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 divergence/chat@0.2.5
Permissions in 0.2.5
Files
views/composer.ts24.8 KB
// Composer rendering preserves the chat's retained tree and interaction keys.
import { ui, html } from "divergence";
import { findTags, matchMentions } from "../mentions.ts";
import { keywordsIn } from "../workflows.ts";
import type { Element, Chat, ConfigOption, ValueEvent, DropEvent, PasteEvent, SubmitEvent } from "divergence";
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} tooltip=${reason ?? (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("divergence").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}
${renderLimit(v, chat)}
${
c.syncError && !c.syncing
? strip(
html`<icon name="triangle-alert" small tone="warning" />`,
html`<text size="xs" tone="warning">${c.syncError}</text>`,
html`<spacer />`,
html`<button id=${`sync-dismiss-${chatId}`} icon="x" variant="ghost" small tooltip="Dismiss"
onClick=${() => {
c.syncError = undefined;
v.controller.refresh(chatId);
}} />`,
)
: 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}>
${renderPending(v, chat)}
<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>
<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>`,
];
}
// How the new chat page's stage looks: its animated background, or
// without one the transcript's flat background under the same still grain.
export function stageLook(v: ChatView): { ambient: string; grain: boolean } {
const background = v.controller.api.settings.get("landingBackground");
const ambient = background === "fog" || background === "contours" || background === "off" ? background : "caustics";
return { ambient, grain: ambient === "off" && v.controller.api.settings.get("transcriptGrain") === true };
}
// The prompt box. When the first prompt goes it travels from the centre of
// the new chat page to the foot of the transcript, taking the new width on
// the way, with the page's headline and chip riding above it as they fade.
export function dock(chat: Chat, composer: Element | null, above: (Element | null)[] = []): Element {
return html`<div ...${column} id=${`dock-${chat.id}`} travels position="relative">${above}${composer}</div>`;
}
// Where the sent text starts its rise into its message: the message's
// corner when its text lies over the prompt's (the prompt's text sits
// 17.5px by 11.75px into the box, a message's 11px by 7.5px).
export const risingFrom = (chat: Chat) =>
html`<div id=${`rising-${chat.id}`} travels position="absolute" left=${6.5} top=${4.25} />`;
const HEADLINE = { fontSize: "1.875rem", bold: false, weight: 500, fontFamily: "Bricolage Grotesque" };
export function landingHeadline(v: ChatView, chat: Chat, motion?: object): Element {
return html`
<div ...${row} id=${`landing-headline-${chat.id}`} travels motion=${motion} 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>`;
}
// 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.
export function landingChips(v: ChatView, chat: Chat, motion?: object): Element {
return html`
<div ...${row} id=${`landing-chip-${chat.id}`} travels motion=${motion} alignSelf="stretch" gap="small" padding="small">
${workspacePicker(v, chat, "chip", chipAnchor)}
${queuedBadge(v, chat)}
</div>`;
}
export function renderLanding(v: ChatView, chat: Chat, composer = renderComposer(v, chat)): Element | null {
const { ambient, grain } = stageLook(v);
return html`
<div ...${column} ...${fill} ...${full} id="landing-stage" gap="large" padding="large" alignItems="center" justifyContent="center" background=${grain ? undefined : "stage"} grain=${grain} ambient=${ambient}>
${landingHeadline(v, chat)}
<div ...${column} ...${centred} gap="small" padding="small" maxWidth=${768}>
${landingChips(v, chat)}
${dock(chat, composer, [risingFrom(chat)])}
</div>
</div>`;
}Versions
| Version | Published | Plugin API | Size | Permissions | Status |
|---|---|---|---|---|---|
| 0.2.9latest | Nov 21, 2026 | >=5 <6 | 349 KB | 5 permissions | Listed |
| 0.2.8 | Nov 16, 2026 | >=5 <6 | 348.6 KB | 5 permissions | Listed |
| 0.2.7 | Nov 11, 2026 | >=5 <6 | 314.3 KB | 5 permissions | Listed |
| 0.2.6 | Nov 9, 2026 | >=5 <6 | 306.2 KB | 5 permissions | Listed |
| 0.2.5 | Oct 27, 2026 | >=2 <4 | 178.6 KB | 5 permissions | Listed |
No comments yet.