@chatbridge/vscode 0.7.0

package/dist/manifest.js

@@ -0,0 +1,54 @@
+export const COMMAND_NAMES = [
+    "login",
+    "logout",
+    "newChat",
+    "installBrowser",
+    "sendSelection",
+    "sendFile",
+    "focus",
+];
+/** The `contributes` IDs a vendor extension must declare for `id`. */
+export function expectedContributions(id) {
+    return {
+        viewContainers: [id],
+        views: [`${id}.chat`],
+        commands: COMMAND_NAMES.map((n) => `${id}.${n}`),
+    };
+}
+function ids(list, key) {
+    const out = new Set();
+    if (Array.isArray(list)) {
+        for (const item of list) {
+            const v = item?.[key];
+            if (typeof v === "string")
+                out.add(v);
+        }
+    }
+    return out;
+}
+/**
+ * The contributes entries a vendor manifest must declare for `id`, that
+ * this package.json lacks. Empty when the manifest is complete.
+ */
+export function missingContributions(packageJSON, id) {
+    const c = (packageJSON
+        ?.contributes ?? {});
+    const expected = expectedContributions(id);
+    const containers = ids(c.viewsContainers?.activitybar, "id");
+    const views = ids(c.views?.[id], "id");
+    const commands = ids(c.commands, "command");
+    const missing = [];
+    for (const v of expected.viewContainers) {
+        if (!containers.has(v))
+            missing.push(`viewsContainers.activitybar: ${v}`);
+    }
+    for (const v of expected.views) {
+        if (!views.has(v))
+            missing.push(`views.${id}: ${v}`);
+    }
+    for (const v of expected.commands) {
+        if (!commands.has(v))
+            missing.push(`commands: ${v}`);
+    }
+    return missing;
+}

package/dist/protocol.d.ts

@@ -0,0 +1,54 @@
+import type { Attachment } from "@chatbridge/core";
+export type Role = "user" | "assistant" | "error" | "separator";
+export interface Message {
+    role: Role;
+    text: string;
+    /** `user` entries: files appended to the prompt, one line each. */
+    attachments?: Attachment[];
+}
+/** closed: no browser. opening: ChatSession.open in flight. idle: ready.
+ * busy: a turn is in flight. dead: fatal error; New chat or Log in recover. */
+export type Status = "closed" | "opening" | "idle" | "busy" | "dead";
+export interface State {
+    status: Status;
+    messages: Message[];
+    pendingAttachments: Attachment[];
+    /** `ChatBridgeError.code` of the error that made the status `dead`. */
+    lastError?: string;
+}
+/** webview → host */
+export type ToHost = {
+    type: "ready";
+} | {
+    type: "send";
+    text: string;
+} | {
+    type: "removeAttachment";
+    index: number;
+} | {
+    type: "command";
+    name: "login" | "newChat" | "installBrowser";
+};
+/** Vendor UI customisation, as the webview receives it. */
+export interface UiConfig {
+    welcome?: string;
+    /** Webview URI (already converted with `asWebviewUri`). */
+    bannerUri?: string;
+    footer?: string;
+    sendButton?: {
+        background?: string;
+        foreground?: string;
+    };
+    userMessage?: {
+        borderColor?: string;
+    };
+}
+/** host → webview */
+export type ToWebview = ({
+    type: "state";
+} & State) | {
+    type: "progress";
+    text: string;
+} | ({
+    type: "config";
+} & UiConfig);

package/dist/protocol.js

@@ -0,0 +1 @@
+export {};

package/dist/session-controller.d.ts

