@chatbridge/vscode 0.8.0 → 0.8.2

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,15 @@ 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;
+    /** The openSession in flight (first send or reopen), so close() can wait
+     * for it instead of orphaning the browser it is about to produce. */
+    opening;
     closeTimeoutMs;
     constructor(opts) {
         this.opts = opts;
@@ -32,6 +43,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;
@@ -41,6 +56,10 @@ export class SessionController {
         this.status = status;
         this.emit();
     }
+    /** A `/help` listing, as a history entry. */
+    pushHelp(text) {
+        this.push({ role: "help", text });
+    }
     push(message) {
         this.messages.push(message);
         this.emit();
@@ -72,37 +91,103 @@ 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 the controller was not ready when the last
+        // entry arrived and has not become ready since — every ready transition
+        // drains first; `closed` after deactivate can still hold a queue, which
+        // the next send queues behind. Either way, keep FIFO by queueing.
+        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 { entries: [], droppedAttachments: 0 };
+        const entries = this.queue.splice(0);
+        let total = this.pending.reduce((n, p) => n + p.bytes, 0);
+        let dropped = 0;
+        for (const e of entries) {
+            for (const a of e.attachments) {
+                if (total + a.bytes > MAX_TOTAL_BYTES) {
+                    dropped++;
+                    continue;
+                }
+                total += a.bytes;
+                this.pending.push(a);
+            }
+        }
+        this.emit();
+        return {
+            entries: entries.map((e) => ({
+                text: e.text,
+                attachments: e.attachments.map(({ path, bytes }) => ({ path, bytes })),
+            })),
+            droppedAttachments: dropped,
+        };
+    }
+    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,22 +207,39 @@ 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.trackOpen(this.opts.openSession());
+                // A reopen ran while we were opening: this browser is an orphan.
+                // dropSession may have closed it already; close/kill are idempotent.
+                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);
         }
     }
-    async fail(err) {
+    /** Pushes the error entry (message plus the extension's remedy, if any)
+     * and reports the code back to the caller. */
+    pushError(err) {
         const code = err instanceof ChatBridgeError ? err.code : "UNKNOWN";
         const message = err instanceof Error ? err.message : String(err);
         const hint = this.opts.hints?.[code];
@@ -145,10 +247,16 @@ export class SessionController {
             role: "error",
             text: hint === undefined ? message : `${message}\n${hint}`,
         });
+        return { code, message };
+    }
+    async fail(err) {
+        const { code, message } = this.pushError(err);
         // 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;
@@ -157,27 +265,89 @@ export class SessionController {
         }
         return { ok: false, code, message };
     }
