Official

chat

Built-in chat UI (JavaScript UI plugin).

The app opens the listing; nothing installs until an agent in your Plugins workspace has read the files and you enable the plugin. In a terminal: dvg install convergence/chat@0.2.3

Permissions in 0.2.3

  • Control chats chats.controlHighCreates chats, sends prompts and cancels runs.Send prompts, answer agent questions, and create, change, fork, revert, stop and group chats
  • Run other plugins' commands commands.runHighRuns commands of other plugins.Run the sidebar's New chat command from the title bar
  • Read chats chats.readMediumReads your transcripts and chat lists.Show workspaces, tasks, chats and transcripts, and follow them as agents work
  • Read files fs.readMediumReads files in the listed places.Suggest workspace files for @ mentionsPlaces: the open workspace
  • Show panels ui.slotsAlways grantedShows views in the listed parts of the window.Draw the chat grid, the title bar, and the Session panel with its rail buttonSlots: centertitlerailright

Files

views/composer.ts22.7 KB
// Composer rendering preserves the chat's retained tree and interaction keys.
import { ui, html } from "convergence";
import { findTags, matchMentions } from "../mentions.ts";
import { keywordsIn } from "../workflows.ts";
import type { Element, Chat, ConfigOption, ValueEvent, DropEvent, PasteEvent, SubmitEvent } from "convergence";
import type { Composer, AnchorProps } from "../state.ts";
import type { ChatView } from "../controller.ts";
import {
  FIELD_INSET_X,
  PILL_INSET_X,
  column,
  row,
  fill,
  full,
  centred,
  BORDER,
  EDGE_WIDTH,
  corner,
  headlineAnchor,
  chipAnchor,
  markOf,
  RAISED,
} from "./styles.ts";
import { usageMeter, contextMeter } from "./usage.ts";
import { renderLimit, renderPending } from "./pending.ts";
import { steeringReason } from "../composition.ts";
import { acceptPicked, pickerKey } from "../composer.ts";
import { allTasks, isLive } from "../subagents.ts";

// The composer footer's width per chat, from the probe under its pills.
const footerWidths = new Map<string, number>();
// Under this width the agent and approval pills show only their marks.
const ICONS_ONLY_BELOW = 560;
// The approval levels every agent publishes (plugins/sdk/agent.ts), drawn
// as marks when their pill has no room for a label.
const APPROVAL_ICONS: Record<string, string> = {
  supervised: "shield-check",
  auto_edits: "file-pen",
  auto: "shield-half",
  full: "shield-off",
};
export function renderPicker(v: ChatView, chatId: string, c: Composer): Element | null {
  if (!c.picker) return null;
  const note = (text: string) => html`<text style="body" size="xs" tone="muted">${text}</text>`;
  let items;
  if (c.picker.kind === "files") {
    const mentions = matchMentions(v.controller.api.mentions.list(), c.picker.query).map((mention) => ({
      id: `mention-${mention.plugin}-${mention.id}`,
      label: mention.label,
      sublabel: mention.detail ?? `@${mention.token}`,
      icon: mention.icon ?? "bot",
      onClick: () => v.ctx.run(v.controller.acceptMention(chatId, mention)),
    }));
    items = [
      ...mentions,
      ...c.files.map((path) => ({
        id: `file-${path}`,
        label: path,
        icon: "file",
        onClick: () => v.ctx.run(v.controller.acceptFile(chatId, path)),
      })),
    ];
    if (!items.length) return note(c.picker.query ? "No matching files" : "Type to search files");
  } else if (c.picker.kind === "skills") {
    items = v.controller.matchingSkills(c, c.picker.query).map((skill) => ({
      id: `skill-${skill.name}`,
      label: `$${skill.name}`,
      sublabel: skill.description || skill.source,
      icon: "sparkles",
      onClick: () => v.ctx.run(v.controller.acceptSkill(chatId, skill)),
    }));
    if (!items.length) return note("No matching skills");
  } else {
    items = v.controller.matchingCommands(c, c.picker.query).map((cmd) => ({
      id: `cmd-${cmd.name}`,
      label: `/${cmd.name}`,
      sublabel: cmd.description,
      onClick: () => v.ctx.run(v.controller.acceptCommand(chatId, cmd)),
    }));
    if (!items.length) return note("No matching commands");
  }
  return html`<div ...${column} gap="small" padding="small" background="card/40" backdrop=${{ blur: 6 }} borderRadius="md" ...${RAISED}>${ui.list({ id: `picker-${chatId}`, items: items.map((item, index) => ({ ...item, selected: index === (c.picker?.index ?? 0) })) })}</div>`;
}