@@ -0,0 +1,77 @@
+import { type Attachment } from "@chatbridge/core";
+import type { State } from "./protocol.js";
+/** What the controller needs from a ChatSession; lets tests inject a fake. */
+export interface ChatSessionLike {
+    send(prompt: string): Promise<string>;
+    close(): Promise<void>;
+    kill(): Promise<void>;
+}
+/** A queued attachment: what the history shows plus the content to send. */
+export interface PendingAttachment extends Attachment {
+    content: string;
+}
+export type SendResult = {
+    ok: true;
+} | {
+    ok: false;
+    code: string;
+    message: string;
+};
+export type AddResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+export interface SessionControllerOptions {
+    /** Opens a ChatSession; called lazily on the first send after `closed`. */
+    openSession: () => Promise<ChatSessionLike>;
+    /** How long newChat / discard / close wait before killing. Default 5 s. */
+    closeTimeoutMs?: number;
+    /** Called with the full state after every change. */
+    onChange?: (state: State) => void;
+    /** Extra line appended to the history entry of a failed turn, keyed by
+     * `ChatBridgeError.code`. Core's messages are CLI-flavoured (`Try
+     * --headful.`); the extension adds the VSCode-side remedy. */
+    hints?: Partial<Record<string, string>>;
+}
+export declare const CLOSE_TIMEOUT_MS = 5000;
+/** Owns the history, the pending attachments and the ChatSession. No
+ * vscode import: the extension wires it to the webview and the commands. */
+export declare class SessionController {
+    private readonly opts;
+    private status;
+    private messages;
+    private pending;
+    private lastError;
+    private session;
+    /** The full prompt of the last send, for retryLast(). */
+    private lastPrompt;
+    private readonly closeTimeoutMs;
+    constructor(opts: SessionControllerOptions);
+    getState(): State;
+    private setStatus;
+    private push;
+    private emit;
+    addAttachment(a: PendingAttachment): AddResult;
+    removeAttachment(index: number): void;
+    /** Sends the text plus the pending attachments as one turn. Never
+     * throws: the outcome is the result and the history. */
+    send(text: string): Promise<SendResult>;
+    /** Re-runs the last prompt after a recoverable fatal error (a missing
+     * browser that was just installed). Drops the trailing error entry so
+     * the history reads user → assistant. */
+    retryLast(): Promise<SendResult>;
+    private runTurn;
+    private fail;
+    private dropSession;
+    /** Ctrl+R of the TUI: drop the browser, mark the break, reopen lazily. */
+    newChat(): Promise<void>;
+    /** Closes the session (if any) and pushes `separator`. Refused (returns
+     * false) while a turn is in flight. Clears a dead state. */
+    discard(separator: string): Promise<boolean>;
+    /** After a successful login command: a dead controller may try again. */
+    markLoggedIn(): void;
+    /** deactivate: close the browser, keep the history. Idempotent. */
+    close(): Promise<void>;
+}

package/dist/session-controller.js