+    /** Tracks an openSession so close()/dropSession can wait for it. */
+    async trackOpen(p) {
+        this.opening = p;
+        try {
+            return await p;
+        }
+        finally {
+            if (this.opening === p)
+                this.opening = undefined;
+        }
+    }
     async dropSession() {
+        // An open still in flight would assign `this.session` after we return,
+        // so wait for it and close the browser it produced here: the caller
+        // (close(), discard()) must not return with one still running.
+        const opened = await this.opening?.catch(() => undefined);
         const old = this.session;
         this.session = undefined;
         if (old !== undefined)
             await closeOrKill(old, this.closeTimeoutMs);
+        // The opener's own generation check will close this one too; close()
+        // and kill() are idempotent, so closing it twice is harmless.
+        else if (opened !== undefined) {
+            await closeOrKill(opened, 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.trackOpen(this.opts.openSession());
+            // `close()` (deactivate) ran while the browser was opening: this one
+            // is an orphan, and the controller is closed. dropSession may have
+            // closed it already; close/kill are idempotent.
+            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 } = this.pushError(err);
+            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 +356,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/timeout-setting.d.ts

@@ -0,0 +1,7 @@
+/** Mirrors the CLI's parseTimeoutMs: finite and > 0, else the default.
+ * `invalid` is true when a value was set but unusable, so the caller can
+ * warn once. */
+export declare function parseTimeoutSec(raw: unknown, fallbackMs: number): {
+    timeoutMs: number;
+    invalid: boolean;
+};

package/dist/timeout-setting.js

@@ -0,0 +1,12 @@
+/** Mirrors the CLI's parseTimeoutMs: finite and > 0, else the default.
+ * `invalid` is true when a value was set but unusable, so the caller can
+ * warn once. */
+export function parseTimeoutSec(raw, fallbackMs) {
+    if (raw === undefined)
+        return { timeoutMs: fallbackMs, invalid: false };
+    const seconds = typeof raw === "number" ? raw : Number(raw);
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        return { timeoutMs: fallbackMs, invalid: true };
+    }
+    return { timeoutMs: seconds * 1000, invalid: false };
+}

package/dist/vscode-ui.d.ts

@@ -20,6 +20,11 @@ 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;
+    /** True when the value is a real vscode.Uri: a command argument from an
+     * unexpected caller is not. */
+    isUri(value: unknown): boolean;
+    /** 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,8 @@ export function createVscodeUi(api, id) {
             }
             return snap;
         },
+        isUri: (v) => v instanceof api.Uri,
+        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,25 @@
 "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 word = PATTERN.exec(text.trim())?.[1];
+    if (word === void 0)
+      return void 0;
+    return NAMES.has(word) ? { command: word } : { unknown: word };
+  }
+  function unknownCommandMessage(word) {
+    return `Unknown command: /${word}. Type /help.`;
+  }
+
   // src/webview/main.ts
   var vscode = acquireVsCodeApi();
   var history = document.getElementById("history");
@@ -12,7 +32,17 @@
   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");
+  function fitComposer() {
+    const atBottom = history.scrollHeight - history.scrollTop - history.clientHeight < 2;
+    input.style.height = "auto";
+    input.style.height = `${input.scrollHeight + input.offsetHeight - input.clientHeight}px`;
+    if (atBottom) history.scrollTop = history.scrollHeight;
+  }
   var config = {};
+  var lastState;
+  var lastProgress;
   function applyConfig(c) {
     config = c;
     if (c.sendButton?.background) {
@@ -43,8 +73,8 @@
     if (text !== void 0) e.textContent = text;
     return e;
   }
-  function button(label, onClick) {
-    const b = el("button", "action", label);
+  function button(label, onClick, className = "action") {
+    const b = el("button", className, label);
     b.setAttribute("type", "button");
     b.addEventListener("click", onClick);
     return b;
@@ -60,6 +90,10 @@
       box.textContent = `\u2014 ${m.text} \u2014`;
       return box;
     }
+    if (m.role === "help") {
+      box.textContent = m.text;
+      return box;
+    }
     box.appendChild(el("div", "text", m.text));
     for (const a of m.attachments ?? []) {
       box.appendChild(
@@ -68,16 +102,22 @@
     }
     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..."
+          `${lastProgress ?? waitingText(s.status)}${queued}`
         )
       );
       return;
@@ -99,6 +139,12 @@
           )
         );
       }
+      status.appendChild(
+        button(
+          "Reopen",
+          () => vscode.postMessage({ type: "command", name: "reopen" })
+        )
+      );
       status.appendChild(
         button(
           "New chat",
@@ -109,36 +155,79 @@
     }
     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 }),
+        "chip-remove"
+      );
+      li.appendChild(x);
+      queue.appendChild(li);
+    });
+  }
   function renderAttachments(s) {
     attachments.replaceChildren();
     s.pendingAttachments.forEach((a, index) => {
       const chip = el("span", "chip", `\u{1F4CE} ${a.path} (${formatSize(a.bytes)})`);
       const x = button(
         "\xD7",
-        () => vscode.postMessage({ type: "removeAttachment", index })
+        () => vscode.postMessage({ type: "removeAttachment", index }),
+        "chip-remove"
       );
-      x.className = "chip-remove";
       chip.appendChild(x);
       attachments.appendChild(chip);
     });
   }
   function render(s) {
+    const active = s.status === "busy" || s.status === "opening" || s.status === "reopening";
+    if (!active) lastProgress = void 0;
     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();
+    input.disabled = false;
+    sendButton.disabled = false;
+    sendButton.textContent = active ? "Queue" : "Send";
+    if (!lastState || lastState.status !== s.status) {
+      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 = "";
+      fitComposer();
+      const name = slash.command === "new" ? "newChat" : slash.command;
+      vscode.postMessage({ type: "command", name });
+      return;
+    }
     vscode.postMessage({ type: "send", text });
     input.value = "";
+    fitComposer();
   }
   form.addEventListener("submit", (e) => {
     e.preventDefault();
@@ -148,10 +237,83 @@
     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();
+      vscode.postMessage({ type: "takeBack" });
+    }
+  });
+  input.addEventListener("input", () => {
+    showInlineError(void 0);
+    fitComposer();
+  });
+  function urisFromDrop(dt) {
+    const list = dt?.getData("text/uri-list") ?? "";
+    return list.split(/\r?\n/).map((l) => l.trim()).filter((l) => l !== "" && !l.startsWith("#"));
+  }
+  function carriesFiles(dt) {
+    return dt?.types.includes("text/uri-list") ?? false;
+  }
+  var dragDepth = 0;
+  document.addEventListener("dragenter", (e) => {
+    if (!carriesFiles(e.dataTransfer)) return;
+    dragDepth++;
+    document.body.classList.add("drop-target");
+  });
+  document.addEventListener("dragover", (e) => {
+    if (carriesFiles(e.dataTransfer)) e.preventDefault();
+  });
+  document.addEventListener("dragleave", (e) => {
+    if (!carriesFiles(e.dataTransfer)) return;
+    if (--dragDepth <= 0) {
+      dragDepth = 0;
+      document.body.classList.remove("drop-target");
+    }
+  });
+  document.addEventListener("drop", (e) => {
+    if (!carriesFiles(e.dataTransfer)) return;
+    e.preventDefault();
+    dragDepth = 0;
+    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.dispatchEvent(new Event("input", { bubbles: true }));
+    }
+    fitComposer();
+  }
+  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);
+      if (!input.disabled) 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) => {
     const m = event.data;
+    if (!m || typeof m !== "object" || typeof m.type !== "string") return;
     if (m.type === "state") {
       const { type: _type, ...state } = m;
       render(state);
@@ -159,9 +321,22 @@
       const { type: _type, ...rest } = m;
       applyConfig(rest);
     } else if (m.type === "progress") {
+      lastProgress = m.text;
       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);
+    } else if (m.type === "tookBack") {
+      input.value = m.entries.map((q) => q.text).join("\n\n");
+      showInlineError(void 0);
+      fitComposer();
+      input.focus();
     }
   });
+  fitComposer();
   vscode.postMessage({ type: "ready" });
 })();