export function renderComposer(v: ChatView, chat: Chat): Element | null {
  const chatId = chat.id;
  v.ctx.run(v.controller.ensureComposer(chatId));
  const c = v.controller.composer(chatId);
  const running = v.controller.isRunning(chat);
  const preparing = !!c.preparing || v.controller.drafts.loading.has(chatId);
  const snapshot = v.controller.scheduler.snapshots[chatId];
  // The host is resuming this chat's session: Send waits, typing does not.
  const resuming = !!snapshot?.preparing;
  const busy =
    running || snapshot?.settling || allTasks(v.controller.transcript(chatId).items).some((row) => isLive(row.task));
  const reason = steeringReason(v.controller, chat);
  const supportedSimulation = running && v.controller.state.agents[chat.agentId]?.capabilities?.simulatedSteer;
  const enabled = v.controller.state.agentList.map((a) => ({ value: a.id, label: a.name, svg: a.icon }));
  // A pill ellipsizes past its width; the model's names a model and its
  // reasoning, so it gets more room than one value.
  const compact = (select: Element | null, maxWidth = 220) =>
    html`<div ...${row} gap="small" padding="small" maxWidth=${maxWidth} minWidth=${0} flexShrink=${1}>${select}</div>`;
  // A strip over or under the prompt box: a keyword, a queued prompt.
  const strip = (...children: (Element | null)[]) =>
    html`
      <div ...${row} gap="small" padding="small" paddingX=${FIELD_INSET_X} paddingY="small" background="muted" borderRadius="md">${children}</div>`;
  const pills = [];
  // An established conversation changes native attachments, not chat identity.
  // Older Alpha hosts keep their original label after the first prompt.
  const fresh = !chat.sessionId && !v.controller.transcript(chatId).items.length;
  const policyUnavailable = !fresh && !v.controller.canHandoff();
  // A narrow footer keeps every pill on its one line: the agent and the
  // approval give up their labels for their marks first (the label is the
  // tooltip then), the model's ellipsizes.
  const iconsOnly = (footerWidths.get(chatId) ?? Infinity) < ICONS_ONLY_BELOW;
  if ((fresh || v.controller.drafts.available === true) && enabled.length) {
    const tooltip = busy
      ? "Finish current work before changing agents"
      : policyUnavailable
        ? "Select an available conversation policy to change agents"
        : "Continue this conversation with another agent";
    const current = enabled.find((agent) => agent.value === chat.agentId);
    pills.push(
      compact(
        iconsOnly && current?.svg
          ? html`<combobox id=${`agent-${chatId}`} look="toolbar" value=${chat.agentId} label="" marks=${[{ svg: current.svg }]} options=${enabled} disabled=${!!busy || preparing || c.submitting || policyUnavailable} tooltip=${`${current.label}: ${tooltip}`} onChange=${(e: ValueEvent<string>) => v.ctx.run(v.controller.changeAgent(chatId, e.value))} />`
          : html`<select id=${`agent-${chatId}`} value=${chat.agentId} placeholder="Choose an agent" small ghost options=${enabled} disabled=${!!busy || preparing || c.submitting || policyUnavailable} tooltip=${tooltip} onChange=${(e: ValueEvent<string>) => v.ctx.run(v.controller.changeAgent(chatId, e.value))} />`,
      ),
    );
  } else {
    pills.push(
      html`
        <div ...${row} gap="medium" padding="small" paddingX=${PILL_INSET_X}>
          <icon name="bot" small tone="muted" svg=${v.controller.state.agents[chat.agentId]?.icon} />
          <text style="body" size=${12.2} weight=${500} tone="muted" text=${String(v.controller.state.agents[chat.agentId]?.name ?? chat.agentId ?? "")} />
        </div>`,
    );
  }
  // Model, mode, effort, speed and the other settings share one menu;
  // approval (what the agent may do unasked) stays its own pill.
  const options = v.controller.visibleOptions(c);
  const alone = (o: ConfigOption) => o.category === "approval";
  const model = options.find((o) => o.category === "model");
  const together = options.filter((o) => o !== model && !alone(o));
  if (model || together.length) pills.push(compact(v.controller.renderModelPicker(v, chat, model, together), 340));
  for (const option of options.filter(alone)) {
    const choices = (option.choices ?? []).map((ch) => ({ value: ch.value, label: ch.name, svg: ch.icon }));
    const chosen = (option.choices ?? []).find((ch) => ch.value === option.value);
    const mark = chosen?.icon ? { svg: chosen.icon } : { icon: APPROVAL_ICONS[String(option.value)] ?? "shield" };
    pills.push(
      compact(
        iconsOnly && chosen
          ? html`<combobox id=${`opt-${chatId}-${option.id}`} look="toolbar" value=${option.value ?? ""} label="" marks=${[mark]}
              options=${choices} tooltip=${`${option.name}: ${chosen.name}`}
              onChange=${(e: ValueEvent<string>) => v.ctx.run(v.controller.setOption(chatId, option.id, e.value))} />`
          : html`
        <select id=${`opt-${chatId}-${option.id}`} value=${option.value ?? ""} placeholder=${option.name} small ghost
          options=${choices}
          onChange=${(e: ValueEvent<string>) => v.ctx.run(v.controller.setOption(chatId, option.id, e.value))} />`,
      ),
    );
  }
  const queuedChat = v.controller.state.chatQueue.find((q) => q.chatId === chatId);
  // A word the agent reacts to (Claude's "ultracode") says what it will
  // do with this prompt while it is in the text.
  // Each mention tag in the prompt is a segment with a chip that says
  // what it asks for and takes it out again.
  const mentionTags = findTags(c.text, v.controller.api.mentions.list()).map((tag, i) =>
    strip(
      html`<icon name=${tag.mention.icon ?? "bot"} small tone="primary" />`,
      html`<text style="body" size="xs" weight=${600} tone="primary" text=${`@${tag.mention.token}`} />`,
      html`<text style="body" size="xs" tone="muted" truncate text=${String(tag.mention.detail ?? tag.mention.label ?? "")} />`,
      html`<spacer />`,
      html`<button id=${`tag-drop-${chatId}-${i}`} icon="x" variant="ghost" small tooltip="Remove this tag" onClick=${() => v.ctx.run(v.controller.dropTag(chatId, tag))} />`,
    ),
  );
  const keywords = keywordsIn(c.text, v.controller.state.agents[chat.agentId]?.promptKeywords).map((keyword) =>
    strip(
      html`<icon name="workflow" small tone="primary" />`,
      html`<text style="body" size="xs" weight=${600} tone="primary">${keyword.label}</text>`,
      keyword.description
        ? html`<text style="body" size="xs" tone="muted" truncate>${keyword.description}</text>`
        : null,
    ),
  );
  const attach = html`<button id=${`attach-${chatId}`} icon="paperclip" variant="ghost" small tooltip="Attach an image" onClick=${() => v.ctx.run(v.controller.pickAttachments(chatId))} />`;
  // A draft queues the chat, a started chat its prompts. While the agent
  // works, what was typed turns Stop into Send, which steers.
  const draft = v.controller.isDraft(chat);
  const typed = !!c.text.trim() || c.attachments.length > 0 || !!c.carriedBlocks?.length;
  // Pinned to the card's bottom right, as far from its bottom as from its
  // side, however many lines the prompt has.
  const action = html`
        <div ...${row} gap="small" padding="medium" alignSelf="end">
          ${attach}
          ${
            draft
              ? queuedChat
                ? null
                : html`<button id=${`queue-chat-${chatId}`} icon="list-plus" variant="ghost" small tooltip="Queue this chat: it starts when no other chat runs (⌘Enter / Ctrl+Enter)" onClick=${() => v.ctx.run(v.controller.queueChat(chatId))} />`
              : html`<button id=${`queue-${chatId}`} icon="list-plus" variant="ghost" small disabled=${c.loading || c.submitting || preparing || resuming} tooltip="Hold this prompt in FIFO order (⌘Enter / Ctrl+Enter), even while idle" onClick=${() => v.ctx.run(v.controller.queuePrompt(chatId))} />`
          }
          ${
            running && !typed
              ? html`<button id=${`stop-${chatId}`} icon="square" variant="danger" small tooltip="Stop (⌘⇧C); retain and pause follow-ups" onClick=${() => v.ctx.run(v.controller.scheduler.stop(chatId))} />`
              : resuming
                ? html`<div ...${row} id=${`send-preparing-${chatId}`} gap="small" padding="small">${c.sendWhenReady !== undefined ? html`<text style="body" size="xs" tone="muted">Sends when ready</text>` : null}<spinner /></div>`
                : html`<button id=${`send-${chatId}`} icon="corner-down-left" variant="primary" small disabled=${!!reason || c.loading || c.submitting || preparing || !!c.syncing} tooltip=${reason ?? (c.syncing ? "Syncing with the agent's history…" : null) ?? (supportedSimulation ? "Interrupt tools, settle and send in the same session (Enter)" : running ? "Steer ongoing work (Enter)" : "Send (Enter)")} onClick=${() => v.ctx.run(v.controller.send(chatId))} />`
          }
        </div>`;
  const queued = [
    ...c.queue.map(({ text, attachments, blocks }, i) =>
      strip(
        html`<icon name="list-plus" small tone="muted" />`,
        html`<text style="body" size="xs" tone="muted">${`Held on older app · ${text || `${blocks?.filter((block) => block.type === "image").length ?? attachments.length} images`}`}</text>`,
        html`<spacer />`,
        html`<button id=${`drop-${chatId}-${i}`} icon="x" variant="ghost" small tooltip="Remove" onClick=${() => v.ctx.run(v.controller.dropQueuedPrompt(chatId, i))} />`,
      ),
    ),
  ];

  // Images waiting to go with the prompt, each with the thumbnail the
  // kernel draws from the bytes it is holding.
  // An image chip sits a medium inset from the prompt box's top and left,
  // as the send button does from its top and right, so it shares the box's
  // `xl` corner centre: the field corner. Its thumbnail is concentric with
  // the default theme's field corner (8px) in turn.
  const CHIP_RADIUS = corner("field", 8);
  const attachments = c.attachments.length
    ? html`
        <div ...${row} gap="small" padding="medium" flexWrap="wrap">
          ${c.attachments.map(
            (image) =>
              html`
            <div ...${row} gap="small" padding=${4} maxWidth=${240} background="subtle" borderRadius=${CHIP_RADIUS} ...${RAISED}>
              <image id=${image.id} width=${36} height=${36} radius=${8 - 4 - EDGE_WIDTH} />
              <div ...${column} ...${fill} paddingX="small">
                <text style="body" size="xs" truncate text=${String(image.name ?? "")} />
                <text style="body" size="xs" tone="muted">${`${Math.max(1, Math.round(image.bytes / 1024))} KB`}</text>
              </div>
              <div alignSelf="start">
                <button id=${`attach-drop-${chatId}-${image.id}`} icon="x" variant="ghost" small tooltip=${`Remove ${image.name}`}
                  onClick=${() => v.ctx.run(v.controller.removeAttachment(chatId, image.id))} />
              </div>
            </div>`,
          )}
        </div>`
    : null;

  // An open picker moves with up and down, closes with Escape and takes
  // its highlighted entry with Tab (Enter in onSubmit). The prompt hands
  // those keys over (`keys`): it would act on them itself first.
  const pickerKeys = c.picker ? ["up", "down", "tab", "escape"] : [];
  const onPickerKey = (event: import("convergence").KeyEvent) => {
    if (event.modifiers.meta || event.modifiers.ctrl || event.modifiers.alt || event.modifiers.shift) return;
    if (event.key === "tab") v.ctx.run(acceptPicked(v.controller, chatId, false));
    else pickerKey(v.controller, chatId, event.key);
  };
  // Images dropped from Finder or a browser, and images pasted into the
  // prompt, become attachments; other files become @ mentions. Typing
  // with nothing focused lands in the prompt.
  return html`
      <div ...${column} id=${`composer-${chatId}`} gap="small" padding="small" position="relative"
        onKeyDown=${onPickerKey}
        drop=${{ files: true, onDrop: (event: DropEvent) => v.ctx.run(v.controller.attachFiles(chatId, "paths" in event ? event.paths : [])) }}
        onPaste=${(event: PasteEvent) => v.ctx.run(v.controller.onPasteFiles(chatId, event))}>
        ${renderPicker(v, chatId, c)}
        ${mentionTags}
        ${keywords}
        ${queued}
        ${renderPending(v, chat)}
        ${renderLimit(v, chat)}
        ${c.syncing ? strip(html`<spinner />`, html`<text size="xs" tone="muted">Syncing…</text>`) : null}
        ${c.syncError && !c.syncing ? strip(html`<icon name="triangle-alert" small tone="warning" />`, html`<text size="xs" tone="warning">${c.syncError}</text>`) : null}
        ${c.preparing ? strip(html`<spinner />`, html`<text size="xs" tone="muted">Preparing conversation · no prompt is being sent</text>`) : null}
        ${snapshot?.context && ["pending", "dispatching", "delivery_unknown"].includes(snapshot.context.state) ? strip(html`<icon name="rotate-ccw" small tone="muted" />`, html`<text size="xs" tone=${snapshot.context.state === "delivery_unknown" ? "warning" : "muted"}>${snapshot.context.state === "pending" ? "History prepared · delivered with your next Send" : snapshot.context.state === "delivery_unknown" ? "History delivery is unknown · automatic replay is blocked" : "History delivery in progress"}</text>`) : null}
        ${reason ? html`<text style="body" size="xs" tone="muted">${reason}</text>` : null}
        ${c.submitting && !c.error && !c.dispatching && !c.outgoing?.preview && !c.outgoing?.intent ? html`<div ...${row} gap="small"><spinner /><text tone="muted" size="xs">Submitting…</text></div>` : null}
        ${c.recovered?.map(
          (recovered) => html`<div ...${column} gap="small" padding="small" background="muted" borderRadius="md">
          <text size="xs">${recovered.text || `${recovered.attachments.length} images`}</text>
          <button id=${`recover-${recovered.submission.id}`} label="Restore failed input" small disabled=${typed || c.submitting} onClick=${() => {
            c.text = recovered.text;
            c.attachments = recovered.attachments;
            c.carriedBlocks = recovered.carriedBlocks;
            c.submission = recovered.submission;
            c.recovered = c.recovered?.filter((input) => input !== recovered);
            v.ctx.run(v.controller.onChange(chatId, c.text));
            v.ctx.run(v.controller.drafts.holdImages(chatId));
            v.ctx.update();
          }} />
        </div>`,
        )}
        ${v.controller.scheduler.available === false && c.queue.length ? html`<text style="body" size="xs" tone="muted">Follow-ups are retained. Automatic release and active steering require an updated app.</text>` : null}
        <div ...${column} background="card/40" backdrop=${{ blur: 6 }} borderRadius="xl" ...${RAISED}>
          ${attachments}
          ${(c.carriedBlocks ?? []).map((block, index) =>
            strip(
              html`<icon name=${block.type === "image" ? "image" : "paperclip"} small tone="muted" />`,
              html`<text size="xs" tone="muted">${block.type === "image" || block.type === "audio" ? `${block.type} · ${block.mimeType}` : block.type === "file_ref" || block.type === "resource" ? block.path : block.type === "skill" ? `$${block.name}` : "Attachment"}</text>`,
              html`<spacer />`,
              html`<button id=${`carried-drop-${chatId}-${index}`} icon="x" small variant="ghost" disabled=${preparing} tooltip="Remove attachment" onClick=${() => {
                c.carriedBlocks = c.carriedBlocks?.filter((_, at) => at !== index);
                v.ctx.run(v.controller.textChanged(chatId));
                v.ctx.update();
              }} />`,
            ),
          )}
          <div ...${row}>
            <div ...${column} ...${fill} gap="small" padding="small" paddingY=${0}>
              <input id=${`prompt-${chatId}`} value=${c.text} multiline ghost submitOnEnter catchTyping=${v.controller.state.mainPrompt === chatId} disabled=${!!c.preparing} keys=${pickerKeys} onKey=${onPickerKey}
                placeholder=${`${v.controller.api.mentions.list().length ? "@ files and agents" : "@ files"}, / commands${c.skills.length ? ", $ skills" : ""}`}
                onChange=${(e: ValueEvent<string>) => v.ctx.run(v.controller.onChange(chatId, e.value))}
                onSubmit=${(event?: SubmitEvent) => v.ctx.run(v.controller.onSubmit(chatId, event))} />
            </div>
            ${action}
          </div>
        </div>
        <div ...${row} gap="small" paddingY="small" position="relative">
          <canvas id=${`toolbar-${chatId}`} position="absolute" left=${0} right=${0} top=${0} height=${1}
            onResize=${({ width }: { width: number }) => {
              const before = (footerWidths.get(chatId) ?? Infinity) < ICONS_ONLY_BELOW;
              footerWidths.set(chatId, width);
              if (before !== width < ICONS_ONLY_BELOW) v.controller.refreshComposer(chatId);
            }} />
          <div ...${row} ...${fill} gap="small" minWidth=${0} overflow="hidden">${pills}</div>
          ${usageMeter(v, chat)}
          ${contextMeter(v, chat)}
        </div>
      </div>`;
}