@@ -0,0 +1,198 @@
+import { ChatBridgeError, MAX_FILE_BYTES, MAX_TOTAL_BYTES, closeOrKill, formatAttachment, formatSize, } from "@chatbridge/core";
+export const CLOSE_TIMEOUT_MS = 5_000;
+const EMPTY = {
+    ok: false,
+    code: "EMPTY",
+    message: "Nothing to send.",
+};
+/** Owns the history, the pending attachments and the ChatSession. No
+ * vscode import: the extension wires it to the webview and the commands. */
+export class SessionController {
+    opts;
+    status = "closed";
+    messages = [];
+    pending = [];
+    lastError;
+    session;
+    /** The full prompt of the last send, for retryLast(). */
+    lastPrompt;
+    closeTimeoutMs;
+    constructor(opts) {
+        this.opts = opts;
+        this.closeTimeoutMs = opts.closeTimeoutMs ?? CLOSE_TIMEOUT_MS;
+    }
+    getState() {
+        const state = {
+            status: this.status,
+            messages: this.messages.map((m) => ({
+                ...m,
+                ...(m.attachments ? { attachments: [...m.attachments] } : {}),
+            })),
+            pendingAttachments: this.pending.map(({ path, bytes }) => ({
+                path,
+                bytes,
+            })),
+        };
+        if (this.lastError !== undefined)
+            state.lastError = this.lastError;
+        return state;
+    }
+    setStatus(status) {
+        this.status = status;
+        this.emit();
+    }
+    push(message) {
+        this.messages.push(message);
+        this.emit();
+    }
+    emit() {
+        this.opts.onChange?.(this.getState());
+    }
+    addAttachment(a) {
+        if (a.bytes > MAX_FILE_BYTES) {
+            return {
+                ok: false,
+                reason: `${a.path}: ${Math.ceil(a.bytes / 1024)} KB exceeds ${MAX_FILE_BYTES / 1024} KB`,
+            };
+        }
+        const total = this.pending.reduce((n, p) => n + p.bytes, 0) + a.bytes;
+        if (total > MAX_TOTAL_BYTES) {
+            return {
+                ok: false,
+                reason: `attachments total ${formatSize(total)} exceeds ${formatSize(MAX_TOTAL_BYTES).replace(".0", "")}`,
+            };
+        }
+        this.pending.push(a);
+        this.emit();
+        return { ok: true };
+    }
+    removeAttachment(index) {
+        if (index < 0 || index >= this.pending.length)
+            return;
+        this.pending.splice(index, 1);
+        this.emit();
+    }
+    /** Sends the text plus the pending attachments as one turn. Never
+     * throws: the outcome is the result and the history. */
+    async send(text) {
+        if (this.status === "busy" || this.status === "opening") {
+            return {
+                ok: false,
+                code: "INVALID_STATE",
+                message: "A send is already in progress.",
+            };
+        }
+        const body = text.trim() === "" ? "" : text;
+        if (body === "" && this.pending.length === 0)
+            return EMPTY;
+        const sections = this.pending.map((a) => formatAttachment(a.path, a.content));
+        const prompt = [body, ...sections].filter((s) => s !== "").join("\n\n");
+        const attachments = this.pending.map(({ path, bytes }) => ({
+            path,
+            bytes,
+        }));
+        this.pending = [];
+        this.push({ role: "user", text: body, attachments });
+        this.lastPrompt = prompt;
+        return this.runTurn(prompt);
+    }
+    /** Re-runs the last prompt after a recoverable fatal error (a missing
+     * browser that was just installed). Drops the trailing error entry so
+     * the history reads user → assistant. */
+    async retryLast() {
+        if (this.lastPrompt === undefined)
+            return EMPTY;
+        if (this.status === "busy" || this.status === "opening") {
+            return {
+                ok: false,
+                code: "INVALID_STATE",
+                message: "A send is already in progress.",
+            };
+        }
+        if (this.messages.at(-1)?.role === "error")
+            this.messages.pop();
+        this.lastError = undefined;
+        if (this.status === "dead")
+            this.status = "closed";
+        this.emit();
+        return this.runTurn(this.lastPrompt);
+    }
+    async runTurn(prompt) {
+        // A new turn supersedes whatever killed the previous one: a stale
+        // `lastError` would keep the webview's error banner up after a
+        // successful send from `dead`.
+        this.lastError = undefined;
+        try {
+            if (this.session === undefined) {
+                this.setStatus("opening");
+                this.session = await this.opts.openSession();
+            }
+            this.setStatus("busy");
+            const reply = await this.session.send(prompt);
+            this.messages.push({ role: "assistant", text: reply });
+            this.setStatus("idle");
+            return { ok: true };
+        }
+        catch (err) {
+            return this.fail(err);
+        }
+    }
+    async fail(err) {
+        const code = err instanceof ChatBridgeError ? err.code : "UNKNOWN";
+        const message = err instanceof Error ? err.message : String(err);
+        const hint = this.opts.hints?.[code];
+        this.messages.push({
+            role: "error",
+            text: hint === undefined ? message : `${message}\n${hint}`,
+        });
+        // Show the error before `dropSession` (up to `closeTimeoutMs`) runs.
+        this.emit();
+        if (code === "RESPONSE_TIMEOUT") {
+            this.setStatus("idle");
+        }
+        else {
+            this.lastError = code;
+            await this.dropSession();
+            this.setStatus("dead");
+        }
+        return { ok: false, code, message };
+    }
+    async dropSession() {
+        const old = this.session;
+        this.session = undefined;
+        if (old !== undefined)
+            await closeOrKill(old, this.closeTimeoutMs);
+    }
+    /** Ctrl+R of the TUI: drop the browser, mark the break, reopen lazily. */
+    async newChat() {
+        await this.discard("New chat");
+    }
+    /** Closes the session (if any) and pushes `separator`. Refused (returns
+     * false) while a turn is in flight. Clears a dead state. */
+    async discard(separator) {
+        if (this.status === "busy" || this.status === "opening")
+            return false;
+        await this.dropSession();
+        this.lastError = undefined;
+        // A fresh chat must not re-send a prompt from before the break.
+        this.lastPrompt = undefined;
+        this.status = "closed";
+        this.push({ role: "separator", text: separator });
+        return true;
+    }
+    /** After a successful login command: a dead controller may try again. */
+    markLoggedIn() {
+        if (this.status === "dead") {
+            this.lastError = undefined;
+            this.status = "closed";
+        }
+        this.push({ role: "separator", text: "Logged in" });
+    }
+    /** deactivate: close the browser, keep the history. Idempotent. */
+    async close() {
+        await this.dropSession();
+        if (this.status !== "dead")
+            this.status = "closed";
+        this.emit();
+    }
+}

package/dist/ui-config.d.ts

@@ -0,0 +1,38 @@
+/** Vendor-facing UI customisation, passed as `createExtension({ ui })`. */
+export interface ExtensionUiOptions {
+    /** Shown centred in the empty history until the first message; plain
+     * text, `\n` allowed. */
+    welcome?: string;
+    /** Image path relative to the extension root (png/svg); shown above
+     * `welcome`, same lifetime. Must ship inside the .vsix. */
+    banner?: string;
+    /** One line under the composer, always visible. Plain text. */
+    footer?: string;
+    /** CSS colour strings for the Send button. */
+    sendButton?: {
+        background?: string;
+        foreground?: string;
+    };
+    /** CSS colour string for the border around the user's own messages. */
+    userMessage?: {
+        borderColor?: string;
+    };
+}
+/** Host-side resolved form: `bannerPath` is absolute and already validated.
+ * `ChatViewProvider` turns it into a `bannerUri` per webview. */
+export interface ResolvedUiConfig {
+    welcome?: string;
+    bannerPath?: string;
+    footer?: string;
+    sendButton?: {
+        background?: string;
+        foreground?: string;
+    };
+    userMessage?: {
+        borderColor?: string;
+    };
+}
+/** Validates the vendor's UI options at activation time so a missing banner
+ * fails loudly instead of silently rendering nothing. Pure: the caller
+ * supplies the file-existence check. */
+export declare function resolveUiConfig(ui: ExtensionUiOptions | undefined, extensionRoot: string, exists: (path: string) => boolean): ResolvedUiConfig | undefined;

