@chatbridge/vscode 0.7.0 → 0.8.1

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`
@@ -90,11 +122,32 @@ Bundle with esbuild as CJS, with `vscode` and `playwright` marked external.
 `examples/vscode-dummy-chat` keeps `"type": "module"` in its manifest, so
 its bundle is `dist/extension.cjs`, not `.js` — match that if you copy the
 example's `esbuild.mjs`. Its `package` script runs
-`vsce package --no-dependencies`, which is only a CI packaging smoke test.
-A real vendor `.vsix` must ship `node_modules/playwright` so the Install
-Browser button works for end users: drop `--no-dependencies` when
-packaging for distribution, or vendors get "playwright is not bundled with
-this extension" from the Install button.
+`vsce package --no-dependencies`, which is only a CI packaging smoke test
+(its `workspace:*` dependencies cannot be npm-installed). A distributable
+`.vsix` must ship `node_modules/playwright` so the Install Browser button
+works for end users; without it the button reports "playwright is not
+bundled with this extension".
+
+### Building a distributable `.vsix` (vendor repo)
+
+1. In the extension's `package.json`, keep only `playwright` under
+   `dependencies`. `@chatbridge/vscode` (and everything it pulls in) is
+   inlined by esbuild, so it belongs in `devDependencies` together with
+   `esbuild` and `@vscode/vsce`.
+2. Build the bundle: `bun run build` (esbuild → `dist/extension.cjs` and
+   `dist/webview/`).
+3. Create a plain production `node_modules` with npm, not bun:
+   `rm -rf node_modules && npm install --omit=dev`. vsce discovers
+   dependencies by walking npm's layout; bun's symlinked workspace tree
+   makes that walk escape the folder. The result is just `playwright` and
+   `playwright-core`.
+4. `npx @vscode/vsce package` (no `--no-dependencies`). Expect roughly 4 MB
+   and about 185 files.
+5. Verify: `unzip -l *.vsix | grep node_modules/playwright/cli.js`. Then
+   restore the dev tree with `bun install`.
+6. Install locally with `code --install-extension <file>.vsix`. Chromium is
+   never inside the `.vsix`: end users get it from the Install Browser
+   button (or `npx playwright install chromium`).
 
 `examples/vscode-dummy-chat` in the framework repo is the reference
 implementation to copy into a vendor repo.

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

@@ -1,4 +1,4 @@
-import type { State, ToHost, ToWebview, UiConfig } from "./protocol.js";
+import type { 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,7 +9,11 @@ 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;
 }
 /** Translates webview messages into handler calls and pushes state to
  * whichever webview is currently attached (VSCode recreates it). */
@@ -22,5 +26,6 @@ export declare class ChatViewBridge {
         dispose(): void;
     };
     pushState(state: State): void;
+    pushPasteResult(id: number, attached: boolean): void;
     pushProgress(text: string): void;
 }

package/dist/chat-view-bridge.js

@@ -1,3 +1,10 @@
+const COMMANDS = new Set([
+    "login",
+    "logout",
+    "newChat",
+    "installBrowser",
+    "reopen",
+]);
 function isToHost(m) {
     if (typeof m !== "object" || m === null)
         return false;
@@ -9,10 +16,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 +57,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 +85,9 @@ export class ChatViewBridge {
     pushState(state) {
         void this.webview?.postMessage({ type: "state", ...state });
     }
+    pushPasteResult(id, attached) {
+        void this.webview?.postMessage({ type: "pasteResult", id, attached });
+    }
     pushProgress(text) {
         void this.webview?.postMessage({ type: "progress", text });
     }

package/dist/commands.d.ts

@@ -17,11 +17,16 @@ export interface CommandHandlers {
     login(): Promise<void>;
     logout(): Promise<void>;
     newChat(): Promise<void>;
+    reopen(): Promise<void>;
     installBrowser(): Promise<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

@@ -9,7 +9,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 +66,27 @@ 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(),
         async installBrowser() {
             if (await runInstall())
                 ui.showInformationMessage("Chromium installed.");
@@ -99,6 +113,32 @@ export function createCommands(deps) {
             attachEditor(editor, false);
         },
         focus: () => ui.focusView(),
+        async attachUris(uris) {
+            const skipped = [];
+            for (const raw of 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)
+                return false;
+            const normalise = (s) => s.replace(/\r\n/g, "\n");
+            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

@@ -30,7 +30,11 @@ export function createExtension(opts) {
         const bridge = new ChatViewBridge(() => controller.getState(), {
             send: (text) => void handlers.send(text),
             removeAttachment: (i) => controller?.removeAttachment(i),
+            takeBack: () => controller?.takeBack(),
+            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)),
         });
         function settings() {
             const cfg = vscode.workspace.getConfiguration(opts.id);
@@ -56,7 +60,9 @@ export function createExtension(opts) {
             },
             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 +89,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/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

@@ -7,15 +7,24 @@ 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 → host */
 export type ToHost = {
     type: "ready";
@@ -25,9 +34,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 +76,10 @@ 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;
+};

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,11 +12,14 @@ 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;
 } | {
@@ -47,6 +50,12 @@ 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;
     private readonly closeTimeoutMs;
     constructor(opts: SessionControllerOptions);
     getState(): State;
@@ -55,9 +64,25 @@ export declare class SessionController {
     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(): QueueEntry[];
+    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. */
@@ -65,8 +90,14 @@ export declare class SessionController {
     private runTurn;
     private fail;
     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>;

package/dist/session-controller.js

@@ -1,4 +1,6 @@
 import { ChatBridgeError, MAX_FILE_BYTES, MAX_TOTAL_BYTES, closeOrKill, formatAttachment, formatSize, } from "@chatbridge/core";
+/** The separator pushed into the history by `reopen()`. */
+export const REOPENED_SEPARATOR = "reopened";
 export const CLOSE_TIMEOUT_MS = 5_000;
 const EMPTY = {
     ok: false,
@@ -16,6 +18,12 @@ export class SessionController {
     session;
     /** The full prompt of the last send, for retryLast(). */
     lastPrompt;
+    /** Turns sent while the controller was not ready, oldest first. */
+    queue = [];
+    /** Bumped by every reopen; a send from an older generation is stale. */
+    generation = 0;
+    /** The reopen in flight, so a second Ctrl+R joins it instead of racing. */
+    reopening;
     closeTimeoutMs;
     constructor(opts) {
         this.opts = opts;
@@ -32,6 +40,10 @@ export class SessionController {
                 path,
                 bytes,
             })),
+            queue: this.queue.map((q) => ({
+                text: q.text,
+                attachments: q.attachments.map(({ path, bytes }) => ({ path, bytes })),
+            })),
         };
         if (this.lastError !== undefined)
             state.lastError = this.lastError;
@@ -72,37 +84,89 @@ export class SessionController {
         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. */
+    /** 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. */
+    get canStartTurn() {
+        return (this.status === "idle" ||
+            this.status === "closed" ||
+            this.status === "dead");
+    }
+    /** 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. */
     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,
-        }));
+        const attachments = this.pending;
         this.pending = [];
-        this.push({ role: "user", text: body, attachments });
+        // A non-empty queue means earlier entries are waiting (the controller
+        // is `dead`, where draining stops): keep FIFO by queueing behind them
+        // and letting drain start the oldest, which reopens the browser.
+        if (!this.canStartTurn || this.queue.length > 0) {
+            this.queue.push({ text: body, attachments });
+            this.drain();
+            this.emit();
+            return { ok: true, queued: true };
+        }
+        return this.startTurn({ text: body, attachments });
+    }
+    /** Pushes the user entry and runs the turn. Shared by send and drain. */
+    startTurn(turn) {
+        const sections = turn.attachments.map((a) => formatAttachment(a.path, a.content));
+        const prompt = [turn.text, ...sections]
+            .filter((s) => s !== "")
+            .join("\n\n");
+        this.push({
+            role: "user",
+            text: turn.text,
+            attachments: turn.attachments.map(({ path, bytes }) => ({ path, bytes })),
+        });
         this.lastPrompt = prompt;
         return this.runTurn(prompt);
     }
+    /** 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. */
+    drain() {
+        // markLoggedIn() can arrive in any status; never start a second turn
+        // on top of a running one. The other call sites are already ready.
+        if (!this.canStartTurn)
+            return;
+        const next = this.queue.shift();
+        if (next === undefined)
+            return;
+        void this.startTurn(next);
+    }
+    /** Empties the queue back into the composer: the entries are returned
+     * and their attachments become pending again. */
+    takeBack() {
+        if (this.queue.length === 0)
+            return [];
+        const entries = this.queue.splice(0);
+        for (const e of entries)
+            this.pending.push(...e.attachments);
+        this.emit();
+        return entries.map((e) => ({
+            text: e.text,
+            attachments: e.attachments.map(({ path, bytes }) => ({ path, bytes })),
+        }));
+    }
+    removeQueued(index) {
+        if (index < 0 || index >= this.queue.length)
+            return;
+        this.queue.splice(index, 1);
+        this.emit();
+    }
     /** 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") {
+        if (!this.canStartTurn) {
             return {
                 ok: false,
                 code: "INVALID_STATE",
@@ -122,18 +186,32 @@ export class SessionController {
         // `lastError` would keep the webview's error banner up after a
         // successful send from `dead`.
         this.lastError = undefined;
+        const generation = this.generation;
         try {
             if (this.session === undefined) {
                 this.setStatus("opening");
-                this.session = await this.opts.openSession();
+                const session = await this.opts.openSession();
+                // A reopen ran while we were opening: this browser is an orphan.
+                if (generation !== this.generation) {
+                    await closeOrKill(session, this.closeTimeoutMs);
+                    return { ok: true };
+                }
+                this.session = session;
             }
             this.setStatus("busy");
             const reply = await this.session.send(prompt);
+            if (generation !== this.generation)
+                return { ok: true }; // stale
             this.messages.push({ role: "assistant", text: reply });
-            this.setStatus("idle");
+            // Claim the next turn before emitting, so no idle frame is shown.
+            this.status = "idle";
+            this.drain();
+            this.emit();
             return { ok: true };
         }
         catch (err) {
+            if (generation !== this.generation)
+                return { ok: true }; // stale
             return this.fail(err);
         }
     }
@@ -148,7 +226,9 @@ export class SessionController {
         // Show the error before `dropSession` (up to `closeTimeoutMs`) runs.
         this.emit();
         if (code === "RESPONSE_TIMEOUT") {
-            this.setStatus("idle");
+            this.status = "idle";
+            this.drain();
+            this.emit();
         }
         else {
             this.lastError = code;
@@ -163,21 +243,68 @@ export class SessionController {
         if (old !== undefined)
             await closeOrKill(old, this.closeTimeoutMs);
     }
-    /** Ctrl+R of the TUI: drop the browser, mark the break, reopen lazily. */
+    /** 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. */
     async newChat() {
-        await this.discard("New chat");
+        return this.discard("New chat");
+    }
+    /** 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() {
+        if (this.reopening)
+            return this.reopening;
+        const run = this.runReopen().finally(() => {
+            this.reopening = undefined;
+        });
+        this.reopening = run;
+        return run;
+    }
+    async runReopen() {
+        const generation = ++this.generation;
+        this.setStatus("reopening");
+        await this.dropSession();
+        try {
+            const session = await this.opts.openSession();
+            // `close()` (deactivate) ran while the browser was opening: this one
+            // is an orphan nobody would ever close, and the controller is closed.
+            if (generation !== this.generation) {
+                await closeOrKill(session, this.closeTimeoutMs);
+                return;
+            }
+            this.session = session;
+            this.lastError = undefined;
+            this.messages.push({ role: "separator", text: REOPENED_SEPARATOR });
+            this.status = "idle";
+            this.drain();
+            this.emit();
+        }
+        catch (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}`,
+            });
+            this.lastError = code;
+            this.setStatus("dead");
+        }
     }
     /** 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")
+        if (!this.canStartTurn)
             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 });
+        this.messages.push({ role: "separator", text: separator });
+        // The queue outlives the break: drain it into the new chat.
+        this.drain();
+        this.emit();
         return true;
     }
     /** After a successful login command: a dead controller may try again. */
