npm - @pasko70/pibo - Versions diffs - 1.2.0 → 1.3.0 - Mend

@pasko70/pibo 1.2.0 → 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/dist/apps/chat/static-assets.js +1 -1
package/dist/apps/chat-vscode-web/assets/index-B5QK07zO.css +2 -0
package/dist/apps/chat-vscode-web/assets/index-C3GTPyDo.js +41 -0
package/dist/apps/chat-vscode-web/index.html +14 -0
package/dist/apps/vscode-artifacts/latest.vsix +0 -0
package/dist/apps/vscode-artifacts/pibo-vscode-1.3.0.vsix +0 -0
package/dist/cli.js +17 -0
package/dist/vscode/cli.js +90 -0
package/dist/vscode/code-cli.js +119 -0
package/dist/vscode/install.js +177 -0
package/dist/vscode/status.js +80 -0
package/dist/vscode/types.js +14 -0
package/dist/vscode/uninstall.js +49 -0
package/dist/vscode/vsix-fetcher.js +131 -0
package/docs/ops/vscode-extension-release.md +138 -0
package/package.json +5 -4

package/dist/apps/chat-vscode-web/index.html ADDED Viewed

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="de" class="dark">
+	<head>
+		<meta charset="UTF-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+		<meta name="theme-color" content="#101d22" />
+		<title>Pibo</title>
+		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-C3GTPyDo.js"></script>
+		<link rel="stylesheet" crossorigin href="/apps/chat-vscode/assets/index-B5QK07zO.css">
+	</head>
+	<body>
+		<div id="root"></div>
+	</body>
+</html>

package/dist/apps/vscode-artifacts/latest.vsix ADDED Viewed

Binary file

package/dist/apps/vscode-artifacts/pibo-vscode-1.3.0.vsix ADDED Viewed

Binary file

package/dist/cli.js CHANGED Viewed

@@ -97,6 +97,11 @@ export async function runPiboCli(argv = process.argv) {
         await runRalphCli([argv[0] ?? "node", "pibo ralph", ...argv.slice(3)]);
         return;
     }
+    if (argv[2] === "vscode") {
+        const { runVscodeCli } = await import("./vscode/cli.js");
+        await runVscodeCli([argv[0] ?? "node", "pibo vscode", ...argv.slice(3)]);
+        return;
+    }
     if (argv[2] === "config" && (argv[3] === "--help" || argv[3] === "-h" || argv.length === 3)) {
         printConfigDiscovery();
         return;
@@ -218,6 +223,17 @@ export async function runPiboCli(argv = process.argv) {
         const { runRalphCli } = await import("./ralph/cli.js");
         await runRalphCli([argv[0] ?? "node", "pibo ralph", ...args]);
     });