package/dist/ui-config.js

@@ -0,0 +1,33 @@
+import { isAbsolute, join, normalize, sep } from "node:path";
+/** Validates the vendor's UI options at activation time so a missing banner
+ * fails loudly instead of silently rendering nothing. Pure: the caller
+ * supplies the file-existence check. */
+export function resolveUiConfig(ui, extensionRoot, exists) {
+    if (!ui)
+        return undefined;
+    const config = {};
+    if (ui.welcome !== undefined)
+        config.welcome = ui.welcome;
+    if (ui.footer !== undefined)
+        config.footer = ui.footer;
+    if (ui.sendButton !== undefined)
+        config.sendButton = ui.sendButton;
+    if (ui.userMessage !== undefined)
+        config.userMessage = ui.userMessage;
+    if (ui.banner !== undefined) {
+        const relative = normalize(ui.banner);
+        if (ui.banner.trim() === "" ||
+            isAbsolute(ui.banner) ||
+            relative === "." ||
+            relative === ".." ||
+            relative.startsWith(`..${sep}`)) {
+            throw new Error(`${ui.banner}: banner path must be relative to the extension root`);
+        }
+        const absolute = join(extensionRoot, relative);
+        if (!exists(absolute)) {
+            throw new Error(`${ui.banner}: banner image not found (looked for ${absolute})`);
+        }
+        config.bannerPath = absolute;
+    }
+    return Object.keys(config).length > 0 ? config : undefined;
+}

package/dist/vscode-ui.d.ts

@@ -0,0 +1,30 @@
+import type * as vscode from "vscode";
+export interface EditorSnapshot {
+    /** Workspace-relative, `/`-separated; absolute when outside a workspace. */
+    path: string;
+    text: string;
+    /** Present when the selection is non-empty; lines are 1-based inclusive. */
+    selection?: {
+        text: string;
+        startLine: number;
+        endLine: number;
+    };
+}
+export interface ProgressReporter {
+    report(text: string): void;
+}
+/** The slice of the vscode API the commands use; a fake in unit tests. */
+export interface VscodeUi {
+    showErrorMessage(message: string, ...items: string[]): Promise<string | undefined>;
+    showWarningMessage(message: string): void;
+    showInformationMessage(message: string): void;
+    withProgress<T>(title: string, cancellable: boolean, task: (progress: ProgressReporter, signal: AbortSignal) => Promise<T>): Promise<T>;
+    activeEditor(): EditorSnapshot | undefined;
+    /** Opens the document behind an explorer Uri (or any Uri) read-only. */
+    openDocument(uri: unknown): Promise<{
+        path: string;
+        text: string;
+    }>;
+    focusView(): void;
+}
+export declare function createVscodeUi(api: typeof vscode, id: string): VscodeUi;

package/dist/vscode-ui.js

@@ -0,0 +1,38 @@
+export function createVscodeUi(api, id) {
+    function relPath(uri) {
+        return api.workspace.asRelativePath(uri, false).split("\\").join("/");
+    }
+    return {
+        showErrorMessage: (message, ...items) => Promise.resolve(api.window.showErrorMessage(message, { modal: items.length > 0 }, ...items)),
+        showWarningMessage: (message) => void api.window.showWarningMessage(message),
+        showInformationMessage: (message) => void api.window.showInformationMessage(message),
+        withProgress: (title, cancellable, task) => Promise.resolve(api.window.withProgress({ location: api.ProgressLocation.Notification, title, cancellable }, (progress, token) => {
+            const ac = new AbortController();
+            token.onCancellationRequested(() => ac.abort());
+            return task({ report: (message) => progress.report({ message }) }, ac.signal);
+        })),
+        activeEditor: () => {
+            const editor = api.window.activeTextEditor;
+            if (!editor)
+                return undefined;
+            const doc = editor.document;
+            const snap = {
+                path: relPath(doc.uri),
+                text: doc.getText(),
+            };
+            if (!editor.selection.isEmpty) {
+                snap.selection = {
+                    text: doc.getText(editor.selection),
+                    startLine: editor.selection.start.line + 1,
+                    endLine: editor.selection.end.line + 1,
+                };
+            }
+            return snap;
+        },
+        openDocument: async (uri) => {
+            const doc = await api.workspace.openTextDocument(uri);
+            return { path: relPath(doc.uri), text: doc.getText() };
+        },
+        focusView: () => void api.commands.executeCommand(`${id}.chat.focus`),
+    };
+}