export function workspacePicker(
  v: ChatView,
  chat: Chat,
  place: string,
  anchor: (props: AnchorProps) => Element,
): Element | null {
  const id = `ws-${place}-${chat.id}`;
  const list = Object.values(v.controller.state.workspaces);
  const can = !chat.sessionId && list.length > 1;
  const current = v.controller.state.workspaces[chat.workspaceId];
  const trigger = anchor({ name: current?.name ?? "this workspace", mark: markOf(current), can });
  if (!can) return trigger;
  return html`
      <combobox id=${id} look="toolbar" value=${chat.workspaceId} width=${320}
        options=${list.map((w) => ({ value: w.id, label: w.name, description: w.path, ...markOf(w) }))}
        onChange=${(e: { value?: string }) => {
          if (e.value && e.value !== chat.workspaceId) v.ctx.run(v.controller.moveDraft(chat, e.value));
        }}>
        ${trigger}
      </combobox>`;
}

// A queued draft says so on the right of the workspace chip; the prompt
// below stays editable until the queue sends it.
function queuedBadge(v: ChatView, chat: Chat): Element[] | null {
  const index = v.controller.state.chatQueue.findIndex((queued) => queued.chatId === chat.id);
  if (index < 0) return null;
  const total = v.controller.state.chatQueue.length;
  return [
    html`<spacer />`,
    html`
      <div ...${row} gap="small" paddingX=${PILL_INSET_X}>
        <icon name="list-plus" small tone="info" />
        <text style="body" size="xs" weight=${500} tone="muted" text=${total > 1 ? `Queued · ${index + 1} of ${total}` : "Queued"} />
        <button id=${`unqueue-${chat.id}`} icon="x" variant="ghost" small tooltip="Remove from the queue" onClick=${() => v.ctx.run(v.controller.unqueueChat(chat.id))} />
      </div>`,
  ];
}

