@chatbridge/vscode 0.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 7milch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,104 @@
+# @chatbridge/vscode
+
+VSCode extension factory for [chatbridge](https://github.com/7milch/chatbridge-cli).
+It turns a chatbridge Provider into a sidebar chat view: a webview talks to a
+`vscode`-free `SessionController` that owns the conversation history, the
+pending attachments and the underlying `ChatSession` lifecycle. A provider
+package wires it up and ships its own extension.
+
+## Usage
+
+```ts
+import { createExtension } from "@chatbridge/vscode";
+import provider from "./provider.js";
+export const { activate, deactivate } = createExtension({
+  id: "company-ai", displayName: "Company AI", provider, configDir: "company-ai",
+});
+```
+
+## Options
+
+- `id` — prefix for the view, commands and settings the manifest must
+  declare (see below). Also used as the config directory name unless
+  `configDir` is given.
+- `displayName` — shown in progress notifications and command titles.
+- `provider` — a chatbridge Provider, same shape as `createCli`'s.
+- `configDir` — auth-state directory name; pass the CLI's `configDir` so one
+  `auth login` serves both.
+- `playwrightCliPath` — override for the `playwright/cli.js` location the
+  Install Browser command spawns; only needed when Playwright is not
+  resolvable from the extension's own `node_modules`.
+- `timeoutMs` — per-step timeout default, in milliseconds (default
+  `120000`). The user's `<id>.timeoutSec` setting overrides it.
+- `headless` — whether sessions launch a headless browser (default `true`).
+  The user's `<id>.headless` setting overrides it.
+- `ui` — optional vendor branding, all fields plain text (no HTML, no
+  Markdown):
+  - `welcome` — shown centred above the history while it is empty; `\n`
+    makes a line break. Hidden once the first message arrives.
+  - `banner` — image (png/svg) shown above `welcome`, same lifetime. The
+    path is relative to the extension root, must not escape it, and must
+    exist at activation — a missing file throws — so ship it in the
+    `.vsix` (keep it out of `.vscodeignore`).
+  - `footer` — one line under the composer, always visible.
+  - `sendButton` — `{ background, foreground }` CSS colour strings for the
+    Send button; each defaults to the VSCode button theme colour.
+  - `userMessage` — `{ borderColor }`, the CSS colour of the border drawn
+    around the user's own messages; defaults to the theme's focus border.
+
+  ```ts
+  createExtension({
+    id: "company-ai", displayName: "Company AI", provider,
+    ui: {
+      welcome: "Ask Company AI anything.",
+      banner: "media/banner.svg",
+      footer: "Conversations are not stored by this extension.",
+      sendButton: { background: "#2f6f4f", foreground: "#ffffff" },
+      userMessage: { borderColor: "#2f6f4f" },
+    },
+  });
+  ```
+- `baseDir` — test-only override for the base directory of the config /
+  auth-state store.
+
+## Manifest
+
+The vendor's `package.json` must contribute, with `<id>` replaced by the
+`id` passed to `createExtension`:
+
+- View `<id>.chat` (a webview, typically under its own `viewsContainers`
+  entry)
+- Commands `<id>.login`, `<id>.logout`, `<id>.newChat`,
+  `<id>.installBrowser`, `<id>.sendSelection`, `<id>.sendFile`, `<id>.focus`
+- Settings `<id>.headless` (boolean) and `<id>.timeoutSec` (number)
+
+Activation checks exactly three things and throws a message listing every
+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.configuration` is not validated: a missing `<id>.headless` or
+`<id>.timeoutSec` setting simply falls back to the `createExtension`
+default.
+
+## Packaging
+
+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.
+
+`examples/vscode-dummy-chat` in the framework repo is the reference
+implementation to copy into a vendor repo.
+
+## License
+
+MIT

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

@@ -0,0 +1,26 @@
+import type { State, ToHost, ToWebview, UiConfig } from "./protocol.js";
+/** The slice of vscode.Webview the bridge uses; a fake in tests. */
+export interface WebviewLike {
+    postMessage(message: ToWebview): Thenable<boolean>;
+    onDidReceiveMessage(listener: (message: ToHost) => void): {
+        dispose(): void;
+    };
+}
+export interface ChatViewHandlers {
+    send(text: string): void;
+    removeAttachment(index: number): void;
+    command(name: "login" | "newChat" | "installBrowser"): void;
+}
+/** Translates webview messages into handler calls and pushes state to
+ * whichever webview is currently attached (VSCode recreates it). */
+export declare class ChatViewBridge {
+    private readonly getState;
+    private readonly handlers;
+    private webview;
+    constructor(getState: () => State, handlers: ChatViewHandlers);
+    attach(webview: WebviewLike, uiConfig?: UiConfig): {
+        dispose(): void;
+    };
+    pushState(state: State): void;
+    pushProgress(text: string): void;
+}

package/dist/chat-view-bridge.js

@@ -0,0 +1,66 @@
+function isToHost(m) {
+    if (typeof m !== "object" || m === null)
+        return false;
+    const msg = m;
+    switch (msg.type) {
+        case "ready":
+            return true;
+        case "send":
+            return typeof msg.text === "string";
+        case "removeAttachment":
+            return typeof msg.index === "number";
+        case "command":
+            return (msg.name === "login" ||
+                msg.name === "newChat" ||
+                msg.name === "installBrowser");
+        default:
+            return false;
+    }
+}
+/** Translates webview messages into handler calls and pushes state to
+ * whichever webview is currently attached (VSCode recreates it). */
+export class ChatViewBridge {
+    getState;
+    handlers;
+    webview;
+    constructor(getState, handlers) {
+        this.getState = getState;
+        this.handlers = handlers;
+    }
+    attach(webview, uiConfig) {
+        this.webview = webview;
+        const sub = webview.onDidReceiveMessage((raw) => {
+            if (!isToHost(raw))
+                return;
+            switch (raw.type) {
+                case "ready":
+                    if (uiConfig)
+                        void webview.postMessage({ type: "config", ...uiConfig });
+                    this.pushState(this.getState());
+                    break;
+                case "send":
+                    this.handlers.send(raw.text);
+                    break;
+                case "removeAttachment":
+                    this.handlers.removeAttachment(raw.index);
+                    break;
+                case "command":
+                    this.handlers.command(raw.name);
+                    break;
+            }
+        });
+        return {
+            dispose: () => {
+                sub.dispose();
+                if (this.webview === webview)
+                    this.webview = undefined;
+            },
+        };
+    }
+    pushState(state) {
+        void this.webview?.postMessage({ type: "state", ...state });
+    }
+    pushProgress(text) {
+        void this.webview?.postMessage({ type: "progress", text });
+    }
+}

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

@@ -0,0 +1,11 @@
+import * as vscode from "vscode";
+import type { ChatViewBridge } from "./chat-view-bridge.js";
+import type { ResolvedUiConfig } from "./ui-config.js";
+export declare class ChatViewProvider implements vscode.WebviewViewProvider {
+    private readonly extensionUri;
+    private readonly title;
+    private readonly bridge;
+    private readonly ui?;
+    constructor(extensionUri: vscode.Uri, title: string, bridge: ChatViewBridge, ui?: ResolvedUiConfig | undefined);
+    resolveWebviewView(view: vscode.WebviewView): void;
+}

package/dist/chat-view-provider.js

@@ -0,0 +1,50 @@
+import { randomBytes } from "node:crypto";
+import * as vscode from "vscode";
+import { buildHtml } from "./webview-html.js";
+export class ChatViewProvider {
+    extensionUri;
+    title;
+    bridge;
+    ui;
+    constructor(extensionUri, title, bridge, ui) {
+        this.extensionUri = extensionUri;
+        this.title = title;
+        this.bridge = bridge;
+        this.ui = ui;
+    }
+    resolveWebviewView(view) {
+        const root = vscode.Uri.joinPath(this.extensionUri, "dist", "webview");
+        const bannerUri = this.ui?.bannerPath
+            ? vscode.Uri.file(this.ui.bannerPath)
+            : undefined;
+        view.webview.options = {
+            enableScripts: true,
+            localResourceRoots: bannerUri
+                ? [root, vscode.Uri.joinPath(bannerUri, "..")]
+                : [root],
+        };
+        view.webview.html = buildHtml({
+            cspSource: view.webview.cspSource,
+            nonce: randomBytes(16).toString("base64url"),
+            scriptUri: view.webview
+                .asWebviewUri(vscode.Uri.joinPath(root, "main.js"))
+                .toString(),
+            styleUri: view.webview
+                .asWebviewUri(vscode.Uri.joinPath(root, "style.css"))
+                .toString(),
+            title: this.title,
+        });
+        let uiConfig;
+        if (this.ui) {
+            const { bannerPath: _bannerPath, ...rest } = this.ui;
+            uiConfig = bannerUri
+                ? {
+                    ...rest,
+                    bannerUri: view.webview.asWebviewUri(bannerUri).toString(),
+                }
+                : rest;
+        }
+        const sub = this.bridge.attach(view.webview, uiConfig);
+        view.onDidDispose(() => sub.dispose());
+    }
+}

package/dist/commands.d.ts

@@ -0,0 +1,27 @@
+import type { LoginOptions } from "@chatbridge/core";
+import type { InstallBrowserOptions } from "./install-browser.js";
+import type { SessionController } from "./session-controller.js";
+import type { VscodeUi } from "./vscode-ui.js";
+export interface CommandDeps {
+    displayName: string;
+    controller: SessionController;
+    ui: VscodeUi;
+    runLogin: (opts: LoginOptions) => Promise<void>;
+    installBrowser: (opts: InstallBrowserOptions) => Promise<void>;
+    /** Provider, auth store, etc.; the command adds signal and onProgress. */
+    loginOptions: () => Omit<LoginOptions, "signal" | "onProgress">;
+    installOptions: () => Omit<InstallBrowserOptions, "onProgress">;
+    clearAuth: () => Promise<void>;
+}
+export interface CommandHandlers {
+    login(): Promise<void>;
+    logout(): Promise<void>;
+    newChat(): 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>;
+}
+export declare function createCommands(deps: CommandDeps): CommandHandlers;

package/dist/commands.js

@@ -0,0 +1,113 @@
+import { LoginAbortedError } from "@chatbridge/core";
+function utf8Bytes(text) {
+    return new TextEncoder().encode(text).byteLength;
+}
+function message(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+export function createCommands(deps) {
+    const { controller, ui } = deps;
+    function isBusy() {
+        const status = controller.getState().status;
+        return status === "busy" || status === "opening";
+    }
+    async function runInstall() {
+        try {
+            await ui.withProgress("Installing Chromium", false, (progress) => deps.installBrowser({
+                ...deps.installOptions(),
+                onProgress: (l) => progress.report(l),
+            }));
+            return true;
+        }
+        catch (err) {
+            await ui.showErrorMessage(`Chromium install failed: ${message(err)}`);
+            return false;
+        }
+    }
+    function attach(path, text) {
+        const result = controller.addAttachment({
+            path,
+            bytes: utf8Bytes(text),
+            content: text,
+        });
+        if (!result.ok) {
+            ui.showWarningMessage(result.reason);
+            return;
+        }
+        ui.focusView();
+    }
+    function attachEditor(editor, useSelection) {
+        if (useSelection && editor.selection) {
+            const s = editor.selection;
+            attach(`${editor.path}:L${s.startLine}-L${s.endLine}`, s.text);
+        }
+        else {
+            attach(editor.path, editor.text);
+        }
+    }
+    return {
+        async login() {
+            if (isBusy()) {
+                ui.showWarningMessage("Wait for the current reply to finish, then log in.");
+                return;
+            }
+            try {
+                await ui.withProgress(`Log in to ${deps.displayName}`, true, (progress, signal) => deps.runLogin({
+                    ...deps.loginOptions(),
+                    signal,
+                    onProgress: (m) => progress.report(m),
+                }));
+                controller.markLoggedIn();
+            }
+            catch (err) {
+                if (err instanceof LoginAbortedError)
+                    return;
+                await ui.showErrorMessage(`Login failed: ${message(err)}`);
+            }
+        },
+        async logout() {
+            if (!(await controller.discard("Logged out"))) {
+                ui.showWarningMessage("Wait for the current reply to finish, then log out.");
+                return;
+            }
+            await deps.clearAuth();
+        },
+        newChat: () => controller.newChat(),
+        async installBrowser() {
+            if (await runInstall())
+                ui.showInformationMessage("Chromium installed.");
+        },
+        async sendSelection() {
+            const editor = ui.activeEditor();
+            if (!editor) {
+                ui.showWarningMessage("No active editor.");
+                return;
+            }
+            attachEditor(editor, true);
+        },
+        async sendFile(uri) {
+            if (uri !== undefined && uri !== null) {
+                const doc = await ui.openDocument(uri);
+                attach(doc.path, doc.text);
+                return;
+            }
+            const editor = ui.activeEditor();
+            if (!editor) {
+                ui.showWarningMessage("No active editor.");
+                return;
+            }
+            attachEditor(editor, false);
+        },
+        focus: () => ui.focusView(),
+        async send(text) {
+            const result = await controller.send(text);
+            if (result.ok || result.code !== "BROWSER_UNAVAILABLE")
+                return;
+            const choice = await ui.showErrorMessage(result.message, "Install");
+            if (choice !== "Install")
+                return;
+            if (await runInstall())
+                await controller.retryLast();
+        },
+    };
+}

package/dist/create-extension.d.ts

@@ -0,0 +1,33 @@
+import { type Provider } from "@chatbridge/core";
+import * as vscode from "vscode";
+import { SessionController } from "./session-controller.js";
+import { type ExtensionUiOptions } from "./ui-config.js";
+export interface CreateExtensionOptions {
+    /** Prefix for every contributed ID, e.g. "company-ai". */
+    id: string;
+    /** Shown as the view title and in notifications. */
+    displayName: string;
+    /** Always pinned; no dynamic provider loading. */
+    provider: Provider;
+    /** Directory name under ~/.config; defaults to `id`. Use the vendor
+     * CLI's `configDir` so one `auth login` serves both. */
+    configDir?: string;
+    /** Defaults; the user's `<id>.timeoutSec` / `<id>.headless` settings win. */
+    timeoutMs?: number;
+    headless?: boolean;
+    /** Test-only: overrides the config/auth-store base directory. */
+    baseDir?: string;
+    /** Vendor UI customisation: welcome text, banner, footer, Send colours. */
+    ui?: ExtensionUiOptions;
+    /** Path of `playwright/cli.js`; defaults to
+     * `<extension>/node_modules/playwright/cli.js`. */
+    playwrightCliPath?: string;
+}
+/** What `activate` returns: the E2E drives the controller directly. */
+export interface ExtensionApi {
+    controller: SessionController;
+}
+export declare function createExtension(opts: CreateExtensionOptions): {
+    activate: (context: vscode.ExtensionContext) => Promise<ExtensionApi>;
+    deactivate: () => Promise<void>;
+};

package/dist/create-extension.js

@@ -0,0 +1,92 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { ChatSession, createAuthStore, runLogin, } from "@chatbridge/core";
+import * as vscode from "vscode";
+import { ChatViewBridge } from "./chat-view-bridge.js";
+import { ChatViewProvider } from "./chat-view-provider.js";
+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 { resolveUiConfig } from "./ui-config.js";
+import { createVscodeUi } from "./vscode-ui.js";
+const DEFAULT_TIMEOUT_MS = 120_000;
+export function createExtension(opts) {
+    let controller;
+    async function activate(context) {
+        const missing = missingContributions(context.extension.packageJSON, opts.id);
+        if (missing.length > 0) {
+            throw new Error(`${opts.displayName}: package.json lacks contributes entries for "${opts.id}": ${missing.join(", ")}`);
+        }
+        const uiConfig = resolveUiConfig(opts.ui, context.extensionPath, existsSync);
+        const authStore = createAuthStore({
+            configDir: opts.configDir ?? opts.id,
+            providerName: opts.provider.name,
+            baseDir: opts.baseDir,
+        });
+        const output = vscode.window.createOutputChannel(opts.displayName);
+        const statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
+        context.subscriptions.push(output, statusBar);
+        const bridge = new ChatViewBridge(() => controller.getState(), {
+            send: (text) => void handlers.send(text),
+            removeAttachment: (i) => controller?.removeAttachment(i),
+            command: (name) => void handlers[name](),
+        });
+        function settings() {
+            const cfg = vscode.workspace.getConfiguration(opts.id);
+            return {
+                headless: cfg.get("headless", opts.headless ?? true),
+                timeoutMs: cfg.get("timeoutSec", (opts.timeoutMs ?? DEFAULT_TIMEOUT_MS) / 1000) * 1000,
+            };
+        }
+        function progress(message) {
+            output.appendLine(message);
+            statusBar.text = `$(sync~spin) ${message}`;
+            bridge.pushProgress(message);
+        }
+        controller = new SessionController({
+            openSession: () => ChatSession.open({
+                provider: opts.provider,
+                authStore,
+                ...settings(),
+                onProgress: progress,
+            }),
+            hints: {
+                BLOCKED: `Set the "${opts.id}.headless" setting to false and try again.`,
+            },
+            onChange: (state) => {
+                bridge.pushState(state);
+                if (state.status === "busy" || state.status === "opening")
+                    statusBar.show();
+                else
+                    statusBar.hide();
+            },
+        });
+        const cliPath = opts.playwrightCliPath ??
+            join(context.extensionPath, "node_modules", "playwright", "cli.js");
+        const handlers = createCommands({
+            displayName: opts.displayName,
+            controller,
+            ui: createVscodeUi(vscode, opts.id),
+            runLogin,
+            installBrowser,
+            loginOptions: () => ({ provider: opts.provider, authStore }),
+            installOptions: () => {
+                if (!existsSync(cliPath)) {
+                    throw new Error(`playwright is not bundled with this extension (looked for ${cliPath}).`);
+                }
+                return { cliPath };
+            },
+            clearAuth: () => authStore.clear(),
+        });
+        context.subscriptions.push(vscode.window.registerWebviewViewProvider(`${opts.id}.chat`, new ChatViewProvider(context.extensionUri, opts.displayName, bridge, uiConfig)));
+        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 };
+    }
+    async function deactivate() {
+        await controller?.close();
+    }
+    return { activate, deactivate };
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./protocol.js";
+export { type AddResult, type ChatSessionLike, type PendingAttachment, type SendResult, SessionController, type SessionControllerOptions, } 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";
+export { buildHtml, type HtmlInputs } from "./webview-html.js";
+export { type ExtensionUiOptions, type ResolvedUiConfig, resolveUiConfig, } from "./ui-config.js";
+export { createVscodeUi, type EditorSnapshot, type ProgressReporter, type VscodeUi, } from "./vscode-ui.js";
+export { type CommandDeps, type CommandHandlers, createCommands, } from "./commands.js";
+export { createExtension, type CreateExtensionOptions, type ExtensionApi, } from "./create-extension.js";

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from "./protocol.js";
+export { SessionController, } from "./session-controller.js";
+export { installBrowser, splitProgressLines, } from "./install-browser.js";
+export { COMMAND_NAMES, expectedContributions, missingContributions, } from "./manifest.js";
+export { ChatViewBridge, } from "./chat-view-bridge.js";
+export { buildHtml } from "./webview-html.js";
+export { resolveUiConfig, } from "./ui-config.js";
+export { createVscodeUi, } from "./vscode-ui.js";
+export { createCommands, } from "./commands.js";
+export { createExtension, } from "./create-extension.js";

package/dist/install-browser.d.ts

@@ -0,0 +1,33 @@
+export interface ChildLike {
+    stdout: {
+        on(event: "data", listener: (chunk: Buffer | string) => void): unknown;
+    } | null;
+    stderr: {
+        on(event: "data", listener: (chunk: Buffer | string) => void): unknown;
+    } | null;
+    on(event: "exit", listener: (code: number | null) => void): unknown;
+    on(event: "error", listener: (err: Error) => void): unknown;
+}
+export type SpawnFn = (command: string, args: string[], opts: {
+    env: Record<string, string | undefined>;
+}) => ChildLike;
+export interface InstallBrowserOptions {
+    /** Absolute path of `playwright/cli.js` inside the extension's node_modules. */
+    cliPath: string;
+    /**
+     * The Node binary to run it with; the extension host's process.execPath
+     * (Electron) works with ELECTRON_RUN_AS_NODE=1.
+     */
+    execPath?: string;
+    env?: Record<string, string | undefined>;
+    spawn?: SpawnFn;
+    /** One call per progress line (download names, progress bars). */
+    onProgress?: (line: string) => void;
+}
+/**
+ * Playwright redraws its progress bar with `\r`; treat every `\r` or `\n`
+ * as a line break and drop blanks.
+ */
+export declare function splitProgressLines(chunk: string): string[];
+/** Runs `playwright install chromium` and resolves when it exits 0. */
+export declare function installBrowser(opts: InstallBrowserOptions): Promise<void>;

package/dist/install-browser.js

@@ -0,0 +1,39 @@
+import { spawn as nodeSpawn } from "node:child_process";
+/**
+ * Playwright redraws its progress bar with `\r`; treat every `\r` or `\n`
+ * as a line break and drop blanks.
+ */
+export function splitProgressLines(chunk) {
+    return chunk
+        .split(/\r?\n|\r/)
+        .map((l) => l.trim())
+        .filter((l) => l !== "");
+}
+/** Runs `playwright install chromium` and resolves when it exits 0. */
+export function installBrowser(opts) {
+    const spawn = opts.spawn ?? ((c, a, o) => nodeSpawn(c, a, o));
+    const child = spawn(opts.execPath ?? process.execPath, [opts.cliPath, "install", "chromium"], {
+        env: { ...(opts.env ?? process.env), ELECTRON_RUN_AS_NODE: "1" },
+    });
+    let lastStderr = "";
+    return new Promise((resolve, reject) => {
+        child.stdout?.on("data", (chunk) => {
+            for (const line of splitProgressLines(String(chunk)))
+                opts.onProgress?.(line);
+        });
+        child.stderr?.on("data", (chunk) => {
+            const lines = splitProgressLines(String(chunk));
+            if (lines.length > 0)
+                lastStderr = lines[lines.length - 1];
+        });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`playwright install chromium exited with ${code ?? "signal"}${lastStderr ? `: ${lastStderr}` : ""}`));
+            }
+        });
+    });
+}

package/dist/manifest.d.ts

@@ -0,0 +1,13 @@
+export declare const COMMAND_NAMES: readonly ["login", "logout", "newChat", "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): {
+    viewContainers: string[];
+    views: string[];
+    commands: string[];
+};
+/**
+ * The contributes entries a vendor manifest must declare for `id`, that
+ * this package.json lacks. Empty when the manifest is complete.
+ */
+export declare function missingContributions(packageJSON: unknown, id: string): string[];