@falkenslab/agent-kit 0.19.0 → 0.21.0

package/dist/core/marketplaces.js

@@ -0,0 +1,242 @@
+import { execFile } from "node:child_process";
+import { cp, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { addExtension, isGitSource } from "./externalExtensions.js";
+import { fetchArchivePlugin, fetchNpmPlugin } from "./pluginDownloads.js";
+/**
+ * Marketplaces (ADR-025, #29): a repository of extensions is a Claude Code marketplace as it is,
+ * a folder or git repository with `.claude-plugin/marketplace.json` listing plugins and where
+ * each comes from. An agent knows the marketplaces added to it, kept in its extensions folder
+ * (`marketplaces.json`, and a copy of each in `.marketplaces/<name>/`), and installs from them
+ * by `<plugin>@<marketplace>` into either scope, through `addExtension()`: the same copy, hash and
+ * lock as any extension. Its official marketplace is known without asking; any other is added
+ * only by hand, after a warning (the command asks to type its name).
+ */
+const exec = promisify(execFile);
+const REGISTRY = "marketplaces.json";
+const COPIES = ".marketplaces";
+const NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+/** Reads and checks a marketplace's `.claude-plugin/marketplace.json`. */
+export async function readMarketplaceManifest(root) {
+    const file = path.join(root, ".claude-plugin", "marketplace.json");
+    const raw = JSON.parse(await readFile(file, "utf8").catch(() => {
+        throw new Error(`${root} isn't a marketplace: it has no .claude-plugin/marketplace.json.`);
+    }));
+    const name = raw.name;
+    if (typeof name !== "string" || !NAME.test(name) || name.includes(".."))
+        throw new Error(`${file}: "name" must be letters, digits, ".", "_" or "-".`);
+    const owner = raw.owner;
+    if (!owner || typeof owner.name !== "string")
+        throw new Error(`${file}: "owner" needs a "name".`);
+    if (!Array.isArray(raw.plugins))
+        throw new Error(`${file}: "plugins" must be a list.`);
+    const metadata = (raw.metadata ?? {});
+    const plugins = raw.plugins.map((plugin, index) => {
+        if (typeof plugin?.name !== "string" || !NAME.test(plugin.name))
+            throw new Error(`${file}: plugin ${index + 1} has no valid "name".`);
+        if (plugin.source === undefined)
+            throw new Error(`${file}: ${plugin.name} has no "source".`);
+        return plugin;
+    });
+    const description = raw.description ?? metadata.description;
+    return { name, owner, ...(description ? { description } : {}), ...(metadata.pluginRoot ? { pluginRoot: metadata.pluginRoot } : {}), plugins };
+}
+async function readRegistry(dir) {
+    try {
+        return JSON.parse(await readFile(path.join(dir, REGISTRY), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        throw error;
+    }
+}
+async function writeRegistry(dir, registry) {
+    await mkdir(dir, { recursive: true });
+    const sorted = Object.fromEntries(Object.keys(registry).sort().map((name) => [name, registry[name]]));
+    await writeFile(path.join(dir, REGISTRY), `${JSON.stringify(sorted, null, 2)}\n`, "utf8");
+}
+/** A git URL for a marketplace or plugin source: `owner/repo` is GitHub's. */
+function gitUrl(source) {
+    return /^[\w.-]+\/[\w.-]+$/.test(source) ? `https://github.com/${source}.git` : source.replace(/^github:/, "https://github.com/");
+}
+/** Whether a marketplace source is a git repository rather than a folder (`owner/repo` included, unless such a folder exists). */
+async function isGitMarketplace(source) {
+    const [location] = source.split("#");
+    if (isGitSource(location))
+        return true;
+    if (!/^[\w.-]+\/[\w.-]+$/.test(location))
+        return false;
+    return !(await stat(path.resolve(location)).then((found) => found.isDirectory(), () => false));
+}
+/** Takes a copy of a marketplace (a folder, or a git clone at its ref) into a temporary folder. */
+async function fetchMarketplace(source) {
+    const copy = await mkdtemp(path.join(os.tmpdir(), "agent-kit-marketplace-"));
+    try {
+        if (await isGitMarketplace(source)) {
+            const [location, ref] = source.split("#");
+            await exec("git", ["clone", "--depth", "1", ...(ref ? ["--branch", ref] : []), gitUrl(location), copy]);
+            const commit = (await exec("git", ["-C", copy, "rev-parse", "HEAD"])).stdout.trim();
+            await rm(path.join(copy, ".git"), { recursive: true, force: true });
+            return { copy, commit };
+        }
+        await cp(path.resolve(source), copy, { recursive: true, filter: (file) => path.basename(file) !== ".git" });
+        return { copy };
+    }
+    catch (error) {
+        await rm(copy, { recursive: true, force: true });
+        throw error;
+    }
+}
+/** Reads a marketplace from a folder, a git URL (`#ref`) or `owner/repo` without adding it: what to show before asking. */
+export async function inspectMarketplace(source) {
+    const { copy } = await fetchMarketplace((await isGitMarketplace(source)) ? source : path.resolve(source));
+    try {
+        return await readMarketplaceManifest(copy);
+    }
+    finally {
+        await rm(copy, { recursive: true, force: true });
+    }
+}
+/**
+ * Adds a marketplace to the agent (its extensions folder, `dir`) from a folder, a git URL
+ * (`#ref`) or `owner/repo`, taking a copy; one with the same name is replaced. Asking the person
+ * first is the caller's: the kit's command asks them to type its name, unless it's `official`.
+ */
+export async function addMarketplace(source, dir, options = {}) {
+    const location = (await isGitMarketplace(source)) ? source : path.resolve(source);
+    const { copy, commit } = await fetchMarketplace(location);
+    try {
+        const manifest = await readMarketplaceManifest(copy);
+        const registry = await readRegistry(dir);
+        const replaced = Boolean(registry[manifest.name]);
+        const target = path.join(dir, COPIES, manifest.name);
+        await rm(target, { recursive: true, force: true });
+        await mkdir(path.dirname(target), { recursive: true });
+        await cp(copy, target, { recursive: true });
+        registry[manifest.name] = { source: location, ...(commit ? { commit } : {}), official: Boolean(options.official || registry[manifest.name]?.official), updated: new Date().toISOString() };
+        await writeRegistry(dir, registry);
+        return { name: manifest.name, replaced, manifest, ...(commit ? { commit } : {}) };
+    }
+    finally {
+        await rm(copy, { recursive: true, force: true });
+    }
+}
+/** The marketplaces the agent knows, with their manifests when they can be read. */
+export async function listMarketplaces(dir) {
+    const registry = await readRegistry(dir);
+    return Promise.all(Object.entries(registry).map(async ([name, entry]) => {
+        const copy = path.join(dir, COPIES, name);
+        const manifest = await readMarketplaceManifest(copy).catch(() => undefined);
+        return { name, ...entry, dir: copy, ...(manifest ? { manifest } : {}) };
+    }));
+}
+/** Takes a fresh copy of a known marketplace from where it came from. */
+export async function updateMarketplace(dir, name) {
+    const known = (await readRegistry(dir))[name];
+    if (!known)
+        throw new Error(`No marketplace ${name}.`);
+    const result = await addMarketplace(known.source, dir, { official: known.official });
+    if (result.name !== name)
+        throw new Error(`${known.source} is now the marketplace ${result.name}, not ${name}.`);
+    return result.commit ? { commit: result.commit } : {};
+}
+/** Forgets a marketplace (its copy and its entry); the extensions installed from it stay. False when it wasn't known. */
+export async function removeMarketplace(dir, name) {
+    const registry = await readRegistry(dir);
+    if (!registry[name])
+        return false;
+    delete registry[name];
+    await rm(path.join(dir, COPIES, name), { recursive: true, force: true });
+    await writeRegistry(dir, registry);
+    return true;
+}
+/** A plugin found in the known marketplaces: `<name>@<marketplace>`, or a name only one of them offers. */
+export async function findPlugin(dir, spec) {
+    const [name, wanted] = spec.split("@");
+    const marketplaces = (await listMarketplaces(dir)).filter((marketplace) => !wanted || marketplace.name === wanted);
+    if (wanted && !marketplaces.length)
+        throw new Error(`No marketplace ${wanted}.`);
+    const found = marketplaces.flatMap((marketplace) => (marketplace.manifest?.plugins ?? []).filter((plugin) => plugin.name === name).map((plugin) => ({ marketplace, plugin })));
+    if (!found.length)
+        throw new Error(`No marketplace offers ${name}${wanted ? ` (${wanted} doesn't)` : ""}.`);
+    if (found.length > 1)
+        throw new Error(`${name} is in several marketplaces (${found.map(({ marketplace }) => marketplace.name).join(", ")}): say which, ${name}@<marketplace>.`);
+    return found[0];
+}
+/** Where a plugin's source points: a folder of the marketplace's copy, a git repository, an npm package or a zip. */
+export function resolvePluginSource(marketplace, plugin) {
+    const { source } = plugin;
+    if (typeof source === "string") {
+        // From the marketplace's root: `./plugins/x`, or a bare name under `pluginRoot`; never "..", as Claude Code.
+        if (source.split(/[\\/]/).includes(".."))
+            throw new Error(`${plugin.name}'s source leaves its marketplace: ${source}.`);
+        const relative = source.startsWith("./") || source === "." ? source : path.join(marketplace.manifest?.pluginRoot ?? ".", source);
+        const root = path.resolve(marketplace.dir);
+        const folder = path.resolve(root, relative);
+        if (folder !== root && !folder.startsWith(`${root}${path.sep}`))
+            throw new Error(`${plugin.name}'s source leaves its marketplace: ${source}.`);
+        return { source: folder };
+    }
+    // Its fields, as written: the union above only names the forms the kit knows.
+    const entry = source;
+    const ref = typeof entry.ref === "string" ? `#${entry.ref}` : "";
+    const sha = typeof entry.sha === "string" ? { sha: entry.sha } : {};
+    switch (source.source) {
+        case "github":
+            return { source: `https://github.com/${String(entry.repo)}.git${ref}`, ...sha };
+        case "url":
+            return { source: `${String(entry.url)}${ref}`, ...sha };
+        case "git-subdir":
+            return { source: `${gitUrl(String(entry.url))}${ref}`, subdir: String(entry.path), ...sha };
+        case "npm": {
+            // "package" may carry its version ("@scope/name@^2.0.0"); "version" wins.
+            const spec = String(entry.package);
+            const at = spec.lastIndexOf("@");
+            const [name, inline] = at > 0 ? [spec.slice(0, at), spec.slice(at + 1)] : [spec, undefined];
+            const version = typeof entry.version === "string" ? entry.version : inline;
+            return { npm: { name, ...(version ? { version } : {}), ...(typeof entry.registry === "string" ? { registry: entry.registry } : {}) } };
+        }
+        case "archive":
+            return { archive: { url: String(entry.url), ...(typeof entry.sha256 === "string" ? { sha256: entry.sha256 } : {}) } };
+        default:
+            // command runs a program of the marketplace's on this machine: never.
+            throw new Error(`${plugin.name} comes from a "${source.source}" source, which agent-kit doesn't install: only folders of the marketplace, github, url, git-subdir, npm and archive.`);
+    }
+}
+/**
+ * Installs `<plugin>@<marketplace>` (or a plugin only one known marketplace offers) into a scope,
+ * locked with where it came from. Its name in the agent is its `plugin.json`'s, as for any extension.
+ */
+export async function installFromMarketplace(dir, spec, scopeDir) {
+    const { marketplace, plugin } = await findPlugin(dir, spec);
+    const resolved = resolvePluginSource(marketplace, plugin);
+    const from = `${plugin.name}@${marketplace.name}`;
+    if ("npm" in resolved) {
+        const { name, version, registry } = resolved.npm;
+        const fetched = await fetchNpmPlugin(name, version, registry);
+        try {
+            return { ...(await addExtension(fetched.dir, scopeDir, { marketplace: from, origin: `npm:${name}@${fetched.version}` })), marketplace: marketplace.name };
+        }
+        finally {
+            await rm(fetched.dir, { recursive: true, force: true });
+        }
+    }
+    if ("archive" in resolved) {
+        const fetched = await fetchArchivePlugin(resolved.archive.url, resolved.archive.sha256);
+        try {
+            return { ...(await addExtension(fetched.root, scopeDir, { marketplace: from, origin: resolved.archive.url })), marketplace: marketplace.name };
+        }
+        finally {
+            await rm(fetched.dir, { recursive: true, force: true });
+        }
+    }
+    const result = await addExtension(resolved.source, scopeDir, {
+        ...(resolved.subdir ? { subdir: resolved.subdir } : {}),
+        ...(resolved.sha ? { sha: resolved.sha } : {}),
+        marketplace: from,
+    });
+    return { ...result, marketplace: marketplace.name };
+}

package/dist/core/messages/de.js

@@ -29,6 +29,7 @@ export const de = {
     extensionsNone: "(keine Erweiterungen)",
     extensionOff: (name, reason) => `${name} ist aus: ${reason}`,
     extensionsInstalled: "Installiert:",
+    extensionSwitched: (name, enabled) => `(${name} ${enabled ? "aktiviert" : "deaktiviert"}, in derselben Sitzung)`,
     extensionToggled: (name, enabled) => `(${name} ${enabled ? "aktiviert" : "deaktiviert"}: die Sitzung wird mit derselben Unterhaltung neu geöffnet)`,
     extensionNotInstalled: (name) => `(${name} ist nicht installiert: /extensions listet sie auf)`,
     extensionsUsage: "(Verwendung: /extensions, /extensions enable <Name>, /extensions disable <Name>)",

package/dist/core/messages/en.d.ts

@@ -38,6 +38,8 @@ export interface Messages {
     extensionsNone: string;
     extensionOff(name: string, reason: string): string;
     extensionsInstalled: string;
+    /** An installed extension turned off or on in the running session (#49). */
+    extensionSwitched(name: string, enabled: boolean): string;
     extensionToggled(name: string, enabled: boolean): string;
     extensionNotInstalled(name: string): string;
     extensionsUsage: string;

package/dist/core/messages/en.js

@@ -28,6 +28,7 @@ export const en = {
     extensionsNone: "(no extensions)",
     extensionOff: (name, reason) => `${name} is off: it ${reason}`,
     extensionsInstalled: "Installed:",
+    extensionSwitched: (name, enabled) => `(${name} ${enabled ? "enabled" : "disabled"}, in this same session)`,
     extensionToggled: (name, enabled) => `(${name} ${enabled ? "enabled" : "disabled"}: the session reopens, with the same conversation)`,
     extensionNotInstalled: (name) => `(${name} isn't installed: /extensions lists them)`,
     extensionsUsage: "(usage: /extensions, /extensions enable <name>, /extensions disable <name>)",

package/dist/core/messages/es.js

@@ -29,6 +29,7 @@ export const es = {
     extensionsNone: "(ninguna extensión)",
     extensionOff: (name, reason) => `${name} está desactivada: ${reason}`,
     extensionsInstalled: "Instaladas:",
+    extensionSwitched: (name, enabled) => `(${name} ${enabled ? "activada" : "desactivada"}, en esta misma sesión)`,
     extensionToggled: (name, enabled) => `(${name} ${enabled ? "activada" : "desactivada"}: la sesión se reabre, con la misma conversación)`,
     extensionNotInstalled: (name) => `(${name} no está instalada: /extensions las lista)`,
     extensionsUsage: "(uso: /extensions, /extensions enable <nombre>, /extensions disable <nombre>)",

package/dist/core/messages/fr.js

@@ -29,6 +29,7 @@ export const fr = {
     extensionsNone: "(aucune extension)",
     extensionOff: (name, reason) => `${name} est désactivée : ${reason}`,
     extensionsInstalled: "Installées :",
+    extensionSwitched: (name, enabled) => `(${name} ${enabled ? "activée" : "désactivée"}, dans cette même session)`,
     extensionToggled: (name, enabled) => `(${name} ${enabled ? "activée" : "désactivée"} : la session se rouvre, avec la même conversation)`,
     extensionNotInstalled: (name) => `(${name} n'est pas installée : /extensions les liste)`,
     extensionsUsage: "(usage : /extensions, /extensions enable <nom>, /extensions disable <nom>)",

package/dist/core/pluginDownloads.d.ts

@@ -0,0 +1,14 @@
+/** The regular files of a tar archive, by path (ustar, with pax and GNU long names). */
+export declare function untar(tar: Uint8Array): Map<string, Uint8Array>;
+/** The highest of `versions` that `wanted` asks for: an exact version, or a range (`^`, `~`, comparators, `*`). */
+export declare function pickVersion(versions: readonly string[], wanted: string): string | undefined;
+/** An npm package into a new temporary folder: `{ dir, version }`. */
+export declare function fetchNpmPlugin(name: string, wanted?: string, registry?: string): Promise<{
+    dir: string;
+    version: string;
+}>;
+/** A zip archive into a new temporary folder; the plugin is its root, or its only folder. */
+export declare function fetchArchivePlugin(url: string, sha256?: string): Promise<{
+    dir: string;
+    root: string;
+}>;

package/dist/core/pluginDownloads.js

@@ -0,0 +1,141 @@
+import { createHash } from "node:crypto";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { inKitRange } from "./externalExtensions.js";
+async function fflate() {
+    try {
+        return (await import("fflate"));
+    }
+    catch (error) {
+        throw new Error('Installing from an npm or archive source needs the optional "fflate" library: npm install fflate', { cause: error });
+    }
+}
+async function download(url) {
+    if (!url.startsWith("https://"))
+        throw new Error(`Only https downloads: ${url}.`);
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`${url} answered ${response.status}.`);
+    return new Uint8Array(await response.arrayBuffer());
+}
+/** Files into `dir`, each at its relative path; one that would land outside it is refused. */
+async function writeFiles(dir, files) {
+    const root = path.resolve(dir);
+    for (const [name, data] of files) {
+        const target = path.resolve(root, name);
+        if (!target.startsWith(`${root}${path.sep}`) || name.split(/[\\/]/).includes(".."))
+            throw new Error(`The download has a file outside its folder: ${name}.`);
+        await mkdir(path.dirname(target), { recursive: true });
+        await writeFile(target, data);
+    }
+}
+/** The regular files of a tar archive, by path (ustar, with pax and GNU long names). */
+export function untar(tar) {
+    const files = new Map();
+    const text = (from, length) => new TextDecoder().decode(tar.subarray(from, from + length)).replace(/\0.*$/s, "");
+    let offset = 0;
+    let longName;
+    while (offset + 512 <= tar.length) {
+        const name = text(offset, 100);
+        if (!name)
+            break; // the two empty blocks at the end
+        const size = parseInt(text(offset + 124, 12).trim() || "0", 8);
+        const type = text(offset + 156, 1);
+        const prefix = text(offset + 345, 155);
+        const body = tar.subarray(offset + 512, offset + 512 + size);
+        if (type === "x") {
+            longName = /(?:^|\n)\d+ path=([^\n]*)\n/.exec(new TextDecoder().decode(body))?.[1] ?? longName;
+        }
+        else if (type === "L") {
+            longName = new TextDecoder().decode(body).replace(/\0.*$/s, "");
+        }
+        else {
+            if (type === "0" || type === "" || type === "7")
+                files.set(longName ?? (prefix ? `${prefix}/${name}` : name), body);
+            longName = undefined;
+        }
+        offset += 512 + Math.ceil(size / 512) * 512;
+    }
+    return files;
+}
+/** The highest of `versions` that `wanted` asks for: an exact version, or a range (`^`, `~`, comparators, `*`). */
+export function pickVersion(versions, wanted) {
+    const range = wanted.trim();
+    if (versions.includes(range))
+        return range;
+    const comparators = range.split(/\s+/).flatMap((part) => {
+        if (part === "*" || part === "x" || part === "")
+            return [];
+        const caret = /^\^(\d+)\.(\d+)\.(\d+)$/.exec(part);
+        if (caret) {
+            const [major, minor, patch] = caret.slice(1).map(Number);
+            const upper = major > 0 ? `${major + 1}.0.0` : minor > 0 ? `0.${minor + 1}.0` : `0.0.${patch + 1}`;
+            return [`>=${major}.${minor}.${patch}`, `<${upper}`];
+        }
+        const tilde = /^~(\d+)\.(\d+)\.(\d+)$/.exec(part);
+        if (tilde)
+            return [`>=${tilde[1]}.${tilde[2]}.${tilde[3]}`, `<${tilde[1]}.${Number(tilde[2]) + 1}.0`];
+        return [part];
+    });
+    const stable = versions.filter((version) => /^\d+\.\d+\.\d+$/.test(version));
+    const matching = stable.filter((version) => !comparators.length || inKitRange(version, comparators.join(" ")));
+    const order = (version) => version.split(".").map(Number);
+    return matching.sort((a, b) => {
+        const [x, y] = [order(a), order(b)];
+        for (let i = 0; i < 3; i++)
+            if (x[i] !== y[i])
+                return x[i] - y[i];
+        return 0;
+    }).at(-1);
+}
+/** An npm package into a new temporary folder: `{ dir, version }`. */
+export async function fetchNpmPlugin(name, wanted = "latest", registry = "https://registry.npmjs.org") {
+    if (!/^(@[a-z0-9][\w.-]*\/)?[a-z0-9][\w.-]*$/i.test(name))
+        throw new Error(`"${name}" isn't an npm package name.`);
+    const response = await fetch(`${registry.replace(/\/+$/, "")}/${name.replace("/", "%2f")}`, { headers: { accept: "application/json" } });
+    if (!response.ok)
+        throw new Error(`The registry has no package ${name} (${response.status}).`);
+    const metadata = (await response.json());
+    const version = metadata["dist-tags"]?.[wanted] ?? pickVersion(Object.keys(metadata.versions ?? {}), wanted);
+    const dist = version ? metadata.versions?.[version]?.dist : undefined;
+    if (!version || !dist?.tarball)
+        throw new Error(`${name} has no version ${wanted}.`);
+    const tarball = await download(dist.tarball);
+    const sri = /^sha512-(.+)$/.exec(dist.integrity ?? "");
+    if (!sri)
+        throw new Error(`${name}@${version} has no sha512 integrity to check it against.`);
+    if (createHash("sha512").update(tarball).digest("base64") !== sri[1])
+        throw new Error(`${name}@${version}'s download doesn't match its integrity.`);
+    const { gunzipSync } = await fflate();
+    const dir = await mkdtemp(path.join(os.tmpdir(), "agent-kit-npm-"));
+    try {
+        // npm puts a package's files under package/.
+        const files = [...untar(gunzipSync(tarball))].flatMap(([file, data]) => (file.startsWith("package/") ? [[file.slice("package/".length), data]] : []));
+        await writeFiles(dir, files);
+        return { dir, version };
+    }
+    catch (error) {
+        await rm(dir, { recursive: true, force: true });
+        throw error;
+    }
+}
+/** A zip archive into a new temporary folder; the plugin is its root, or its only folder. */
+export async function fetchArchivePlugin(url, sha256) {
+    const zip = await download(url);
+    if (sha256 && createHash("sha256").update(zip).digest("hex") !== sha256.toLowerCase())
+        throw new Error(`${url} doesn't match its sha256.`);
+    const { unzipSync } = await fflate();
+    const files = Object.entries(unzipSync(zip)).filter(([name]) => !name.endsWith("/"));
+    const dir = await mkdtemp(path.join(os.tmpdir(), "agent-kit-archive-"));
+    try {
+        await writeFiles(dir, files);
+        const tops = new Set(files.map(([name]) => name.split("/")[0]));
+        const only = tops.size === 1 && files.every(([name]) => name.includes("/")) ? [...tops][0] : "";
+        return { dir, root: path.join(dir, only) };
+    }
+    catch (error) {
+        await rm(dir, { recursive: true, force: true });
+        throw error;
+    }
+}

package/dist/core/runner.js

@@ -31,7 +31,12 @@ export function runQuery(prompt, options) {
     // What the session is, for an extension that asks (sessionFacts.ts): the controls now, the
     // tools and skills when the session starts.
     const view = sessionViewOf(options);
-    view?.attach({ supportedCommands: () => result.supportedCommands(), contextUsage: () => contextUsage() });
+    view?.attach({
+        supportedCommands: () => result.supportedCommands(),
+        contextUsage: () => contextUsage(),
+        toggleMcpServer: (server, enabled) => result.toggleMcpServer(server, enabled),
+        reloadPlugins: () => result.reloadPlugins(),
+    });
     // The main agent's tool calls by id, to name the results that come back for them.
     const toolNames = new Map();
     async function* generateEvents() {

package/dist/core/session.d.ts

@@ -1,12 +1,12 @@
 import type { Options, SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
 import { type TranscriptLogger } from "./hooks/transcriptLogger.js";
 import { type ModeControl } from "./modeControl.js";
-import type { KnowledgeStore } from "../extensions/knowledge/knowledgeStore.js";
 import { type ExtensionDirs, type InstalledExtension } from "./externalExtensions.js";
 import type { ToolLabels } from "./toolLabels.js";
 import type { AgentSpec, BaseSessionConfig } from "./agentSpec.js";
 import { type Language } from "./language.js";
 import { type RunFolder } from "./runs.js";
+import { type ExtensionSwitch } from "./liveExtensions.js";
 /**
  * Builds the `options` object passed to the Agent SDK's `query()` — everything about
  * *how* the agent runs a session (system prompt, tools, MCP servers, hooks), independent
@@ -40,10 +40,10 @@ export declare function buildSessionOptions<TConfig extends BaseSessionConfig>(c
     toolLabels: ToolLabels;
     /** The installed extensions and what this session runs with, for `/extensions` (#37). */
     extensions: ExtensionsStatus;
-    /** The knowledge base's store, when the knowledge extension is on (for a host that reads the knowledge base). */
-    knowledgeStore?: KnowledgeStore;
-    /** What each active extension hands the host (its contribution's `api`), by its name: the sources' `addSource`, the knowledge base's store. */
+    /** What each active extension hands the host (its contribution's `api`), by its name: the sources' `addSource`, the knowledge base's `knowledgeStore`. */
     apis: Record<string, Record<string, unknown>>;
+    /** Turns an installed extension off or on in the running session; false when that takes opening it again (#49). */
+    switchExtension: ExtensionSwitch;
 }>;
 export { createModeControl, togglePlanMode, type ModeControl } from "./modeControl.js";
 /** The extensions of a session: where they're installed, what's installed, what runs and what can't (with why). */
@@ -68,6 +68,13 @@ export interface ExtensionsStatus {
  * and digits as "-" (confirmed empirically).
  */
 export declare function claudeProjectDir(projectDir: string): string;
+/**
+ * The SDK's `permissions.deny` rules for paths no file tool may read or change, each one and
+ * whatever is inside it. An absolute path is written `//` and POSIX: `C:\Users\x` is
+ * `//c/Users/x` (confirmed empirically on Windows; on POSIX `/home/x` is `//home/x`). `Read`
+ * rules reach the tools that read, `Edit` rules those that write.
+ */
+export declare function denyRules(paths: readonly string[]): string[];
 /**
  * The skills of the plugins in `roots`, as the SDK names them: `<plugin>:<folder>`, the
  * plugin's name from its `.claude-plugin/plugin.json` and the skill's folder under `skills/`,