@nklisch/pi-enhanced 0.2.4 → 0.2.5

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## v0.2.5
+
+### Changed
+
+- Rebundle `@nklisch/pi-plugins` 0.6.0 with the keyboard-first plugin manager, explicit multi-select batches, bounded marketplace checks, and marker-authorized startup updates.
+
 ## v0.2.4
 
 ### Changed

package/node_modules/@nklisch/pi-plugins/README.md

@@ -1,9 +1,9 @@
 # Pi Plugins
 
-`@nklisch/pi-plugins` is a small filesystem-first marketplace and plugin host
-for [Pi](https://github.com/badlogic/pi-mono). It installs compatible Claude
-Code and Codex plugin bundles, discovers their skills, runs their simple
-command hooks, and supplies their MCP declarations to Pi.
+`@nklisch/pi-plugins` is a filesystem-first marketplace and plugin manager for
+[Pi](https://github.com/badlogic/pi-mono). It installs compatible Claude Code
+and Codex plugin bundles, discovers their skills, runs their simple command
+hooks, and supplies their MCP declarations to Pi.
 
 ## Install
 
@@ -11,23 +11,53 @@ command hooks, and supplies their MCP declarations to Pi.
 pi install npm:@nklisch/pi-plugins
 ```
 
-Then use the concise command surface:
+Run `/plugins` with no arguments to open the keyboard-first manager. It provides
+Installed, Discover, Marketplaces, and Issues views; search and plugin details;
+and explicit multi-select batches. `Ctrl+F` focuses search, Space selects rows,
+`a` selects all filtered rows, Enter opens details, `r` checks marketplaces,
+and the footer shows the contextual action keys.
+
+The manager opens from local files. Marketplace checks run asynchronously with
+bounded concurrency and timeouts, remain cancellable, and never hide the
+installed copies when a source is offline. Runtime changes are applied
+sequentially and trigger one Pi reload when the manager closes.
+
+The direct command surface remains available for scripts and focused actions:
 
 ```text
+/plugins list
 /plugins marketplace add nklisch/skills
 /plugins marketplace list
+/plugins marketplace refresh nklisch-skills
 /plugins browse nklisch-skills
 /plugins install workbench@nklisch-skills --yes
 /plugins update workbench@nklisch-skills --yes
 /plugins enable workbench@nklisch-skills --yes
 /plugins disable workbench@nklisch-skills
 /plugins remove workbench@nklisch-skills --yes
+/plugins update-marked
 ```
 
-The command uses Pi's ordinary select, input, and confirmation dialogs when
-invoked without arguments in a UI session. Installing, updating, enabling, or
-removing executable plugin content requires confirmation; pass `--yes` for
-headless use. Pi reloads after a runtime-affecting mutation.
+Direct installation, update, enablement, or removal of executable plugin
+content requires confirmation; pass `--yes` for headless use. Each direct
+runtime mutation reloads Pi after it succeeds.
+
+## Automatic updates
+
+An installed plugin can be marked for automatic updates from its detail view.
+The `.auto-update` marker is both the selection and the standing authorization
+to replace that plugin's executable content.
+
+Before plugin activation, Pi refreshes each affected marketplace once with a
+bounded timeout. A marked plugin updates only when the catalog declares a
+version different from its installed receipt. Missing versions, offline
+sources, and item failures leave the installed copy unchanged and do not block
+startup.
+
+`/plugins update-marked` is the explicit escape path. It refreshes affected
+marketplaces, force-updates every marked plugin—including unversioned entries—
+reports mixed results, and reloads once if any update succeeds. There is no
+scheduler or periodic background updater.
 
 ## Filesystem truth
 
@@ -35,18 +65,21 @@ The host stores no database or lifecycle ledger. Its durable layout is:
 
 ```text
 <agent-dir>/plugin-host/
+├── .check-on-open?
 ├── marketplaces/<name>/{source.json,checkout}
-├── plugins/<marketplace>/<plugin>/{.pi-plugin.json,.disabled?,...bundle}
+├── plugins/<marketplace>/<plugin>/{.pi-plugin.json,.disabled?,.auto-update?,...bundle}
 └── data/<marketplace>/<plugin>/
 ```
 
 A plugin directory is installed; `.disabled` means disabled. The receipt is
-descriptive only. Refresh and install/update stage a sibling directory and
-rename it into place. Persistent plugin data is not replaced by an update and
-is retained by removal unless `--delete-data` is supplied.
-
-Marketplaces accept GitHub shorthand, Git URLs, and local repository paths.
-The host reads `.agents/plugins/marketplace.json` and
+descriptive only. `.check-on-open` stores the manager's optional refresh
+preference; cursor, selection, progress, results, and errors are never stored.
+Refresh and install/update stage a sibling directory and rename it into place.
+Persistent plugin data is not replaced by an update and is retained by removal
+unless `--delete-data` is supplied.
+
+Marketplaces accept GitHub shorthand, Git URLs, and local repository paths. The
+host reads `.agents/plugins/marketplace.json` and
 `.claude-plugin/marketplace.json`, merges valid siblings, and supports local
 plugin declarations such as `{ "source": "local", "path": "./plugins/demo" }`
 and ordinary relative string paths. Catalog paths must remain within the
@@ -71,12 +104,9 @@ injected into the next Pi system prompt.
 
 MCP declarations are recursively expanded for the plugin root, persistent data
 root, and project root, then passed as an in-memory `{ mcpServers }` overlay to
-`@nklisch/pi-mcp-adapter`. The adapter merges that overlay with the user's normal
-file-discovered MCP configuration. Duplicate plugin server names are qualified
-by plugin identity.
-There is no background network activity. Marketplace refresh runs only when
-requested; updating a plugin first refreshes its marketplace, then replaces the
-installed copy.
+`@nklisch/pi-mcp-adapter`. The adapter merges that overlay with the user's
+normal file-discovered MCP configuration. Duplicate plugin server names are
+qualified by plugin identity.
 
 ## Development
 

package/node_modules/@nklisch/pi-plugins/dist/host.d.ts

@@ -1,4 +1,5 @@
 import type { PluginHost } from "./types.js";
+export declare const DEFAULT_REFRESH_TIMEOUT_MS = 10000;
 export declare function createPluginHost(agentDir: string): PluginHost;
 export { assertSafeRelativePath, assertSafeName, isPathContained, resolveContainedPath } from "./paths.js";
 export { mergeMarketplaceCatalogs, readMarketplaceCatalog } from "./catalog.js";

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

@@ -7,6 +7,18 @@ import { assertNoSymlinks, assertSafeName, assertSafeRelativePath, createPluginH
 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);
 }
@@ -62,13 +74,19 @@ async function normalizeMarketplaceSource(value, ref) {
 async function readSource(root) {
     return parseSourceFile(JSON.parse(await readFile(join(root, "source.json"), "utf8")));
 }
-async function runGitClone(source, destination) {
+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 });
+    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);
@@ -92,13 +110,15 @@ async function removeOwnedTree(root) {
     }
     await rm(root, { recursive: true, force: true });
 }
-async function materializeMarketplace(source, destination) {
+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);
+        await runGitClone(source, destination, options);
     }
+    throwIfAborted(options.signal);
     await makeOwnerWritable(destination);
 }
 async function ensureRoots(paths) {
@@ -154,6 +174,50 @@ async function readReceipt(root) {
         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");
@@ -162,9 +226,10 @@ async function installedInfo(paths, marketplace, plugin) {
     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 lstat(join(root, ".disabled")).then((item) => item.isFile()).catch(() => false);
+    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, ...(receipt === undefined ? {} : { receipt }) });
+    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"));
@@ -205,7 +270,7 @@ async function resolvePluginSource(paths, info, entry) {
         throw error;
     }
 }
-async function copyPluginBundle(paths, source, marketplace, plugin, entry, preserveDisabled) {
+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");
@@ -214,7 +279,10 @@ async function copyPluginBundle(paths, source, marketplace, plugin, entry, prese
     const stage = await mkdtemp(join(parent, `.${name}-`));
     try {
         for (const item of await readdir(source, { withFileTypes: true })) {
-            if (item.name === ".git")
+            // 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 });
         }
@@ -228,6 +296,8 @@ async function copyPluginBundle(paths, source, marketplace, plugin, entry, prese
         }, 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);
@@ -248,7 +318,11 @@ export function createPluginHost(agentDir) {
         const stageRoot = await mkdtemp(join(paths.marketplaces, ".marketplace-"));
         try {
             const checkout = join(stageRoot, "checkout");
-            await materializeMarketplace(source, 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");
@@ -279,18 +353,20 @@ export function createPluginHost(agentDir) {
         }
         return Object.freeze(values.sort((a, b) => a.name.localeCompare(b.name)));
     }
-    async function refreshMarketplace(nameValue) {
+    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);
+            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);
@@ -299,6 +375,47 @@ export function createPluginHost(agentDir) {
             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);
@@ -326,7 +443,7 @@ export function createPluginHost(agentDir) {
         }
         return Object.freeze(result.sort((a, b) => `${a.marketplace}/${a.name}`.localeCompare(`${b.marketplace}/${b.name}`)));
     }
-    async function mutatePlugin(marketplace, plugin, update) {
+    async function mutatePlugin(marketplace, plugin, update, options = {}) {
         await ensureRoots(paths);
         let currentInfo;
         try {
@@ -340,13 +457,14 @@ export function createPluginHost(agentDir) {
             throw new Error(`plugin is not installed: ${plugin}@${marketplace}`);
         }
         const preserveDisabled = currentInfo?.enabled === false;
-        if (update) {
-            await refreshMarketplace(marketplace);
+        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);
+            return await copyPluginBundle(paths, source.root, info.name, entry.name, entry, preserveDisabled, preserveAutoUpdate);
         }
         finally {
             await source.cleanup();
@@ -370,9 +488,33 @@ export function createPluginHost(agentDir) {
     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);
@@ -385,19 +527,139 @@ export function createPluginHost(agentDir) {
         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) => mutatePlugin(marketplace, plugin, true),
+        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()),
     });