@nklisch/pi-enhanced 0.2.3 → 0.2.5

package/node_modules/@nklisch/pi-plugins/dist/host.js

@@ -0,0 +1,669 @@
+import { execFile } from "node:child_process";
+import { chmod, cp, mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, writeFile, lstat } from "node:fs/promises";
+import { promisify } from "node:util";
+import { join, resolve } from "node:path";
+import { mergeMarketplaceCatalogs, readMarketplaceCatalog } from "./catalog.js";
+import { assertNoSymlinks, assertSafeName, assertSafeRelativePath, createPluginHostPaths, resolveContainedExistingPath, resolveContainedPath, } from "./paths.js";
+import { buildMcpConfig } from "./mcp.js";
+import { scanInstalledPlugins } from "./runtime-discovery.js";
+const execFileAsync = promisify(execFile);
+export const DEFAULT_REFRESH_TIMEOUT_MS = 10_000;
+const CHECK_ON_OPEN_MARKER = ".check-on-open";
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function throwIfAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    const error = new Error(signal.reason instanceof Error ? signal.reason.message : "operation cancelled");
+    error.name = "AbortError";
+    throw error;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function sourceFile(source) {
+    return Object.freeze({
+        kind: source.kind,
+        value: source.value,
+        ...(source.ref === undefined ? {} : { ref: source.ref }),
+    });
+}
+function parseSourceFile(value) {
+    if (!isRecord(value) || typeof value.kind !== "string" || typeof value.value !== "string") {
+        throw new Error("source.json must contain kind and value strings");
+    }
+    if (value.kind !== "github" && value.kind !== "git" && value.kind !== "local") {
+        throw new Error(`unsupported marketplace source kind: ${value.kind}`);
+    }
+    return Object.freeze({
+        kind: value.kind,
+        value: value.value,
+        ...(typeof value.ref === "string" ? { ref: value.ref } : {}),
+    });
+}
+function isGithubShorthand(value) {
+    return /^[^/\s]+\/[^/\s]+$/u.test(value) && !value.startsWith(".");
+}
+function isGitUrl(value) {
+    return /^(?:https?|ssh|git):\/\//u.test(value) || /^[^@/\s]+@[^:/\s]+:.+$/u.test(value);
+}
+async function normalizeMarketplaceSource(value, ref) {
+    const input = value.trim();
+    if (input.length === 0)
+        throw new Error("marketplace source is required");
+    if (isGitUrl(input))
+        return Object.freeze({ kind: "git", value: input, ...(ref === undefined ? {} : { ref }) });
+    const local = input.startsWith("file://") ? new URL(input) : undefined;
+    const localPath = local === undefined ? resolve(input) : resolve(decodeURIComponent(local.pathname));
+    try {
+        const stat = await lstat(localPath);
+        if (!stat.isDirectory() && !stat.isSymbolicLink())
+            throw new Error(`local marketplace source is not a directory: ${input}`);
+        const actual = await realpath(localPath);
+        return Object.freeze({ kind: "local", value: actual, ...(ref === undefined ? {} : { ref }) });
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    if (isGithubShorthand(input))
+        return Object.freeze({ kind: "github", value: input, ...(ref === undefined ? {} : { ref }) });
+    throw new Error(`marketplace source is not a Git URL, GitHub shorthand, or existing local repository: ${input}`);
+}
+async function readSource(root) {
+    return parseSourceFile(JSON.parse(await readFile(join(root, "source.json"), "utf8")));
+}
+async function runGitClone(source, destination, options = {}) {
+    throwIfAborted(options.signal);
+    const gitSource = source.kind === "github" ? `https://github.com/${source.value}.git` : source.value;
+    const args = ["clone", "--quiet", "--no-tags"];
+    if (source.ref !== undefined)
+        args.push("--branch", source.ref);
+    args.push(gitSource, destination);
+    await execFileAsync("git", args, {
+        maxBuffer: 4 * 1024 * 1024,
+        timeout: options.timeoutMs ?? DEFAULT_REFRESH_TIMEOUT_MS,
+        ...(options.signal === undefined ? {} : { signal: options.signal }),
+    });
+    throwIfAborted(options.signal);
+}
+async function makeOwnerWritable(root) {
+    const stat = await lstat(root);
+    if (stat.isSymbolicLink())
+        return;
+    if (!stat.isDirectory()) {
+        await chmod(root, stat.mode | 0o200);
+        return;
+    }
+    await chmod(root, stat.mode | 0o700);
+    for (const entry of await readdir(root))
+        await makeOwnerWritable(join(root, entry));
+}
+async function removeOwnedTree(root) {
+    try {
+        await makeOwnerWritable(root);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    await rm(root, { recursive: true, force: true });
+}
+async function materializeMarketplace(source, destination, options = {}) {
+    throwIfAborted(options.signal);
+    if (source.kind === "local") {
+        await cp(source.value, destination, { recursive: true, dereference: false, force: true });
+    }
+    else {
+        await runGitClone(source, destination, options);
+    }
+    throwIfAborted(options.signal);
+    await makeOwnerWritable(destination);
+}
+async function ensureRoots(paths) {
+    await mkdir(paths.marketplaces, { recursive: true });
+    await mkdir(paths.plugins, { recursive: true });
+    await mkdir(paths.data, { recursive: true });
+}
+async function validateCatalogPaths(catalog, checkout) {
+    for (const plugin of catalog.plugins) {
+        if (plugin.source.kind === "local") {
+            // Lexical validation stops `..`; realpath validation stops a catalog path
+            // that crosses a symlink in the checkout (the actual escape threat).
+            const path = resolveContainedPath(checkout, plugin.source.path, `${plugin.name} source`);
+            try {
+                const actual = await realpath(path);
+                if (!path.startsWith(`${resolve(checkout)}/`) && path !== resolve(checkout))
+                    throw new Error("source escapes checkout");
+                if (!actual.startsWith(`${resolve(checkout)}/`) && actual !== resolve(checkout)) {
+                    throw new Error(`${plugin.name} source escapes marketplace checkout through a symlink`);
+                }
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+        }
+    }
+}
+async function catalogForCheckout(checkout) {
+    const result = await readMarketplaceCatalog(checkout);
+    await validateCatalogPaths(result.catalog, checkout);
+    return result;
+}
+function marketplaceInfo(paths, name, source) {
+    const safe = assertSafeName(name, "marketplace name");
+    return Object.freeze({
+        name: safe,
+        source,
+        root: join(paths.marketplaces, safe),
+        checkout: join(paths.marketplaces, safe, "checkout"),
+    });
+}
+async function replaceDirectory(staged, target) {
+    await removeOwnedTree(target);
+    await rename(staged, target);
+}
+async function readReceipt(root) {
+    try {
+        const value = JSON.parse(await readFile(join(root, ".pi-plugin.json"), "utf8"));
+        return isRecord(value) ? Object.freeze({ ...value }) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function hasRegularMarker(root, marker) {
+    try {
+        const stat = await lstat(join(root, marker));
+        if (stat.isSymbolicLink())
+            throw new Error(`${marker} must not be a symlink: ${root}`);
+        return stat.isFile();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function setRegularMarker(root, marker, enabled) {
+    const path = join(root, marker);
+    if (enabled) {
+        try {
+            const stat = await lstat(path);
+            if (stat.isSymbolicLink())
+                throw new Error(`${marker} must not be a symlink: ${root}`);
+            if (!stat.isFile())
+                throw new Error(`${marker} must be a regular file: ${root}`);
+            return;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            await writeFile(path, "", { encoding: "utf8", flag: "wx" });
+        }
+        return;
+    }
+    try {
+        const stat = await lstat(path);
+        if (stat.isSymbolicLink())
+            throw new Error(`${marker} must not be a symlink: ${root}`);
+        if (!stat.isFile())
+            throw new Error(`${marker} must be a regular file: ${root}`);
+        await rm(path, { force: true });
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+async function installedInfo(paths, marketplace, plugin) {
+    const market = assertSafeName(marketplace, "marketplace name");
+    const name = assertSafeName(plugin, "plugin name");
+    const root = join(paths.plugins, market, name);
+    const stat = await lstat(root);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new Error(`installed plugin is not a directory: ${name}@${market}`);
+    const data = join(paths.data, market, name);
+    const disabled = await hasRegularMarker(root, ".disabled");
+    const autoUpdate = await hasRegularMarker(root, ".auto-update");
+    const receipt = await readReceipt(root);
+    return Object.freeze({ marketplace: market, name, root, data, enabled: !disabled, autoUpdate, ...(receipt === undefined ? {} : { receipt }) });
+}
+function pluginPath(paths, marketplace, plugin) {
+    return join(paths.plugins, assertSafeName(marketplace, "marketplace name"), assertSafeName(plugin, "plugin name"));
+}
+async function findCatalogPlugin(paths, marketplace, plugin) {
+    const name = assertSafeName(marketplace, "marketplace name");
+    const pluginName = assertSafeName(plugin, "plugin name");
+    const info = marketplaceInfo(paths, name, await readSource(join(paths.marketplaces, name)));
+    const result = await catalogForCheckout(info.checkout);
+    const entry = result.catalog.plugins.find((candidate) => candidate.name === pluginName);
+    if (entry === undefined)
+        throw new Error(`plugin is not in marketplace catalog: ${pluginName}@${name}`);
+    return { info, catalog: result.catalog, entry };
+}
+async function resolvePluginSource(paths, info, entry) {
+    if (entry.source.kind === "local") {
+        const root = await resolveContainedExistingPath(info.checkout, entry.source.path, `${entry.name} source`);
+        const stat = await lstat(root);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw new Error(`plugin source is not a directory: ${entry.name}`);
+        return { root, cleanup: async () => undefined };
+    }
+    await mkdir(paths.plugins, { recursive: true });
+    const sourceStage = await mkdtemp(join(paths.plugins, ".plugin-source-"));
+    try {
+        const source = { kind: "git", value: entry.source.url, ...(entry.source.ref === undefined ? {} : { ref: entry.source.ref }) };
+        await materializeMarketplace(source, sourceStage);
+        const root = entry.source.path === undefined
+            ? sourceStage
+            : await resolveContainedExistingPath(sourceStage, entry.source.path, `${entry.name} Git source`);
+        const stat = await lstat(root);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw new Error(`Git plugin source is not a directory: ${entry.name}`);
+        return { root, cleanup: async () => rm(sourceStage, { recursive: true, force: true }) };
+    }
+    catch (error) {
+        await rm(sourceStage, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function copyPluginBundle(paths, source, marketplace, plugin, entry, preserveDisabled, preserveAutoUpdate) {
+    await assertNoSymlinks(source);
+    const market = assertSafeName(marketplace, "marketplace name");
+    const name = assertSafeName(plugin, "plugin name");
+    const parent = join(paths.plugins, market);
+    await mkdir(parent, { recursive: true });
+    const stage = await mkdtemp(join(parent, `.${name}-`));
+    try {
+        for (const item of await readdir(source, { withFileTypes: true })) {
+            // These files are host authority, not bundle content. In particular, a
+            // catalog must not be able to grant automatic executable updates by
+            // shipping its own marker.
+            if (item.name === ".git" || item.name === ".pi-plugin.json" || item.name === ".disabled" || item.name === ".auto-update")
+                continue;
+            await cp(join(source, item.name), join(stage, item.name), { recursive: true, dereference: false, force: true });
+        }
+        await makeOwnerWritable(stage);
+        await writeFile(join(stage, ".pi-plugin.json"), `${JSON.stringify({
+            marketplace: market,
+            plugin: name,
+            description: entry.description,
+            version: entry.version,
+            source: entry.source,
+        }, null, 2)}\n`, "utf8");
+        if (preserveDisabled)
+            await writeFile(join(stage, ".disabled"), "", "utf8");
+        if (preserveAutoUpdate)
+            await writeFile(join(stage, ".auto-update"), "", "utf8");
+        await assertNoSymlinks(stage);
+        const target = pluginPath(paths, market, name);
+        await removeOwnedTree(target);
+        await rename(stage, target);
+        await mkdir(join(paths.data, market, name), { recursive: true });
+        return installedInfo(paths, market, name);
+    }
+    catch (error) {
+        await rm(stage, { recursive: true, force: true });
+        throw error;
+    }
+}
+export function createPluginHost(agentDir) {
+    const paths = createPluginHostPaths(agentDir);
+    async function addMarketplace(sourceValue, options = {}) {
+        await ensureRoots(paths);
+        const source = await normalizeMarketplaceSource(sourceValue, options.ref);
+        const stageRoot = await mkdtemp(join(paths.marketplaces, ".marketplace-"));
+        try {
+            const checkout = join(stageRoot, "checkout");
+            // Adding a user-selected source may need to clone substantially more
+            // history than a routine refresh. Node's zero timeout leaves this
+            // foreground acquisition user-controlled instead of applying the
+            // manager/startup refresh budget.
+            await materializeMarketplace(source, checkout, { timeoutMs: 0 });
+            const result = await catalogForCheckout(checkout);
+            const info = marketplaceInfo(paths, result.catalog.name, source);
+            await writeFile(join(stageRoot, "source.json"), `${JSON.stringify(sourceFile(source), null, 2)}\n`, "utf8");
+            await replaceDirectory(stageRoot, info.root);
+            return info;
+        }
+        catch (error) {
+            await rm(stageRoot, { recursive: true, force: true });
+            throw error;
+        }
+    }
+    async function listMarketplaces() {
+        await ensureRoots(paths);
+        const values = [];
+        for (const entry of await readdir(paths.marketplaces, { withFileTypes: true })) {
+            if (entry.name.startsWith("."))
+                continue;
+            if (!entry.isDirectory() || entry.isSymbolicLink())
+                continue;
+            try {
+                const source = await readSource(join(paths.marketplaces, entry.name));
+                values.push(marketplaceInfo(paths, entry.name, source));
+            }
+            catch {
+                // A broken marketplace is omitted from the concise list; browse/refresh
+                // reports its concrete source or catalog error when selected.
+            }
+        }
+        return Object.freeze(values.sort((a, b) => a.name.localeCompare(b.name)));
+    }
+    async function refreshMarketplace(nameValue, options = {}) {
+        const name = assertSafeName(nameValue, "marketplace name");
+        await ensureRoots(paths);
+        throwIfAborted(options.signal);
+        const root = join(paths.marketplaces, name);
+        const source = await readSource(root);
+        const stageRoot = await mkdtemp(join(paths.marketplaces, ".marketplace-refresh-"));
+        try {
+            const checkout = join(stageRoot, "checkout");
+            await materializeMarketplace(source, checkout, options);
+            const result = await catalogForCheckout(checkout);
+            if (result.catalog.name !== name)
+                throw new Error(`refreshed marketplace declares ${result.catalog.name}, expected ${name}`);
+            throwIfAborted(options.signal);
+            await removeOwnedTree(join(root, "checkout"));
+            await rename(checkout, join(root, "checkout"));
+            return marketplaceInfo(paths, name, source);
+        }
+        finally {
+            await rm(stageRoot, { recursive: true, force: true });
+        }
+    }
+    async function refreshMarketplaces(names, options = {}) {
+        const uniqueNames = [...new Set(names)].map((name) => assertSafeName(name, "marketplace name"));
+        const concurrency = Math.max(1, Math.min(options.concurrency ?? 2, uniqueNames.length || 1));
+        const results = [];
+        let next = 0;
+        const worker = async () => {
+            while (true) {
+                const index = next++;
+                const name = uniqueNames[index];
+                if (name === undefined)
+                    return;
+                let result;
+                if (options.signal?.aborted) {
+                    result = Object.freeze({ marketplace: name, ok: false, diagnostics: Object.freeze([]), error: "operation cancelled" });
+                }
+                else {
+                    try {
+                        const info = await refreshMarketplace(name, options);
+                        const catalog = await catalogForCheckout(info.checkout);
+                        result = Object.freeze({
+                            marketplace: name,
+                            ok: true,
+                            info,
+                            catalog: Object.freeze({ ...catalog.catalog, diagnostics: catalog.diagnostics }),
+                            diagnostics: catalog.diagnostics,
+                        });
+                    }
+                    catch (error) {
+                        result = Object.freeze({ marketplace: name, ok: false, diagnostics: Object.freeze([]), error: errorMessage(error) });
+                    }
+                }
+                results[index] = result;
+                try {
+                    options.onResult?.(result);
+                }
+                catch { /* UI observers cannot change filesystem truth. */ }
+            }
+        };
+        await Promise.all(Array.from({ length: concurrency }, () => worker()));
+        return Object.freeze(results.filter((result) => result !== undefined));
+    }
+    async function removeMarketplace(nameValue) {
+        const name = assertSafeName(nameValue, "marketplace name");
+        const root = join(paths.marketplaces, name);
+        await removeOwnedTree(root);
+    }
+    async function browseMarketplace(nameValue) {
+        const name = assertSafeName(nameValue, "marketplace name");
+        const result = await catalogForCheckout(join(paths.marketplaces, name, "checkout"));
+        return Object.freeze({ ...result.catalog, diagnostics: result.diagnostics });
+    }
+    async function listInstalled() {
+        await ensureRoots(paths);
+        const result = [];
+        for (const market of await readdir(paths.plugins, { withFileTypes: true })) {
+            if (market.name.startsWith(".") || !market.isDirectory() || market.isSymbolicLink())
+                continue;
+            for (const plugin of await readdir(join(paths.plugins, market.name), { withFileTypes: true })) {
+                if (plugin.name.startsWith(".") || !plugin.isDirectory() || plugin.isSymbolicLink())
+                    continue;
+                try {
+                    result.push(await installedInfo(paths, market.name, plugin.name));
+                }
+                catch { /* local listing remains useful */ }
+            }
+        }
+        return Object.freeze(result.sort((a, b) => `${a.marketplace}/${a.name}`.localeCompare(`${b.marketplace}/${b.name}`)));
+    }
+    async function mutatePlugin(marketplace, plugin, update, options = {}) {
+        await ensureRoots(paths);
+        let currentInfo;
+        try {
+            currentInfo = await installedInfo(paths, marketplace, plugin);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (update && currentInfo === undefined) {
+            throw new Error(`plugin is not installed: ${plugin}@${marketplace}`);
+        }
+        const preserveDisabled = currentInfo?.enabled === false;
+        const preserveAutoUpdate = currentInfo?.autoUpdate === true;
+        if (update && options.refresh !== false) {
+            await refreshMarketplace(marketplace, options);
+        }
+        const { info, entry } = await findCatalogPlugin(paths, marketplace, plugin);
+        const source = await resolvePluginSource(paths, info, entry);
+        try {
+            return await copyPluginBundle(paths, source.root, info.name, entry.name, entry, preserveDisabled, preserveAutoUpdate);
+        }
+        finally {
+            await source.cleanup();
+        }
+    }
+    async function enablePlugin(marketplace, plugin) {
+        const info = await installedInfo(paths, marketplace, plugin);
+        const marker = join(info.root, ".disabled");
+        try {
+            const stat = await lstat(marker);
+            if (stat.isSymbolicLink())
+                throw new Error(`disabled marker is a symlink: ${marker}`);
+            await rm(marker, { force: true });
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        return installedInfo(paths, marketplace, plugin);
+    }
+    async function disablePlugin(marketplace, plugin) {
+        const info = await installedInfo(paths, marketplace, plugin);
+        const marker = join(info.root, ".disabled");
+        try {
+            const stat = await lstat(marker);
+            if (stat.isSymbolicLink())
+                throw new Error(`disabled marker is a symlink: ${marker}`);
+            if (!stat.isFile())
+                throw new Error(`disabled marker is not a file: ${marker}`);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        await writeFile(marker, "", { encoding: "utf8", flag: "w" });
+        return installedInfo(paths, marketplace, plugin);
+    }
+    async function setAutoUpdate(marketplace, plugin, enabled) {
+        const info = await installedInfo(paths, marketplace, plugin);
+        await setRegularMarker(info.root, ".auto-update", enabled);
+        return installedInfo(paths, marketplace, plugin);
+    }
+    async function getCheckOnOpen() {
+        await ensureRoots(paths);
+        return hasRegularMarker(paths.hostRoot, CHECK_ON_OPEN_MARKER);
+    }
+    async function setCheckOnOpen(enabled) {
+        await ensureRoots(paths);
+        await setRegularMarker(paths.hostRoot, CHECK_ON_OPEN_MARKER, enabled);
+    }
+    async function removePlugin(marketplace, plugin, deleteData = false) {
+        const root = pluginPath(paths, marketplace, plugin);
+        await removeOwnedTree(root);
+        if (deleteData) {
+            const data = join(paths.data, assertSafeName(marketplace, "marketplace name"), assertSafeName(plugin, "plugin name"));
+            await removeOwnedTree(data);
+        }
+    }
+    async function scanRuntime() {
+        await ensureRoots(paths);
+        return scanInstalledPlugins(paths);
+    }
+    async function runPluginBatch(action, identities, options = {}) {
+        const refreshRequired = options.refresh ?? (action === "install" || action === "update");
+        const refreshes = refreshRequired
+            ? await refreshMarketplaces(identities.map((identity) => identity.marketplace), options)
+            : [];
+        const refreshByMarketplace = new Map(refreshes.map((result) => [result.marketplace, result]));
+        const results = [];
+        let cancelled = false;
+        for (const identity of identities) {
+            if (options.signal?.aborted) {
+                cancelled = true;
+                break;
+            }
+            try {
+                options.onBeforeItem?.(identity);
+            }
+            catch { /* observers cannot change filesystem truth */ }
+            if (options.signal?.aborted) {
+                cancelled = true;
+                break;
+            }
+            let result;
+            try {
+                const marketplace = assertSafeName(identity.marketplace, "marketplace name");
+                const plugin = assertSafeName(identity.plugin, "plugin name");
+                const refresh = refreshByMarketplace.get(marketplace);
+                if (refreshRequired && refresh?.ok !== true) {
+                    throw new Error(`marketplace refresh failed: ${refresh?.error ?? "unknown error"}`);
+                }
+                let info;
+                if (action === "install")
+                    info = await mutatePlugin(marketplace, plugin, false);
+                if (action === "update") {
+                    const updateOptions = {
+                        refresh: false,
+                        ...(options.signal === undefined ? {} : { signal: options.signal }),
+                        ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+                    };
+                    info = await mutatePlugin(marketplace, plugin, true, updateOptions);
+                }
+                if (action === "enable")
+                    info = await enablePlugin(marketplace, plugin);
+                if (action === "disable")
+                    info = await disablePlugin(marketplace, plugin);
+                if (action === "remove")
+                    await removePlugin(marketplace, plugin, options.deleteData === true);
+                result = Object.freeze({ action, identity: Object.freeze({ marketplace, plugin }), ok: true, ...(info === undefined ? {} : { info }) });
+            }
+            catch (error) {
+                result = Object.freeze({
+                    action,
+                    identity: Object.freeze({ ...identity }),
+                    ok: false,
+                    error: errorMessage(error),
+                });
+            }
+            // The scan is deliberately after each settled item, including failures:
+            // the next item and the result page both observe current filesystem truth.
+            await scanRuntime().catch(() => undefined);
+            results.push(result);
+            try {
+                options.onItem?.(result);
+            }
+            catch { /* a view observer cannot change the batch result */ }
+        }
+        return Object.freeze({ results: Object.freeze(results), cancelled });
+    }
+    async function updateMarkedPlugins(options = {}) {
+        const marked = (await listInstalled()).filter((plugin) => plugin.autoUpdate);
+        const refreshes = await refreshMarketplaces([...new Set(marked.map((plugin) => plugin.marketplace))], options);
+        const refreshByMarketplace = new Map(refreshes.map((result) => [result.marketplace, result]));
+        const results = [];
+        const force = options.force === true;
+        for (const installed of marked) {
+            if (options.signal?.aborted)
+                break;
+            const identity = Object.freeze({ marketplace: installed.marketplace, plugin: installed.name });
+            const refresh = refreshByMarketplace.get(installed.marketplace);
+            let result;
+            try {
+                if (refresh?.ok !== true || refresh.catalog === undefined) {
+                    throw new Error(`marketplace refresh failed: ${refresh?.error ?? "unknown error"}`);
+                }
+                const entry = refresh.catalog.plugins.find((candidate) => candidate.name === installed.name);
+                if (entry === undefined)
+                    throw new Error(`plugin is not in marketplace catalog: ${installed.name}@${installed.marketplace}`);
+                const installedVersion = typeof installed.receipt?.version === "string" ? installed.receipt.version : undefined;
+                if (!force && entry.version === undefined) {
+                    result = Object.freeze({ identity, ok: true, updated: false, skipped: true, reason: "catalog version is not declared" });
+                }
+                else if (!force && installedVersion === entry.version) {
+                    result = Object.freeze({ identity, ok: true, updated: false, skipped: true, reason: "already at declared catalog version" });
+                }
+                else {
+                    const updateOptions = {
+                        refresh: false,
+                        ...(options.signal === undefined ? {} : { signal: options.signal }),
+                        ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+                    };
+                    const info = await mutatePlugin(installed.marketplace, installed.name, true, updateOptions);
+                    result = Object.freeze({ identity, ok: true, updated: true, skipped: false, info });
+                }
+            }
+            catch (error) {
+                result = Object.freeze({ identity, ok: false, updated: false, skipped: false, error: errorMessage(error) });
+            }
+            results.push(result);
+            try {
+                options.onItem?.(result);
+            }
+            catch { /* a view observer cannot change the update outcome */ }
+        }
+        return Object.freeze({ refreshes, results: Object.freeze(results) });
+    }
+    return Object.freeze({
+        paths,
+        addMarketplace,
+        listMarketplaces,
+        refreshMarketplace,
+        refreshMarketplaces,
+        removeMarketplace,
+        browseMarketplace,
+        listInstalled,
+        installPlugin: (marketplace, plugin) => mutatePlugin(marketplace, plugin, false),
+        updatePlugin: (marketplace, plugin, options) => mutatePlugin(marketplace, plugin, true, options),
+        enablePlugin,
+        disablePlugin,
+        removePlugin,
+        setAutoUpdate,
+        runPluginBatch,
+        updateMarkedPlugins,
+        getCheckOnOpen,
+        setCheckOnOpen,
+        scanRuntime,
+        buildMcpConfig: async (snapshot) => buildMcpConfig(snapshot ?? await scanRuntime()),
+    });
+}
+export { assertSafeRelativePath, assertSafeName, isPathContained, resolveContainedPath } from "./paths.js";
+export { mergeMarketplaceCatalogs, readMarketplaceCatalog } from "./catalog.js";
+//# sourceMappingURL=host.js.map