+    program
+        .command("vscode")
+        .description("Manage the Pibo VS Code extension")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runVscodeCli } = await import("./vscode/cli.js");
+        await runVscodeCli([argv[0] ?? "node", "pibo vscode", ...args]);
+    });
     const config = program.command("config").description(`Manage pibo config at ${getDefaultPiboConfigPath()}`).helpOption(false);
     config.action(() => {
         printConfigDiscovery();
@@ -365,6 +381,7 @@ Commands:
   skills       Manage Pibo user skills
   cron         Manage scheduled Pibo jobs
   ralph        Manage continuous Ralph jobs
+  vscode       Manage the Pibo VS Code extension
   profile      Inspect a pibo profile
   tui          Start the direct Pi TUI
   tui:routed   Start the local routed Pibo TUI

package/dist/vscode/cli.js ADDED Viewed

@@ -0,0 +1,90 @@
+/**
+ * `pibo vscode` sub-command — manage the Pibo VS Code extension.
+ *
+ * Sub-commands:
+ *   install     Download and install the latest Pibo VS Code extension.
+ *   uninstall   Remove the installed Pibo VS Code extension.
+ *   status      Show whether the extension is installed and which CLI is used.
+ */
+import { Command } from "commander";
+import { runInstall } from "./install.js";
+import { runStatus, formatStatusText } from "./status.js";
+import { runUninstall } from "./uninstall.js";
+function printDiscovery() {
+    console.log(`pibo vscode
+Manage the Pibo VS Code extension.
+Commands:
+  install     Download and install the latest Pibo VS Code extension
+  uninstall   Remove the installed Pibo VS Code extension
+  status      Show whether the extension is installed
+Next: pibo vscode install --help`);
+}
+export async function runVscodeCli(argv = process.argv) {
+    const program = new Command();
+    program.name("pibo vscode").description("Manage the Pibo VS Code extension").helpOption("-h, --help");
+    program
+        .command("install")
+        .description("Download and install the Pibo VS Code extension")
+        .option("--version <tag>", "Pibo release tag to install (e.g., v1.3.0). Defaults to latest.")
+        .option("--vsix <path>", "Install from a local .vsix file instead of fetching a release")
+        .option("--from-url <url>", "Fetch a .vsix from the given URL (release tag will be inferred)")
+        .option("--owner <owner>", "GitHub owner for the release source", "Pascapone")
+        .option("--repo <repo>", "GitHub repo for the release source", "pibo")
+        .option("--no-cache", "Skip the VSIX download cache")
+        .option("--json", "Print JSON")
+        .action(async (options) => {
+        const result = await runInstall({
+            vsixPath: options.vsix,
+            fromUrl: options.fromUrl,
+            version: options.version,
+            owner: options.owner,
+            repo: options.repo,
+            skipCache: options.cache === false,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else if (result.status === "installed") {
+            console.log(`installed\t${result.tagName}\t${result.vsixPath}`);
+        }
+        else {
+            process.exitCode = 1;
+        }
+    });
+    program
+        .command("uninstall")
+        .description("Remove the installed Pibo VS Code extension")
+        .option("--json", "Print JSON")
+        .action(async (options) => {
+        const result = await runUninstall();
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else if (result.status !== "uninstalled") {
+            process.exitCode = 1;
+        }
+    });
+    program
+        .command("status")
+        .description("Show the Pibo VS Code extension install status")
+        .option("--owner <owner>", "GitHub owner for the release source", "Pascapone")
+        .option("--repo <repo>", "GitHub repo for the release source", "pibo")
+        .option("--json", "Print JSON")
+        .action(async (options) => {
+        const status = await runStatus({ owner: options.owner, repo: options.repo });
+        if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+        }
+        else {
+            console.log(formatStatusText(status));
+        }
+    });
+    if (argv.length <= 2 || argv.includes("--help") || argv.includes("-h")) {
+        printDiscovery();
+        return;
+    }
+    await program.parseAsync(argv);
+}

package/dist/vscode/code-cli.js ADDED Viewed

@@ -0,0 +1,119 @@
+/**
+ * Detection of the VS Code CLI binary and wrapper around it.
+ *
+ * The `code` binary is what VS Code installs on `$PATH` when the user enables
+ * "Shell Command: Install 'code' command in PATH" from the VS Code command
+ * palette. It is the only supported way for `pibo vscode install` to install
+ * the extension. If no supported binary is on `$PATH`, install fails with a
+ * clear error pointing at https://code.visualstudio.com/.
+ */
+import { spawn as defaultSpawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, join } from "node:path";
+export const SUPPORTED_CODE_BINARIES = ["code", "code-insiders", "codium"];
+function splitPathEnv(pathValue) {
+    if (!pathValue)
+        return [];
+    return pathValue.split(delimiter).filter((entry) => entry.length > 0);
+}
+function firstExisting(candidates) {
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+export function detectCodeBinary(options = {}) {
+    const pathValue = options.path ?? options.env?.PATH ?? process.env.PATH ?? "";
+    const directories = splitPathEnv(pathValue);
+    for (const binary of SUPPORTED_CODE_BINARIES) {
+        const candidates = directories.map((dir) => join(dir, binary));
+        const found = firstExisting(candidates);
+        if (found)
+            return { binary, path: found };
+    }
+    return undefined;
+}
+const COLLECT_BUFFER_LIMIT = 1024 * 1024; // 1 MiB
+export function runCodeCommand(options) {
+    const spawnImpl = options.spawnImpl ?? defaultSpawn;
+    const env = options.env ?? process.env;
+    return new Promise((resolveInvocation, rejectInvocation) => {
+        let child;
+        try {
+            child = spawnImpl(options.binary, [...options.args], {
+                env,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (error) {
+            rejectInvocation(error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let stdoutLength = 0;
+        let stderrLength = 0;
+        let timedOut = false;
+        const timeoutHandle = typeof options.timeoutMs === "number"
+            ? setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGKILL");
+            }, options.timeoutMs)
+            : null;
+        child.stdout?.on("data", (chunk) => {
+            stdoutLength += chunk.length;
+            if (stdoutLength <= COLLECT_BUFFER_LIMIT)
+                stdoutChunks.push(chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderrLength += chunk.length;
+            if (stderrLength <= COLLECT_BUFFER_LIMIT)
+                stderrChunks.push(chunk);
+        });
+        child.on("error", (error) => {
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            rejectInvocation(error);
+        });
+        child.on("close", (code) => {
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            if (timedOut) {
+                rejectInvocation(new Error(`code command timed out after ${options.timeoutMs}ms`));
+                return;
+            }
+            resolveInvocation({
+                stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+                stderr: Buffer.concat(stderrChunks).toString("utf8"),
+                exitCode: code ?? -1,
+            });
+        });
+    });
+}
+export async function listInstalledExtensions(options) {
+    const result = await runCodeCommand({
+        binary: options.binary,
+        args: ["--list-extensions", "--show-versions"],
+        spawnImpl: options.spawnImpl,
+        env: options.env,
+        timeoutMs: 30_000,
+    });
+    if (result.exitCode !== 0) {
+        throw new Error(`code --list-extensions failed: ${result.stderr || result.stdout || `exit ${result.exitCode}`}`);
+    }
+    const entries = [];
+    for (const rawLine of result.stdout.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const atIndex = line.lastIndexOf("@");
+        if (atIndex > 0) {
+            entries.push({ id: line.slice(0, atIndex), version: line.slice(atIndex + 1) });
+        }
+        else {
+            entries.push({ id: line });
+        }
+    }
+    return entries;
+}

package/dist/vscode/install.js ADDED Viewed

@@ -0,0 +1,177 @@
+/**
+ * `pibo vscode install` — install the Pibo VS Code extension.
+ *
+ * Resolution order for the VSIX artifact:
+ *  1. `--vsix <path>`     → use the local file directly
+ *  2. `--from-url <url>`  → download from the given URL
+ *  3. default             → fetch the latest GitHub Release for the repo and
+ *                            use its `.vsix` asset (optionally pinned by
+ *                            `--version <tag>`)
+ *
+ * The resolved VSIX is cached under `~/.pibo/vscode/cache/<tagName>/` so
+ * repeated installs do not re-download.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { detectCodeBinary, listInstalledExtensions, runCodeCommand } from "./code-cli.js";
+import { downloadVsixAsset, fetchLatestVsix, isVsixAsset } from "./vsix-fetcher.js";
+import { DEFAULT_GITHUB_OWNER, DEFAULT_GITHUB_REPO, PIBO_VSCODE_CACHE_DIR, PIBO_VSCODE_EXTENSION_ID, } from "./types.js";
+import { findVsixAsset, fetchRelease } from "./vsix-fetcher.js";
+const DEFAULT_LOG = (message) => {
+    console.log(message);
+};
+const DEFAULT_ERROR = (message) => {
+    process.stderr.write(`${message}\n`);
+};
+function getCacheDir(options) {
+    if (options.cacheDir)
+        return options.cacheDir;
+    const base = options.env?.PIBO_HOME ?? join(homedir(), ".pibo");
+    return join(base, PIBO_VSCODE_CACHE_DIR, "cache");
+}
+function cacheKeyForVersion(tagName) {
+    return tagName.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function readCachedVsix(cacheDir, tagName) {
+    const dir = join(cacheDir, cacheKeyForVersion(tagName));
+    const path = join(dir, "pibo.vsix");
+    return existsSync(path) ? path : undefined;
+}
+function writeCachedVsix(cacheDir, tagName, bytes) {
+    const dir = join(cacheDir, cacheKeyForVersion(tagName));
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, "pibo.vsix");
+    writeFileSync(path, bytes);
+    return path;
+}
+function cachedTagManifestPath(cacheDir) {
+    return join(cacheDir, "last-installed.json");
+}
+function readCachedTagManifest(cacheDir) {
+    const path = cachedTagManifestPath(cacheDir);
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const json = JSON.parse(readFileSync(path, "utf8"));
+        return json;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeCachedTagManifest(cacheDir, tagName, vsixPath) {
+    const path = cachedTagManifestPath(cacheDir);
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(path, JSON.stringify({ tagName, vsixPath, installedAt: new Date().toISOString() }, null, 2));
+}
+export async function resolveVsixArtifact(options) {
+    if (options.vsixPath) {
+        const absolute = resolve(options.vsixPath);
+        if (!existsSync(absolute)) {
+            throw new Error(`VSIX file not found at ${absolute}`);
+        }
+        return { tagName: "local", vsixPath: absolute };
+    }
+    if (!options.skipCache && !options.version) {
+        const cachedTag = readCachedTagManifest(options.cacheDir);
+        if (cachedTag?.tagName && cachedTag.vsixPath && existsSync(cachedTag.vsixPath)) {
+            return { tagName: cachedTag.tagName, vsixPath: cachedTag.vsixPath };
+        }
+    }
+    if (options.fromUrl) {
+        const release = await fetchRelease({ owner: options.owner, repo: options.repo, fetchImpl: options.fetchImpl });
+        const asset = findVsixAsset(release) ?? { name: "remote.vsix", browserDownloadUrl: options.fromUrl, size: 0, contentType: "application/octet-stream" };
+        const bytes = await downloadVsixAsset({ url: options.fromUrl, fetchImpl: options.fetchImpl });
+        const cachedPath = writeCachedVsix(options.cacheDir, release.tagName, bytes);
+        return { tagName: release.tagName, vsixPath: cachedPath, bytes };
+    }
+    const result = await fetchLatestVsix({
+        owner: options.owner,
+        repo: options.repo,
+        tagName: options.version,
+        fetchImpl: options.fetchImpl,
+    });
+    if (!options.skipCache) {
+        const cached = readCachedVsix(options.cacheDir, result.tagName);
+        if (cached)
+            return { tagName: result.tagName, vsixPath: cached };
+    }
+    const cachedPath = writeCachedVsix(options.cacheDir, result.tagName, result.bytes);
+    return { tagName: result.tagName, vsixPath: cachedPath, bytes: result.bytes };
+}
+export async function runInstall(options) {
+    const log = options.log ?? DEFAULT_LOG;
+    const errorLog = options.error ?? DEFAULT_ERROR;
+    const owner = options.owner ?? DEFAULT_GITHUB_OWNER;
+    const repo = options.repo ?? DEFAULT_GITHUB_REPO;
+    const cacheDir = getCacheDir(options);
+    const detected = detectCodeBinary({ env: options.env });
+    if (!detected) {
+        const message = `No VS Code CLI found on PATH. Install VS Code (https://code.visualstudio.com/) and run 'Shell Command: Install code command in PATH' from the VS Code command palette.`;
+        errorLog(message);
+        return { status: "failed", reason: "no-code-cli" };
+    }
+    let artifact;
+    try {
+        artifact = await resolveVsixArtifact({
+            vsixPath: options.vsixPath,
+            fromUrl: options.fromUrl,
+            version: options.version,
+            owner,
+            repo,
+            fetchImpl: options.fetchImpl,
+            cacheDir,
+            skipCache: options.skipCache,
+        });
+    }
+    catch (fetchError) {
+        const reason = fetchError instanceof Error ? fetchError.message : String(fetchError);
+        errorLog(`Failed to obtain VSIX: ${reason}`);
+        return { status: "failed", reason };
+    }
+    log(`Installing pibo VS Code extension ${artifact.tagName} from ${artifact.vsixPath} via ${detected.path}…`);
+    let installResult;
+    try {
+        installResult = await runCodeCommand({
+            binary: detected.path,
+            args: ["--install-extension", artifact.vsixPath, "--force"],
+            spawnImpl: options.spawnImpl,
+            env: options.env,
+            timeoutMs: 120_000,
+        });
+    }
+    catch (spawnError) {
+        const reason = spawnError instanceof Error ? spawnError.message : String(spawnError);
+        errorLog(`Failed to invoke ${detected.binary}: ${reason}`);
+        return { status: "failed", reason, codeBinary: detected.path, tagName: artifact.tagName };
+    }
+    if (installResult.exitCode !== 0) {
+        const reason = `code --install-extension exited with code ${installResult.exitCode}: ${installResult.stderr || installResult.stdout}`;
+        errorLog(reason);
+        return { status: "failed", reason, codeBinary: detected.path, tagName: artifact.tagName };
+    }
+    writeCachedTagManifest(cacheDir, artifact.tagName, artifact.vsixPath);
+    try {
+        const installed = await listInstalledExtensions({
+            binary: detected.path,
+            spawnImpl: options.spawnImpl,
+            env: options.env,
+        });
+        const ours = installed.find((entry) => entry.id === PIBO_VSCODE_EXTENSION_ID);
+        if (ours) {
+            log(`Installed ${ours.id}@${ours.version ?? "?"} via ${detected.path}`);
+        }
+        else {
+            log(`code --install-extension reported success but ${PIBO_VSCODE_EXTENSION_ID} is not in the installed list.`);
+        }
+    }
+    catch (listError) {
+        // Listing the installed extensions is a best-effort check; do not fail the install on a listing error.
+        const reason = listError instanceof Error ? listError.message : String(listError);
+        log(`Install completed; failed to verify via --list-extensions: ${reason}`);
+    }
+    return { status: "installed", tagName: artifact.tagName, vsixPath: artifact.vsixPath, codeBinary: detected.path };
+}
+// Re-export for symmetry with code-cli.ts consumers.
+export { isVsixAsset };

package/dist/vscode/status.js ADDED Viewed

@@ -0,0 +1,80 @@
+/**
+ * `pibo vscode status` — report whether the Pibo VS Code extension is
+ * installed, the local VS Code CLI binary, and the cached VSIX artifacts.
+ */
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { detectCodeBinary, listInstalledExtensions } from "./code-cli.js";
+import { fetchRelease } from "./vsix-fetcher.js";
+import { DEFAULT_GITHUB_OWNER, DEFAULT_GITHUB_REPO, PIBO_VSCODE_CACHE_DIR, PIBO_VSCODE_EXTENSION_ID, } from "./types.js";
+function getCacheDir(options) {
+    if (options.cacheDir)
+        return options.cacheDir;
+    const base = options.env?.PIBO_HOME ?? join(homedir(), ".pibo");
+    return join(base, PIBO_VSCODE_CACHE_DIR, "cache");
+}
+function listCachedReleases(cacheDir, limit) {
+    if (!existsSync(cacheDir))
+        return [];
+    const entries = readdirSync(cacheDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name !== "node_modules")
+        .map((entry) => ({ name: entry.name, mtimeMs: statSync(join(cacheDir, entry.name)).mtimeMs }))
+        .sort((a, b) => b.mtimeMs - a.mtimeMs)
+        .slice(0, limit)
+        .map((entry) => entry.name);
+    return entries;
+}
+export async function runStatus(options = {}) {
+    const owner = options.owner ?? DEFAULT_GITHUB_OWNER;
+    const repo = options.repo ?? DEFAULT_GITHUB_REPO;
+    const cacheDir = getCacheDir(options);
+    const limit = options.limit ?? 5;
+    const detected = detectCodeBinary({ env: options.env });
+    let installed = false;
+    let version;
+    if (detected) {
+        try {
+            const installedExtensions = await listInstalledExtensions({
+                binary: detected.path,
+                spawnImpl: options.spawnImpl,
+                env: options.env,
+            });
+            const ours = installedExtensions.find((entry) => entry.id === PIBO_VSCODE_EXTENSION_ID);
+            if (ours) {
+                installed = true;
+                version = ours.version;
+            }
+        }
+        catch {
+            // Listing failed; treat as not-installed for status purposes.
+            installed = false;
+        }
+    }
+    const cachedReleases = listCachedReleases(cacheDir, limit);
+    let availableReleases = [];
+    try {
+        const release = await fetchRelease({ owner, repo, fetchImpl: options.fetchImpl });
+        availableReleases = [release.tagName];
+    }
+    catch {
+        // Network failure is non-fatal for status.
+    }
+    return {
+        installed,
+        version,
+        codeBinary: detected?.path,
+        vsixCacheDir: cacheDir,
+        availableReleases,
+    };
+}
+export function formatStatusText(status) {
+    const lines = [];
+    lines.push(`extension: ${status.installed ? `${PIBO_VSCODE_EXTENSION_ID}@${status.version ?? "?"}` : "not installed"}`);
+    lines.push(`code binary: ${status.codeBinary ?? "(not on PATH)"}`);
+    lines.push(`vsix cache: ${status.vsixCacheDir}`);
+    if (status.availableReleases.length > 0) {
+        lines.push(`latest release: ${status.availableReleases[0]}`);
+    }
+    return lines.join("\n");
+}

package/dist/vscode/types.js ADDED Viewed

@@ -0,0 +1,14 @@
+/**
+ * Types and constants for the `pibo vscode` sub-command.
+ *
+ * The pibo VS Code extension is a thin VS Code client that opens a WebView
+ * pointing at the gateway-served chat-vscode-web app. The extension itself
+ * ships as a `.vsix` artifact, published to the VS Code Marketplace and
+ * mirrored on GitHub Releases.
+ */
+export const PIBO_VSCODE_EXTENSION_PUBLISHER = "pibo";
+export const PIBO_VSCODE_EXTENSION_NAME = "pibo-vscode";
+export const PIBO_VSCODE_EXTENSION_ID = `${PIBO_VSCODE_EXTENSION_PUBLISHER}.${PIBO_VSCODE_EXTENSION_NAME}`;
+export const DEFAULT_GITHUB_OWNER = "Pascapone";
+export const DEFAULT_GITHUB_REPO = "pibo";
+export const PIBO_VSCODE_CACHE_DIR = "vscode";

package/dist/vscode/uninstall.js ADDED Viewed

@@ -0,0 +1,49 @@
+/**
+ * `pibo vscode uninstall` — remove the installed Pibo VS Code extension.
+ */
+import { detectCodeBinary, runCodeCommand } from "./code-cli.js";
+import { PIBO_VSCODE_EXTENSION_ID } from "./types.js";
+const DEFAULT_LOG = (message) => {
+    console.log(message);
+};
+const DEFAULT_ERROR = (message) => {
+    process.stderr.write(`${message}\n`);
+};
+export async function runUninstall(options = {}) {
+    const log = options.log ?? DEFAULT_LOG;
+    const errorLog = options.error ?? DEFAULT_ERROR;
+    const detected = detectCodeBinary({ env: options.env });
+    if (!detected) {
+        errorLog(`No VS Code CLI found on PATH.`);
+        return { status: "failed", reason: "no-code-cli" };
+    }
+    log(`Uninstalling ${PIBO_VSCODE_EXTENSION_ID} via ${detected.path}…`);
+    let result;
+    try {
+        result = await runCodeCommand({
+            binary: detected.path,
+            args: ["--uninstall-extension", PIBO_VSCODE_EXTENSION_ID],
+            spawnImpl: options.spawnImpl,
+            env: options.env,
+            timeoutMs: 60_000,
+        });
+    }
+    catch (spawnError) {
+        const reason = spawnError instanceof Error ? spawnError.message : String(spawnError);
+        errorLog(`Failed to invoke ${detected.binary}: ${reason}`);
+        return { status: "failed", reason, codeBinary: detected.path };
+    }
+    if (result.exitCode !== 0) {
+        const stderr = result.stderr || result.stdout;
+        // VS Code returns a non-zero exit when the extension is not installed; treat that as "not-installed".
+        if (/not found|not installed|Cannot find extension/i.test(stderr)) {
+            log(`${PIBO_VSCODE_EXTENSION_ID} was not installed.`);
+            return { status: "not-installed", codeBinary: detected.path };
+        }
+        const reason = `code --uninstall-extension exited with code ${result.exitCode}: ${stderr}`;
+        errorLog(reason);
+        return { status: "failed", reason, codeBinary: detected.path };
+    }
+    log(`Uninstalled ${PIBO_VSCODE_EXTENSION_ID}`);
+    return { status: "uninstalled", codeBinary: detected.path };
+}