@chatbridge/vscode 0.8.0 → 0.8.2

package/README.md

@@ -61,6 +61,23 @@ export const { activate, deactivate } = createExtension({
 - `baseDir` — test-only override for the base directory of the config /
   auth-state store.
 
+## Composer
+
+- **Enter** sends. While a turn is in flight the message is queued instead
+  and drains in order once the turn finishes; Shift+Enter inserts a newline.
+- **Up** on an empty composer takes the last queued message back for
+  editing; queued entries can also be removed individually.
+- **`/` commands** — `/login`, `/logout`, `/new`, `/reopen`, `/help`, the
+  same table the TUI uses. Only the bare form on its own counts, so
+  anything else (including `/usr/bin` style paths) is sent verbatim.
+- **Drop files** onto the composer to add them as attachment chips. Hold
+  **Shift** while dropping: without it VSCode keeps the drag for itself and
+  opens the file in an editor instead (the same rule as dropping into a text
+  editor).
+- **Paste** text copied from an editor selection and it becomes a selection
+  chip (`path:L2-L3`) instead of inline text; unrelated clipboard text is
+  pasted as usual.
+
 ## Manifest
 
 The vendor's `package.json` must contribute, with `<id>` replaced by the
@@ -68,7 +85,7 @@ The vendor's `package.json` must contribute, with `<id>` replaced by the
 
 - View `<id>.chat` (a webview, typically under its own `viewsContainers`
   entry)
-- Commands `<id>.login`, `<id>.logout`, `<id>.newChat`,
+- Commands `<id>.login`, `<id>.logout`, `<id>.newChat`, `<id>.reopen`,
   `<id>.installBrowser`, `<id>.sendSelection`, `<id>.sendFile`, `<id>.focus`
 - Settings `<id>.headless` (boolean) and `<id>.timeoutSec` (number)
 
@@ -78,7 +95,22 @@ missing ID:
 - `contributes.viewsContainers.activitybar[]` contains an entry with
   `id === <id>`
 - `contributes.views.<id>[]` contains an entry with `id === <id>.chat`
-- `contributes.commands[]` contains all seven `<id>.*` commands above
+- `contributes.commands[]` contains all eight `<id>.*` commands above
+
+A `keybindings` entry is recommended so Ctrl+R (Cmd+R on macOS) reopens the
+browser while the chat view is focused; it is not validated. The webview
+also handles the shortcut itself when the composer has focus.
+
+```json
+"keybindings": [
+  {
+    "command": "<id>.reopen",
+    "key": "ctrl+r",
+    "mac": "cmd+r",
+    "when": "focusedView == <id>.chat"
+  }
+]
+```
 
 `contributes.configuration` is not validated: a missing `<id>.headless` or
 `<id>.timeoutSec` setting simply falls back to the `createExtension`

package/dist/chat-view-bridge.d.ts

@@ -1,4 +1,4 @@
-import type { State, ToHost, ToWebview, UiConfig } from "./protocol.js";
+import type { QueueEntry, State, ToHost, ToWebview, UiConfig, WebviewCommand } from "./protocol.js";
 /** The slice of vscode.Webview the bridge uses; a fake in tests. */
 export interface WebviewLike {
     postMessage(message: ToWebview): Thenable<boolean>;
@@ -9,8 +9,14 @@ export interface WebviewLike {
 export interface ChatViewHandlers {
     send(text: string): void;
     removeAttachment(index: number): void;
-    command(name: "login" | "newChat" | "installBrowser"): void;
+    takeBack(): void;
+    removeQueued(index: number): void;
+    command(name: WebviewCommand): void;
+    attachUris(uris: string[]): void;
+    pasted(id: number, text: string): void;
 }
+/** Every command the webview may post; the bridge rejects the rest. */
+export declare const COMMAND_LIST: ("help" | "login" | "logout" | "newChat" | "installBrowser" | "reopen")[];
 /** Translates webview messages into handler calls and pushes state to
  * whichever webview is currently attached (VSCode recreates it). */
 export declare class ChatViewBridge {
@@ -22,5 +28,7 @@ export declare class ChatViewBridge {
         dispose(): void;
     };
     pushState(state: State): void;
+    pushPasteResult(id: number, attached: boolean): void;
+    pushTookBack(entries: QueueEntry[]): void;
     pushProgress(text: string): void;
 }

package/dist/chat-view-bridge.js

@@ -1,3 +1,13 @@
+/** Every command the webview may post; the bridge rejects the rest. */
+export const COMMAND_LIST = [
+    "login",
+    "logout",
+    "newChat",
+    "installBrowser",
+    "reopen",
+    "help",
+];
+const COMMANDS = new Set(COMMAND_LIST);
 function isToHost(m) {
     if (typeof m !== "object" || m === null)
         return false;
@@ -9,10 +19,16 @@ function isToHost(m) {
             return typeof msg.text === "string";
         case "removeAttachment":
             return typeof msg.index === "number";
+        case "takeBack":
+            return true;
+        case "removeQueued":
+            return typeof msg.index === "number";
         case "command":
-            return (msg.name === "login" ||
-                msg.name === "newChat" ||
-                msg.name === "installBrowser");
+            return typeof msg.name === "string" && COMMANDS.has(msg.name);
+        case "attachUris":
+            return (Array.isArray(msg.uris) && msg.uris.every((u) => typeof u === "string"));
+        case "pasted":
+            return typeof msg.id === "number" && typeof msg.text === "string";
         default:
             return false;
     }
@@ -44,9 +60,21 @@ export class ChatViewBridge {
                 case "removeAttachment":
                     this.handlers.removeAttachment(raw.index);
                     break;
+                case "takeBack":
+                    this.handlers.takeBack();
+                    break;
+                case "removeQueued":
+                    this.handlers.removeQueued(raw.index);
+                    break;
                 case "command":
                     this.handlers.command(raw.name);
                     break;
+                case "attachUris":
+                    this.handlers.attachUris(raw.uris);
+                    break;
+                case "pasted":
+                    this.handlers.pasted(raw.id, raw.text);
+                    break;
             }
         });
         return {
@@ -60,6 +88,12 @@ export class ChatViewBridge {
     pushState(state) {
         void this.webview?.postMessage({ type: "state", ...state });
     }
+    pushPasteResult(id, attached) {
+        void this.webview?.postMessage({ type: "pasteResult", id, attached });
+    }
+    pushTookBack(entries) {
+        void this.webview?.postMessage({ type: "tookBack", entries });
+    }
     pushProgress(text) {
         void this.webview?.postMessage({ type: "progress", text });
     }

package/dist/commands.d.ts

@@ -17,11 +17,18 @@ export interface CommandHandlers {
     login(): Promise<void>;
     logout(): Promise<void>;
     newChat(): Promise<void>;
+    reopen(): Promise<void>;
     installBrowser(): Promise<void>;
+    /** From the webview's `/help`: the listing joins the history. */
+    help(): void;
     sendSelection(): Promise<void>;
     sendFile(uri: unknown): Promise<void>;
     focus(): void;
     /** From the webview's input box. */
     send(text: string): Promise<void>;
+    /** Files dropped on the webview; unreadable URIs are reported together. */
+    attachUris(uris: string[]): Promise<void>;
+    /** A paste into the input box; true when it became a selection chip. */
+    pasted(text: string): boolean;
 }
 export declare function createCommands(deps: CommandDeps): CommandHandlers;

package/dist/commands.js

@@ -1,7 +1,11 @@
 import { LoginAbortedError } from "@chatbridge/core";
+import { helpText } from "@chatbridge/core/slash-commands";
 function utf8Bytes(text) {
     return new TextEncoder().encode(text).byteLength;
 }
+/** Pasted text arrives with the platform's line endings; the editor's
+ * selection text does not. Compare them on the same footing. */
+const normalise = (s) => s.replace(/\r\n/g, "\n");
 function message(err) {
     return err instanceof Error ? err.message : String(err);
 }
@@ -9,7 +13,7 @@ export function createCommands(deps) {
     const { controller, ui } = deps;
     function isBusy() {
         const status = controller.getState().status;
-        return status === "busy" || status === "opening";
+        return status === "busy" || status === "opening" || status === "reopening";
     }
     async function runInstall() {
         try {
@@ -66,13 +70,28 @@ export function createCommands(deps) {
             }
         },
         async logout() {
-            if (!(await controller.discard("Logged out"))) {
+            if (isBusy()) {
                 ui.showWarningMessage("Wait for the current reply to finish, then log out.");
                 return;
             }
+            // The auth state goes first: `discard` drains the queue, and a queued
+            // entry would otherwise reopen the browser — and send — under the
+            // credentials the user just asked to delete.
             await deps.clearAuth();
+            if (!(await controller.discard("Logged out"))) {
+                // A turn started while the auth state was being deleted. The file
+                // is gone either way; only the session is still open, so warn about
+                // that alone.
+                ui.showWarningMessage("Wait for the current reply to finish, then log out.");
+            }
+        },
+        async newChat() {
+            if (!(await controller.newChat())) {
+                ui.showWarningMessage("Wait for the current reply to finish, or press Ctrl+R to reopen.");
+            }
         },
-        newChat: () => controller.newChat(),
+        reopen: () => controller.reopen(),
+        help: () => controller.pushHelp(helpText()),
         async installBrowser() {
             if (await runInstall())
                 ui.showInformationMessage("Chromium installed.");
@@ -87,6 +106,10 @@ export function createCommands(deps) {
         },
         async sendFile(uri) {
             if (uri !== undefined && uri !== null) {
+                if (!ui.isUri(uri)) {
+                    ui.showWarningMessage("Nothing to attach.");
+                    return;
+                }
                 const doc = await ui.openDocument(uri);
                 attach(doc.path, doc.text);
                 return;
@@ -99,6 +122,31 @@ export function createCommands(deps) {
             attachEditor(editor, false);
         },
         focus: () => ui.focusView(),
+        async attachUris(uris) {
+            const skipped = [];
+            for (const raw of new Set(uris)) {
+                try {
+                    const doc = await ui.openDocument(ui.parseUri(raw));
+                    attach(doc.path, doc.text);
+                }
+                catch {
+                    skipped.push(raw);
+                }
+            }
+            if (skipped.length > 0) {
+                ui.showWarningMessage(`Skipped: ${skipped.join(", ")}`);
+            }
+        },
+        pasted(text) {
+            const editor = ui.activeEditor();
+            const selection = editor?.selection;
+            if (!editor || !selection || selection.text.trim() === "")
+                return false;
+            if (normalise(text) !== normalise(selection.text))
+                return false;
+            attachEditor(editor, true);
+            return true;
+        },
         async send(text) {
             const result = await controller.send(text);
             if (result.ok || result.code !== "BROWSER_UNAVAILABLE")

package/dist/create-extension.d.ts

@@ -1,5 +1,6 @@
 import { type Provider } from "@chatbridge/core";
 import * as vscode from "vscode";
+import { type CommandHandlers } from "./commands.js";
 import { SessionController } from "./session-controller.js";
 import { type ExtensionUiOptions } from "./ui-config.js";
 export interface CreateExtensionOptions {
@@ -26,6 +27,8 @@ export interface CreateExtensionOptions {
 /** What `activate` returns: the E2E drives the controller directly. */
 export interface ExtensionApi {
     controller: SessionController;
+    /** The E2E drives the command handlers directly. */
+    handlers: CommandHandlers;
 }
 export declare function createExtension(opts: CreateExtensionOptions): {
     activate: (context: vscode.ExtensionContext) => Promise<ExtensionApi>;

package/dist/create-extension.js

@@ -8,6 +8,7 @@ import { createCommands } from "./commands.js";
 import { installBrowser } from "./install-browser.js";
 import { COMMAND_NAMES, missingContributions } from "./manifest.js";
 import { SessionController } from "./session-controller.js";
+import { parseTimeoutSec } from "./timeout-setting.js";
 import { resolveUiConfig } from "./ui-config.js";
 import { createVscodeUi } from "./vscode-ui.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
@@ -30,13 +31,35 @@ export function createExtension(opts) {
         const bridge = new ChatViewBridge(() => controller.getState(), {
             send: (text) => void handlers.send(text),
             removeAttachment: (i) => controller?.removeAttachment(i),
+            takeBack: () => {
+                const r = controller?.takeBack();
+                if (!r)
+                    return;
+                // `takeBack()` has already emitted a `state` with the queue
+                // empty; the webview fills the composer from `tookBack` alone,
+                // so this arriving second does not matter.
+                bridge.pushTookBack(r.entries);
+                if (r.droppedAttachments > 0) {
+                    void vscode.window.showWarningMessage(`${r.droppedAttachments} attachment(s) left out: total size limit.`);
+                }
+            },
+            removeQueued: (i) => controller?.removeQueued(i),
             command: (name) => void handlers[name](),
+            attachUris: (uris) => void handlers.attachUris(uris),
+            pasted: (id, text) => bridge.pushPasteResult(id, handlers.pasted(text)),
         });
+        let warnedTimeout = false;
         function settings() {
             const cfg = vscode.workspace.getConfiguration(opts.id);
+            const fallbackMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+            const { timeoutMs, invalid } = parseTimeoutSec(cfg.get("timeoutSec"), fallbackMs);
+            if (invalid && !warnedTimeout) {
+                warnedTimeout = true;
+                void vscode.window.showWarningMessage(`${opts.displayName}: "${opts.id}.timeoutSec" must be a positive number; using ${fallbackMs / 1000} s.`);
+            }
             return {
                 headless: cfg.get("headless", opts.headless ?? true),
-                timeoutMs: cfg.get("timeoutSec", (opts.timeoutMs ?? DEFAULT_TIMEOUT_MS) / 1000) * 1000,
+                timeoutMs,
             };
         }
         function progress(message) {
@@ -53,10 +76,13 @@ export function createExtension(opts) {
             }),
             hints: {
                 BLOCKED: `Set the "${opts.id}.headless" setting to false and try again.`,
+                BROWSER_UNAVAILABLE: `Run "${opts.displayName}: Install Browser" and send again.`,
             },
             onChange: (state) => {
                 bridge.pushState(state);
-                if (state.status === "busy" || state.status === "opening")
+                if (state.status === "busy" ||
+                    state.status === "opening" ||
+                    state.status === "reopening")
                     statusBar.show();
                 else
                     statusBar.hide();
@@ -83,7 +109,7 @@ export function createExtension(opts) {
         for (const name of COMMAND_NAMES) {
             context.subscriptions.push(vscode.commands.registerCommand(`${opts.id}.${name}`, (arg) => name === "sendFile" ? handlers.sendFile(arg) : handlers[name]()));
         }
-        return { controller };
+        return { controller, handlers };
     }
     async function deactivate() {
         await controller?.close();

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./protocol.js";
-export { type AddResult, type ChatSessionLike, type PendingAttachment, type SendResult, SessionController, type SessionControllerOptions, } from "./session-controller.js";
+export { type AddResult, type ChatSessionLike, type HintCode, type PendingAttachment, type SendResult, SessionController, type SessionControllerOptions, type TakeBackResult, } from "./session-controller.js";
 export { type ChildLike, installBrowser, type InstallBrowserOptions, type SpawnFn, splitProgressLines, } from "./install-browser.js";
 export { COMMAND_NAMES, type CommandName, expectedContributions, missingContributions, } from "./manifest.js";
 export { ChatViewBridge, type ChatViewHandlers, type WebviewLike, } from "./chat-view-bridge.js";

package/dist/manifest.d.ts

@@ -1,4 +1,4 @@
-export declare const COMMAND_NAMES: readonly ["login", "logout", "newChat", "installBrowser", "sendSelection", "sendFile", "focus"];
+export declare const COMMAND_NAMES: readonly ["login", "logout", "newChat", "reopen", "installBrowser", "sendSelection", "sendFile", "focus"];
 export type CommandName = (typeof COMMAND_NAMES)[number];
 /** The `contributes` IDs a vendor extension must declare for `id`. */
 export declare function expectedContributions(id: string): {

package/dist/manifest.js

@@ -2,6 +2,7 @@ export const COMMAND_NAMES = [
     "login",
     "logout",
     "newChat",
+    "reopen",
     "installBrowser",
     "sendSelection",
     "sendFile",

package/dist/protocol.d.ts

@@ -1,5 +1,5 @@
 import type { Attachment } from "@chatbridge/core";
-export type Role = "user" | "assistant" | "error" | "separator";
+export type Role = "user" | "assistant" | "error" | "separator" | "help";
 export interface Message {
     role: Role;
     text: string;
@@ -7,15 +7,26 @@ export interface Message {
     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";
+ * busy: a turn is in flight. reopening: Ctrl+R is replacing the browser.
+ * dead: fatal error; New chat, Log in or Reopen recover. */
+export type Status = "closed" | "opening" | "idle" | "busy" | "reopening" | "dead";
+/** A message waiting for its turn: sent while the controller was not idle. */
+export interface QueueEntry {
+    text: string;
+    attachments: Attachment[];
+}
 export interface State {
     status: Status;
     messages: Message[];
     pendingAttachments: Attachment[];
+    /** Oldest first; drained one entry per turn end. */
+    queue: QueueEntry[];
     /** `ChatBridgeError.code` of the error that made the status `dead`. */
     lastError?: string;
 }
+export type WebviewCommand = "login" | "logout" | "newChat" | "installBrowser" | "reopen"
+/** Webview only: the host answers with a `help` history entry. */
+ | "help";
 /** webview → host */
 export type ToHost = {
     type: "ready";
@@ -25,9 +36,25 @@ export type ToHost = {
 } | {
     type: "removeAttachment";
     index: number;
+} | {
+    type: "takeBack";
+} | {
+    type: "removeQueued";
+    index: number;
 } | {
     type: "command";
-    name: "login" | "newChat" | "installBrowser";
+    name: WebviewCommand;
+}
+/** Files dropped on the webview, as URI strings. */
+ | {
+    type: "attachUris";
+    uris: string[];
+}
+/** A paste into the input box; `id` pairs it with its `pasteResult`. */
+ | {
+    type: "pasted";
+    id: number;
+    text: string;
 };
 /** Vendor UI customisation, as the webview receives it. */
 export interface UiConfig {
@@ -51,4 +78,15 @@ export type ToWebview = ({
     text: string;
 } | ({
     type: "config";
-} & UiConfig);
+} & UiConfig)
+/** Answer to `pasted`: when attached, the webview drops the pasted text. */
+ | {
+    type: "pasteResult";
+    id: number;
+    attached: boolean;
+}
+/** Answer to `takeBack`: the entries removed from the queue. */
+ | {
+    type: "tookBack";
+    entries: QueueEntry[];
+};

package/dist/session-controller.d.ts

@@ -1,5 +1,5 @@
 import { type Attachment } from "@chatbridge/core";
-import type { State } from "./protocol.js";
+import type { QueueEntry, State } from "./protocol.js";
 /** What the controller needs from a ChatSession; lets tests inject a fake. */
 export interface ChatSessionLike {
     send(prompt: string): Promise<string>;
@@ -12,17 +12,30 @@ export interface PendingAttachment extends Attachment {
 }
 export type SendResult = {
     ok: true;
+    queued?: true;
 } | {
     ok: false;
     code: string;
     message: string;
 };
+/** The separator pushed into the history by `reopen()`. */
+export declare const REOPENED_SEPARATOR = "reopened";
 export type AddResult = {
     ok: true;
 } | {
     ok: false;
     reason: string;
 };
+/** Error codes the extension can attach a remedy to. */
+export type HintCode = "BLOCKED" | "BROWSER_UNAVAILABLE" | "AUTH_REQUIRED" | "AUTH_EXPIRED" | "RESPONSE_TIMEOUT";
+export interface TakeBackResult {
+    /** Every entry that was queued. `entries[i].attachments` lists everything
+     * that entry carried, including attachments that were *not* restored to
+     * pending: only their number is reported, in `droppedAttachments`. */
+    entries: QueueEntry[];
+    /** Attachments left out because restoring them would exceed MAX_TOTAL_BYTES. */
+    droppedAttachments: number;
+}
 export interface SessionControllerOptions {
     /** Opens a ChatSession; called lazily on the first send after `closed`. */
     openSession: () => Promise<ChatSessionLike>;
@@ -31,9 +44,9 @@ export interface SessionControllerOptions {
     /** 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>>;
+     * `ChatBridgeError.code`. Core's messages carry no UI-specific remedy;
+     * the extension adds the VSCode-side one. */
+    hints?: Partial<Record<HintCode, string>>;
 }
 export declare const CLOSE_TIMEOUT_MS = 5000;
 /** Owns the history, the pending attachments and the ChatSession. No
@@ -47,26 +60,64 @@ export declare class SessionController {
     private session;
     /** The full prompt of the last send, for retryLast(). */
     private lastPrompt;
+    /** Turns sent while the controller was not ready, oldest first. */
+    private queue;
+    /** Bumped by every reopen; a send from an older generation is stale. */
+    private generation;
+    /** The reopen in flight, so a second Ctrl+R joins it instead of racing. */
+    private reopening;
+    /** The openSession in flight (first send or reopen), so close() can wait
+     * for it instead of orphaning the browser it is about to produce. */
+    private opening;
     private readonly closeTimeoutMs;
     constructor(opts: SessionControllerOptions);
     getState(): State;
     private setStatus;
+    /** A `/help` listing, as a history entry. */
+    pushHelp(text: string): void;
     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. */
+    /** True when a turn can start right now. `dead` counts: an explicit
+     * send is the user retrying, and only automatic draining must stop
+     * while the controller is dead. */
+    private get canStartTurn();
+    /** Sends the text plus the pending attachments as one turn, or queues it
+     * when a turn is already running. Never throws: the outcome is the
+     * result and the history. */
     send(text: string): Promise<SendResult>;
+    /** Pushes the user entry and runs the turn. Shared by send and drain. */
+    private startTurn;
+    /** Starts the oldest queued entry, if any, when the controller is ready
+     * for a turn. Called at every transition back to a ready state, before
+     * the caller emits, so the webview never sees an idle frame with a
+     * queue still waiting. */
+    private drain;
+    /** Empties the queue back into the composer: the entries are returned
+     * and their attachments become pending again. */
+    takeBack(): TakeBackResult;
+    removeQueued(index: number): void;
     /** 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;
+    /** Pushes the error entry (message plus the extension's remedy, if any)
+     * and reports the code back to the caller. */
+    private pushError;
     private fail;
+    /** Tracks an openSession so close()/dropSession can wait for it. */
+    private trackOpen;
     private dropSession;
-    /** Ctrl+R of the TUI: drop the browser, mark the break, reopen lazily. */
-    newChat(): Promise<void>;
+    /** Ctrl+R of the TUI: drop the browser, mark the break, reopen lazily.
+     * False when a turn is in flight, so the caller can warn. */
+    newChat(): Promise<boolean>;
+    /** Replaces the browser in every state. The in-flight turn, if any, is
+     * abandoned: its result is dropped by the generation check. A second
+     * call while one is running joins the first. */
+    reopen(): Promise<void>;
+    private runReopen;
     /** 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>;