@pasko70/pibo 1.9.7 → 1.9.9

package/dist/user-skills/store.js

@@ -1,267 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { randomUUID } from "node:crypto";
-const STORE_VERSION = 1;
-const SKILL_DIR_NAME = "user-skills";
-const STORE_FILE_NAME = "user-skills.json";
-export function defaultUserSkillStorePath(cwd = process.cwd()) {
-    return resolve(cwd, ".pibo", STORE_FILE_NAME);
-}
-export function defaultUserSkillDir(cwd = process.cwd()) {
-    return resolve(cwd, ".pibo", SKILL_DIR_NAME);
-}
-export function ensureUserSkillStorage(cwd = process.cwd()) {
-    mkdirSync(defaultUserSkillDir(cwd), { recursive: true });
-}
-export function loadUserSkillStore(cwd = process.cwd()) {
-    const path = defaultUserSkillStorePath(cwd);
-    if (!existsSync(path))
-        return { version: STORE_VERSION, skills: [] };
-    const parsed = JSON.parse(readFileSync(path, "utf-8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new Error(`Invalid user skills store at ${path}`);
-    }
-    const data = parsed;
-    if (data.version !== STORE_VERSION || !Array.isArray(data.skills)) {
-        throw new Error(`Unsupported user skills store at ${path}`);
-    }
-    return {
-        version: STORE_VERSION,
-        skills: data.skills.map(sanitizeStoredSkill),
-    };
-}
-export function saveUserSkillStore(data, cwd = process.cwd()) {
-    const path = defaultUserSkillStorePath(cwd);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, `${JSON.stringify({ version: STORE_VERSION, skills: data.skills }, null, 2)}\n`, "utf-8");
-}
-function readUserSkillDescription(skill, cwd = process.cwd()) {
-    const markdown = readSkillMarkdown(skill, cwd);
-    const parsed = parseSkillMd(markdown);
-    return parsed.description;
-}
-export function listUserSkills(cwd = process.cwd()) {
-    const skills = loadUserSkillStore(cwd).skills;
-    for (const skill of skills) {
-        skill.description = readUserSkillDescription(skill, cwd);
-    }
-    return skills;
-}
-export function findUserSkill(idOrName, cwd = process.cwd()) {
-    const lookup = idOrName.trim();
-    const store = loadUserSkillStore(cwd);
-    const stored = store.skills.find((skill) => skill.id === lookup || skill.name === lookup);
-    if (!stored)
-        return undefined;
-    stored.description = readUserSkillDescription(stored, cwd);
-    return stored;
-}
-function validateSkillName(name, existingId, cwd = process.cwd()) {
-    const trimmed = name.trim();
-    if (!trimmed)
-        throw new Error("Skill name is required");
-    if (trimmed.length > 64)
-        throw new Error("Skill name is too long (max 64 characters)");
-    if (!/^[a-z][a-z0-9-]*$/.test(trimmed)) {
-        throw new Error("Skill name must be lowercase kebab-case, e.g. my-skill");
-    }
-    const store = loadUserSkillStore(cwd);
-    const existing = store.skills.find((s) => s.name === trimmed && s.id !== existingId);
-    if (existing)
-        throw new Error(`Skill name "${trimmed}" already exists`);
-    return trimmed;
-}
-export function readSkillMarkdown(skill, cwd = process.cwd()) {
-    const fullPath = resolve(cwd, skill.path);
-    if (!existsSync(fullPath))
-        return "";
-    return readFileSync(fullPath, "utf-8");
-}
-export function createUserSkill(input, cwd = process.cwd()) {
-    ensureUserSkillStorage(cwd);
-    const name = validateSkillName(input.name, undefined, cwd);
-    const description = (input.description ?? "").trim();
-    const id = randomUUID();
-    const skillDir = join(defaultUserSkillDir(cwd), name);
-    mkdirSync(skillDir, { recursive: true });
-    const skillPath = join(skillDir, "SKILL.md");
-    const incoming = input.markdown ?? "";
-    const parsedIncoming = parseSkillMd(incoming);
-    const body = parsedIncoming.body || incoming;
-    const effectiveDescription = description || parsedIncoming.description;
-    const markdown = buildSkillMd(name, effectiveDescription, body);
-    writeFileSync(skillPath, markdown, "utf-8");
-    const now = new Date().toISOString();
-    const skill = {
-        id,
-        name,
-        description: effectiveDescription,
-        path: skillPath,
-        enabled: true,
-        source: "user-created",
-        createdAt: now,
-        updatedAt: now,
-    };
-    // Do not persist description in JSON store; it lives in SKILL.md frontmatter only.
-    const storedSkill = { ...skill };
-    delete storedSkill.description;
-    const store = loadUserSkillStore(cwd);
-    store.skills.push(storedSkill);
-    store.skills.sort((a, b) => a.name.localeCompare(b.name));
-    saveUserSkillStore(store, cwd);
-    return skill;
-}
-export function updateUserSkill(id, input, cwd = process.cwd()) {
-    const store = loadUserSkillStore(cwd);
-    const index = store.skills.findIndex((s) => s.id === id);
-    if (index < 0)
-        throw new Error(`Skill "${id}" not found`);
-    const existing = store.skills[index];
-    let name = existing.name;
-    if (input.name !== undefined) {
-        name = validateSkillName(input.name, existing.id, cwd);
-    }
-    const currentMarkdown = existsSync(existing.path) ? readFileSync(existing.path, "utf-8") : "";
-    const parsed = parseSkillMd(currentMarkdown);
-    let description = parsed.description;
-    if (input.description !== undefined) {
-        description = input.description.trim();
-    }
-    const skillDir = join(defaultUserSkillDir(cwd), name);
-    const skillPath = join(skillDir, "SKILL.md");
-    if (name !== existing.name) {
-        const oldDir = dirname(existing.path);
-        if (existsSync(oldDir) && oldDir !== skillDir) {
-            mkdirSync(dirname(skillDir), { recursive: true });
-            renameDirContents(oldDir, skillDir);
-            if (existsSync(oldDir)) {
-                rmSync(oldDir, { recursive: true, force: true });
-            }
-        }
-    }
-    if (input.markdown !== undefined) {
-        const parsedIncoming = parseSkillMd(input.markdown);
-        const body = parsedIncoming.body || input.markdown;
-        const effectiveDescription = input.description !== undefined ? description : parsedIncoming.description || description;
-        description = effectiveDescription;
-        const markdown = buildSkillMd(name, effectiveDescription, body);
-        writeFileSync(skillPath, markdown, "utf-8");
-    }
-    else if (name !== existing.name || description !== parsed.description) {
-        const currentMarkdown = existsSync(existing.path) ? readFileSync(existing.path, "utf-8") : "";
-        const { body } = parseSkillMd(currentMarkdown);
-        writeFileSync(skillPath, buildSkillMd(name, description, body), "utf-8");
-    }
-    const updated = {
-        ...existing,
-        name,
-        description,
-        path: skillPath,
-        ...(input.enabled !== undefined ? { enabled: input.enabled } : {}),
-        updatedAt: new Date().toISOString(),
-    };
-    // Strip description before persisting to JSON store.
-    const storedUpdated = { ...updated };
-    delete storedUpdated.description;
-    store.skills[index] = storedUpdated;
-    store.skills.sort((a, b) => a.name.localeCompare(b.name));
-    saveUserSkillStore(store, cwd);
-    return updated;
-}
-export function deleteUserSkill(id, cwd = process.cwd()) {
-    const store = loadUserSkillStore(cwd);
-    const index = store.skills.findIndex((s) => s.id === id);
-    if (index < 0)
-        return undefined;
-    const [removed] = store.skills.splice(index, 1);
-    const skillDir = dirname(removed.path);
-    if (existsSync(skillDir)) {
-        rmSync(skillDir, { recursive: true, force: true });
-    }
-    saveUserSkillStore(store, cwd);
-    return removed;
-}
-export function setUserSkillEnabled(id, enabled, cwd = process.cwd()) {
-    return updateUserSkill(id, { enabled }, cwd);
-}
-function sanitizeStoredSkill(value) {
-    const candidate = value;
-    if (!candidate || typeof candidate !== "object")
-        throw new Error("Invalid user skill entry");
-    if (typeof candidate.id !== "string" || typeof candidate.name !== "string" || typeof candidate.path !== "string") {
-        throw new Error("Invalid user skill entry");
-    }
-    return {
-        id: candidate.id,
-        name: candidate.name.trim(),
-        description: "",
-        path: candidate.path.trim(),
-        enabled: candidate.enabled !== false,
-        source: isValidSource(candidate.source) ? candidate.source : "user-created",
-        sourceUrl: typeof candidate.sourceUrl === "string" ? candidate.sourceUrl.trim() : undefined,
-        createdAt: typeof candidate.createdAt === "string" ? candidate.createdAt : new Date().toISOString(),
-        updatedAt: typeof candidate.updatedAt === "string" ? candidate.updatedAt : new Date().toISOString(),
-    };
-}
-function isValidSource(source) {
-    return source === "user-created" || source === "skills.sh" || source === "github";
-}
-export function parseSkillMd(content) {
-    const trimmed = content.trim();
-    if (!trimmed.startsWith("---")) {
-        return { name: "", description: "", body: trimmed };
-    }
-    const endIdx = trimmed.indexOf("---", 3);
-    if (endIdx === -1) {
-        return { name: "", description: "", body: trimmed };
-    }
-    const frontmatter = trimmed.slice(3, endIdx).trim();
-    const body = trimmed.slice(endIdx + 3).trimStart();
-    const parsed = parseSimpleYaml(frontmatter);
-    return {
-        name: typeof parsed.name === "string" ? parsed.name : "",
-        description: typeof parsed.description === "string" ? parsed.description : "",
-        body,
-    };
-}
-export function buildSkillMd(name, description, body) {
-    const cleanBody = body.trimStart();
-    return `---\nname: ${name}\ndescription: ${description}\n---\n\n${cleanBody}`;
-}
-function parseSimpleYaml(text) {
-    const result = {};
-    for (const line of text.split("\n")) {
-        const colonIdx = line.indexOf(":");
-        if (colonIdx <= 0)
-            continue;
-        const key = line.slice(0, colonIdx).trim();
-        const value = parseSimpleYamlScalar(line.slice(colonIdx + 1).trim());
-        if (key)
-            result[key] = value;
-    }
-    return result;
-}
-function parseSimpleYamlScalar(value) {
-    if (value.length >= 2) {
-        const quote = value[0];
-        if ((quote === '"' || quote === "'") && value[value.length - 1] === quote) {
-            return value.slice(1, -1);
-        }
-    }
-    return value;
-}
-function renameDirContents(oldDir, newDir) {
-    mkdirSync(newDir, { recursive: true });
-    for (const entry of readdirSync(oldDir)) {
-        const oldPath = join(oldDir, entry);
-        const newPath = join(newDir, entry);
-        const stat = statSync(oldPath);
-        if (stat.isDirectory()) {
-            renameDirContents(oldPath, newPath);
-            rmSync(oldPath, { recursive: true, force: true });
-        }
-        else {
-            writeFileSync(newPath, readFileSync(oldPath));
-        }
-    }
-}

package/dist/user-skills/types.js

@@ -1 +0,0 @@
-export {};

package/dist/vscode/cli.js

@@ -1,90 +0,0 @@
-/**
- * `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

@@ -1,119 +0,0 @@
-/**
- * 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

@@ -1,177 +0,0 @@
-/**
- * `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 };