@@ -186,10 +313,15 @@ export class SessionController {
             this.lastError = undefined;
             this.status = "closed";
         }
-        this.push({ role: "separator", text: "Logged in" });
+        this.messages.push({ role: "separator", text: "Logged in" });
+        this.drain();
+        this.emit();
     }
     /** deactivate: close the browser, keep the history. Idempotent. */
     async close() {
+        // A reopen in flight is stale from here on: its new browser must be
+        // closed rather than adopted by a controller the user has shut down.
+        this.generation++;
         await this.dropSession();
         if (this.status !== "dead")
             this.status = "closed";

package/dist/vscode-ui.d.ts

@@ -20,6 +20,8 @@ export interface VscodeUi {
     showInformationMessage(message: string): void;
     withProgress<T>(title: string, cancellable: boolean, task: (progress: ProgressReporter, signal: AbortSignal) => Promise<T>): Promise<T>;
     activeEditor(): EditorSnapshot | undefined;
+    /** Parses a URI string; throws when it is not a valid URI. */
+    parseUri(uri: string): unknown;
     /** Opens the document behind an explorer Uri (or any Uri) read-only. */
     openDocument(uri: unknown): Promise<{
         path: string;

package/dist/vscode-ui.js

@@ -29,6 +29,7 @@ export function createVscodeUi(api, id) {
             }
             return snap;
         },
+        parseUri: (uri) => api.Uri.parse(uri, true),
         openDocument: async (uri) => {
             const doc = await api.workspace.openTextDocument(uri);
             return { path: relPath(doc.uri), text: doc.getText() };

package/dist/webview/main.js

@@ -1,5 +1,30 @@
 "use strict";
 (() => {
+  // ../core/dist/slash-commands.js
+  var SLASH_COMMANDS = [
+    { name: "login", description: "Log in in a browser window" },
+    { name: "logout", description: "Delete the saved login and close the chat" },
+    { name: "new", description: "Start a new chat" },
+    { name: "reopen", description: "Reopen the browser (also Ctrl+R)" },
+    { name: "help", description: "List these commands" }
+  ];
+  var NAMES = new Set(SLASH_COMMANDS.map((c) => c.name));
+  var PATTERN = /^\/([a-z]+)$/;
+  function parseSlashCommand(text) {
+    const m = PATTERN.exec(text.trim());
+    if (!m || m[1] === void 0)
+      return void 0;
+    const word = m[1];
+    return NAMES.has(word) ? { command: word } : { unknown: word };
+  }
+  function unknownCommandMessage(word) {
+    return `Unknown command: /${word}. Type /help.`;
+  }
+  function helpText() {
+    const width = Math.max(...SLASH_COMMANDS.map((c) => c.name.length)) + 1;
+    return SLASH_COMMANDS.map((c) => `/${c.name.padEnd(width)} ${c.description}`).join("\n");
+  }
+
   // src/webview/main.ts
   var vscode = acquireVsCodeApi();
   var history = document.getElementById("history");
@@ -12,7 +37,10 @@
   var welcomeText = document.getElementById("welcome-text");
   var banner = document.getElementById("banner");
   var footer = document.getElementById("footer");
+  var queue = document.getElementById("queue");
+  var inlineError = document.getElementById("inline-error");
   var config = {};
+  var lastState;
   function applyConfig(c) {
     config = c;
     if (c.sendButton?.background) {
@@ -68,17 +96,19 @@
     }
     return box;
   }
+  function waitingText(status2) {
+    if (status2 === "reopening") return "Reopening browser...";
+    if (status2 === "opening") return "Opening browser...";
+    return "Waiting...";
+  }
   function renderStatus(s) {
     status.replaceChildren();
     status.hidden = false;
-    if (s.status === "busy" || s.status === "opening") {
+    if (s.status === "busy" || s.status === "opening" || s.status === "reopening") {
       status.appendChild(el("span", "spinner"));
+      const queued = s.queue.length > 0 ? ` \xB7 ${s.queue.length} queued` : "";
       status.appendChild(
-        el(
-          "span",
-          "progress-text",
-          s.status === "opening" ? "Opening browser..." : "Waiting..."
-        )
+        el("span", "progress-text", `${waitingText(s.status)}${queued}`)
       );
       return;
     }
@@ -99,6 +129,12 @@
           )
         );
       }
+      status.appendChild(
+        button(
+          "Reopen",
+          () => vscode.postMessage({ type: "command", name: "reopen" })
+        )
+      );
       status.appendChild(
         button(
           "New chat",
@@ -109,6 +145,23 @@
     }
     status.hidden = true;
   }
+  function renderQueue(s) {
+    queue.replaceChildren();
+    queue.hidden = s.queue.length === 0;
+    s.queue.forEach((entry, index) => {
+      const li = document.createElement("li");
+      const firstLine = entry.text.split("\n")[0] ?? "";
+      const label = entry.attachments.length > 0 ? `${firstLine} \u{1F4CE} ${entry.attachments.length}` : firstLine;
+      li.appendChild(el("span", "queue-text", `\u25B9 ${label}`));
+      const x = button(
+        "\xD7",
+        () => vscode.postMessage({ type: "removeQueued", index })
+      );
+      x.className = "chip-remove";
+      li.appendChild(x);
+      queue.appendChild(li);
+    });
+  }
   function renderAttachments(s) {
     attachments.replaceChildren();
     s.pendingAttachments.forEach((a, index) => {
@@ -126,17 +179,45 @@
     history.replaceChildren(...s.messages.map(renderMessage));
     history.scrollTop = history.scrollHeight;
     renderStatus(s);
+    renderQueue(s);
     renderAttachments(s);
     welcome.hidden = s.messages.length > 0 || !config.welcome && !config.bannerUri;
     history.hidden = !welcome.hidden;
-    const locked = s.status === "busy" || s.status === "opening";
-    input.disabled = locked;
-    sendButton.disabled = locked;
-    if (!locked) input.focus();
+    const active = s.status === "busy" || s.status === "opening" || s.status === "reopening";
+    input.disabled = false;
+    sendButton.disabled = false;
+    sendButton.textContent = active ? "Queue" : "Send";
+    if (document.activeElement === null || document.activeElement === document.body) {
+      input.focus();
+    }
+    lastState = s;
+  }
+  function showInlineError(text) {
+    inlineError.textContent = text ?? "";
+    inlineError.hidden = text === void 0;
   }
   function submit() {
     const text = input.value;
     if (text.trim() === "" && attachments.childElementCount === 0) return;
+    const slash = parseSlashCommand(text);
+    if (slash && "unknown" in slash) {
+      showInlineError(unknownCommandMessage(slash.unknown));
+      return;
+    }
+    showInlineError(void 0);
+    if (slash) {
+      input.value = "";
+      if (slash.command === "help") {
+        welcome.hidden = true;
+        history.hidden = false;
+        history.appendChild(el("div", "message help", helpText()));
+        history.scrollTop = history.scrollHeight;
+        return;
+      }
+      const name = slash.command === "new" ? "newChat" : slash.command;
+      vscode.postMessage({ type: "command", name });
+      return;
+    }
     vscode.postMessage({ type: "send", text });
     input.value = "";
   }
@@ -148,6 +229,63 @@
     if (e.key === "Enter" && !e.shiftKey && !e.isComposing) {
       e.preventDefault();
       submit();
+      return;
+    }
+    if (e.key === "ArrowUp" && input.value === "" && (lastState?.queue.length ?? 0) > 0) {
+      e.preventDefault();
+      const entries = lastState?.queue ?? [];
+      input.value = entries.map((q) => q.text).join("\n\n");
+      showInlineError(void 0);
+      vscode.postMessage({ type: "takeBack" });
+    }
+  });
+  input.addEventListener("input", () => showInlineError(void 0));
+  function urisFromDrop(dt) {
+    const list = dt?.getData("text/uri-list") ?? "";
+    return list.split(/\r?\n/).map((l) => l.trim()).filter((l) => l !== "" && !l.startsWith("#"));
+  }
+  document.addEventListener("dragover", (e) => {
+    e.preventDefault();
+    document.body.classList.add("drop-target");
+  });
+  document.addEventListener(
+    "dragleave",
+    () => document.body.classList.remove("drop-target")
+  );
+  document.addEventListener("drop", (e) => {
+    e.preventDefault();
+    document.body.classList.remove("drop-target");
+    const uris = urisFromDrop(e.dataTransfer);
+    if (uris.length > 0) vscode.postMessage({ type: "attachUris", uris });
+  });
+  var PASTE_TIMEOUT_MS = 500;
+  var pasteSeq = 0;
+  var pendingPastes = /* @__PURE__ */ new Map();
+  function insertAtCaret(text) {
+    input.focus();
+    if (!document.execCommand("insertText", false, text)) {
+      const { selectionStart, selectionEnd, value } = input;
+      input.value = value.slice(0, selectionStart) + text + value.slice(selectionEnd);
+      const pos = selectionStart + text.length;
+      input.setSelectionRange(pos, pos);
+    }
+  }
+  input.addEventListener("paste", (e) => {
+    const text = e.clipboardData?.getData("text/plain") ?? "";
+    if (!text.includes("\n")) return;
+    e.preventDefault();
+    const id = ++pasteSeq;
+    const timer = setTimeout(() => {
+      pendingPastes.delete(id);
+      insertAtCaret(text);
+    }, PASTE_TIMEOUT_MS);
+    pendingPastes.set(id, { text, timer });
+    vscode.postMessage({ type: "pasted", id, text });
+  });
+  document.addEventListener("keydown", (e) => {
+    if (e.key.toLowerCase() === "r" && (e.ctrlKey || e.metaKey) && !e.shiftKey && !e.altKey) {
+      e.preventDefault();
+      vscode.postMessage({ type: "command", name: "reopen" });
     }
   });
   window.addEventListener("message", (event) => {
@@ -161,6 +299,12 @@
     } else if (m.type === "progress") {
       const t = status.querySelector(".progress-text");
       if (t) t.textContent = m.text;
+    } else if (m.type === "pasteResult") {
+      const p = pendingPastes.get(m.id);
+      if (!p) return;
+      clearTimeout(p.timer);
+      pendingPastes.delete(m.id);
+      if (!m.attached) insertAtCaret(p.text);
     }
   });
   vscode.postMessage({ type: "ready" });

package/dist/webview/style.css

@@ -137,3 +137,38 @@ body {
 #input:disabled {
   opacity: 0.5;
 }
+#queue {
+  list-style: none;
+  margin: 0;
+  padding: 0 8px;
+  font-size: 90%;
+  opacity: 0.8;
+}
+#queue li {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 2px 0;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+#queue li .queue-text {
+  flex: 1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+#inline-error {
+  padding: 2px 8px;
+  color: var(--vscode-errorForeground);
+  font-size: 90%;
+}
+.message.help {
+  font-family: var(--vscode-editor-font-family);
+  white-space: pre;
+  opacity: 0.8;
+}
+body.drop-target {
+  outline: 2px dashed var(--vscode-focusBorder);
+  outline-offset: -2px;
+}

package/dist/webview-html.js

@@ -20,9 +20,11 @@ export function buildHtml(i) {
 <div id="welcome" hidden><img id="banner" alt="" hidden><p id="welcome-text"></p></div>
 <main id="history" aria-live="polite"></main>
 <div id="status" hidden></div>
+<ul id="queue" hidden></ul>
 <div id="attachments"></div>
+<div id="inline-error" hidden></div>
 <form id="composer">
-<textarea id="input" rows="3" placeholder="Message (Enter to send, Shift+Enter for a newline)"></textarea>
+<textarea id="input" rows="3" placeholder="Message (Enter to send, Shift+Enter for a newline, / for commands)"></textarea>
 <button id="send" type="submit">Send</button>
 </form>
 <footer id="footer" hidden></footer>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatbridge/vscode",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "VSCode extension factory for chatbridge: a sidebar chat view on top of ChatSession",
   "license": "MIT",
   "repository": {
@@ -28,7 +28,7 @@
     "build:webview": "bun run check:webview && esbuild src/webview/main.ts --bundle --format=iife --target=es2022 --outfile=dist/webview/main.js && mkdir -p dist/webview && cp src/webview/style.css dist/webview/style.css"
   },
   "dependencies": {
-    "@chatbridge/core": "0.7.0"
+    "@chatbridge/core": "0.8.1"
   },
   "devDependencies": {
     "@types/vscode": "1.138.0",