@chatbridge/vscode 0.8.1 → 0.8.2

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

@@ -1,4 +1,4 @@
-import type { State, ToHost, ToWebview, UiConfig, WebviewCommand } 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>;
@@ -15,6 +15,8 @@ export interface ChatViewHandlers {
     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 {
@@ -27,5 +29,6 @@ export declare class ChatViewBridge {
     };
     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,10 +1,13 @@
-const COMMANDS = new Set([
+/** 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;
@@ -88,6 +91,9 @@ export class ChatViewBridge {
     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

@@ -19,6 +19,8 @@ export interface CommandHandlers {
     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;

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);
 }
@@ -87,6 +91,7 @@ export function createCommands(deps) {
             }
         },
         reopen: () => controller.reopen(),
+        help: () => controller.pushHelp(helpText()),
         async installBrowser() {
             if (await runInstall())
                 ui.showInformationMessage("Chromium installed.");
@@ -101,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;
@@ -115,7 +124,7 @@ export function createCommands(deps) {
         focus: () => ui.focusView(),
         async attachUris(uris) {
             const skipped = [];
-            for (const raw of uris) {
+            for (const raw of new Set(uris)) {
                 try {
                     const doc = await ui.openDocument(ui.parseUri(raw));
                     attach(doc.path, doc.text);
@@ -131,9 +140,8 @@ export function createCommands(deps) {
         pasted(text) {
             const editor = ui.activeEditor();
             const selection = editor?.selection;
-            if (!editor || !selection)
+            if (!editor || !selection || selection.text.trim() === "")
                 return false;
-            const normalise = (s) => s.replace(/\r\n/g, "\n");
             if (normalise(text) !== normalise(selection.text))
                 return false;
             attachEditor(editor, true);

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,17 +31,35 @@ export function createExtension(opts) {
         const bridge = new ChatViewBridge(() => controller.getState(), {
             send: (text) => void handlers.send(text),
             removeAttachment: (i) => controller?.removeAttachment(i),
-            takeBack: () => controller?.takeBack(),
+            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) {
@@ -57,6 +76,7 @@ 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);

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/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;
@@ -24,7 +24,9 @@ export interface State {
     /** `ChatBridgeError.code` of the error that made the status `dead`. */
     lastError?: string;
 }
-export type WebviewCommand = "login" | "logout" | "newChat" | "installBrowser" | "reopen";
+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";
@@ -82,4 +84,9 @@ export type ToWebview = ({
     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

@@ -26,6 +26,16 @@ export type AddResult = {
     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>;
@@ -34,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
@@ -56,10 +66,15 @@ export declare class SessionController {
     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;
@@ -81,14 +96,19 @@ export declare class SessionController {
     private drain;
     /** Empties the queue back into the composer: the entries are returned
      * and their attachments become pending again. */
-    takeBack(): QueueEntry[];
+    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.
      * False when a turn is in flight, so the caller can warn. */

package/dist/session-controller.js

@@ -24,6 +24,9 @@ export class SessionController {
     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;
@@ -53,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();
@@ -101,9 +108,10 @@ export class SessionController {
             return EMPTY;
         const attachments = this.pending;
         this.pending = [];
-        // 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.
+        // 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();
@@ -144,15 +152,28 @@ export class SessionController {
      * and their attachments become pending again. */
     takeBack() {
         if (this.queue.length === 0)
-            return [];
+            return { entries: [], droppedAttachments: 0 };
         const entries = this.queue.splice(0);
-        for (const e of entries)
-            this.pending.push(...e.attachments);
+        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.map((e) => ({
-            text: e.text,
-            attachments: e.attachments.map(({ path, bytes }) => ({ path, bytes })),
-        }));
+        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)
@@ -190,8 +211,9 @@ export class SessionController {
         try {
             if (this.session === undefined) {
                 this.setStatus("opening");
-                const 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 };
@@ -215,7 +237,9 @@ export class SessionController {
             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];
@@ -223,6 +247,10 @@ 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") {
@@ -237,11 +265,31 @@ 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.
      * False when a turn is in flight, so the caller can warn. */
@@ -265,9 +313,10 @@ export class SessionController {
         this.setStatus("reopening");
         await this.dropSession();
         try {
-            const session = await this.opts.openSession();
+            const session = await this.trackOpen(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.
+            // 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;
@@ -280,13 +329,7 @@ export class SessionController {
             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}`,
-            });
+            const { code } = this.pushError(err);
             this.lastError = code;
             this.setStatus("dead");
         }

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,9 @@ 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. */

package/dist/vscode-ui.js

@@ -29,6 +29,7 @@ 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);

package/dist/webview/main.js

@@ -11,19 +11,14 @@
   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)
+    const word = PATTERN.exec(text.trim())?.[1];
+    if (word === 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();
@@ -39,8 +34,15 @@
   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) {
@@ -71,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;
@@ -88,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(
@@ -108,7 +114,11 @@
       status.appendChild(el("span", "spinner"));
       const queued = s.queue.length > 0 ? ` \xB7 ${s.queue.length} queued` : "";
       status.appendChild(
-        el("span", "progress-text", `${waitingText(s.status)}${queued}`)
+        el(
+          "span",
+          "progress-text",
+          `${lastProgress ?? waitingText(s.status)}${queued}`
+        )
       );
       return;
     }
@@ -155,9 +165,9 @@
       li.appendChild(el("span", "queue-text", `\u25B9 ${label}`));
       const x = button(
         "\xD7",
-        () => vscode.postMessage({ type: "removeQueued", index })
+        () => vscode.postMessage({ type: "removeQueued", index }),
+        "chip-remove"
       );
-      x.className = "chip-remove";
       li.appendChild(x);
       queue.appendChild(li);
     });
@@ -168,14 +178,16 @@
       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);
@@ -183,12 +195,13 @@
     renderAttachments(s);
     welcome.hidden = s.messages.length > 0 || !config.welcome && !config.bannerUri;
     history.hidden = !welcome.hidden;
-    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();
+    if (!lastState || lastState.status !== s.status) {
+      if (document.activeElement === null || document.activeElement === document.body) {
+        input.focus();
+      }
     }
     lastState = s;
   }
@@ -207,19 +220,14 @@
     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;
-      }
+      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();
@@ -233,27 +241,40 @@
     }
     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));
+  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("#"));
   }
-  document.addEventListener("dragover", (e) => {
-    e.preventDefault();
+  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(
-    "dragleave",
-    () => document.body.classList.remove("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 });
@@ -268,7 +289,9 @@
       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") ?? "";
@@ -277,7 +300,7 @@
     const id = ++pasteSeq;
     const timer = setTimeout(() => {
       pendingPastes.delete(id);
-      insertAtCaret(text);
+      if (!input.disabled) insertAtCaret(text);
     }, PASTE_TIMEOUT_MS);
     pendingPastes.set(id, { text, timer });
     vscode.postMessage({ type: "pasted", id, text });
@@ -290,6 +313,7 @@
   });
   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);
@@ -297,6 +321,7 @@
       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") {
@@ -305,7 +330,13 @@
       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" });
 })();

package/dist/webview/style.css

@@ -85,6 +85,7 @@ body {
 }
 #composer {
   display: flex;
+  align-items: flex-end;
   gap: 6px;
   padding: 8px;
   border-top: 1px solid var(--vscode-panel-border);
@@ -92,6 +93,13 @@ body {
 #input {
   flex: 1;
   resize: none;
+  /* `height = scrollHeight` and the row-based max-height are only exact
+     when padding and border are inside the box. */
+  box-sizing: border-box;
+  overflow-y: auto;
+  line-height: 1.4;
+  /* 8 rows + padding: beyond this the textarea scrolls internally. */
+  max-height: calc(1.4em * 8 + 8px);
   background: var(--vscode-input-background);
   color: var(--vscode-input-foreground);
   border: 1px solid var(--vscode-input-border, transparent);

package/dist/webview-html.js

@@ -24,7 +24,7 @@ export function buildHtml(i) {
 <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, / for commands)"></textarea>
+<textarea id="input" rows="1" 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.8.1",
+  "version": "0.8.2",
   "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.8.1"
+    "@chatbridge/core": "0.8.2"
   },
   "devDependencies": {
     "@types/vscode": "1.138.0",