export function renderLanding(v: ChatView, chat: Chat, composer = renderComposer(v, chat)): Element | null {
  const headline = { fontSize: "1.875rem", bold: false, weight: 500, fontFamily: "Bricolage Grotesque" };
  // The chip is the same picker, not a label: it sits where the eye is
  // already going, so it has to answer a press like the headline.
  return html`
      <div ...${column} ...${fill} ...${full} gap="large" padding="large" alignItems="center" justifyContent="center" background="stage">
        <div ...${row} gap=${0} padding="small" justifyContent="center">
          <text style="body" ...${headline}>What should we do in</text>
          ${workspacePicker(v, chat, "landing", headlineAnchor(headline))}
          <text style="body" ...${headline}>?</text>
        </div>
        <div ...${column} ...${centred} gap="small" padding="small" maxWidth=${768}>
          <div ...${row} gap="small" padding="small">
            ${workspacePicker(v, chat, "chip", chipAnchor)}
            ${queuedBadge(v, chat)}
          </div>
          ${composer}
        </div>
      </div>`;
}

Versions

VersionPublishedPlugin APISizePermissionsStatus
0.2.5latestNov 21, 2026>=2 <4174.6 KB5 permissionsListed
0.2.4Oct 25, 2026>=2 <4174.2 KB5 permissionsListed
0.2.3Oct 24, 2026>=2 <4165.4 KB5 permissionsListed
0.2.2Oct 23, 2026>=2 <4165 KB5 permissionsListed
0.2.1Oct 6, 2026>=2 <3111.8 KB5 permissionsListed
0.2.0Oct 5, 2026>=2 <3105.1 KB5 permissionsListed

Reviews and comments

0 threads · 0 reviews

No comments yet.