@falkenslab/agent-kit 0.19.0 → 0.20.0

package/dist/core/liveExtensions.d.ts

@@ -0,0 +1,51 @@
+import type { ExtensionsStatus } from "./session.js";
+import type { SessionLive, StaticSessionFacts } from "./sessionFacts.js";
+import type { ToolLabels } from "./toolLabels.js";
+/**
+ * Turning an installed extension off and on in a running session (#49), without reopening it.
+ * Only one that was running when the session opened: its MCP servers are toggled
+ * (`toggleMcpServer()`, which removes their tools from the model's context and brings them back,
+ * confirmed empirically) and its plugin, a copy in the run's folder, is emptied or filled again
+ * before `reloadPlugins()` (its skills, commands and subagents go and come back, confirmed
+ * empirically). The kit's own lists follow: the plan gate's read-only tools, the subagent gates'
+ * allowed types, the chat's labels, `/extensions` and what `about_me` says. One that wasn't
+ * running has no plugin path the session knows: it takes reopening the session.
+ *
+ * Not through `setMcpServers()`: it leaves the servers given at start alone (confirmed
+ * empirically: removing one from its set removes nothing).
+ */
+/** What an installed extension brought to this session, to take it away and bring it back. */
+export interface LiveExtension {
+    name: string;
+    /** Where it's installed (its scope's folder): the plugin copy is filled from there. */
+    installedDir: string;
+    scopeDir: string;
+    /** Its plugin, copied into the run's folder for this session. */
+    pluginCopy: string;
+    servers: string[];
+    readOnlyTools: string[];
+    toolLabels: ToolLabels;
+    /** Its subagents, as the type gate names them (`<plugin>:<name>`). */
+    agents: string[];
+    description: string;
+    provides: string[];
+    help: string[];
+}
+/** The session's own lists the switch keeps in step: the same objects the gates, the chat and the view read. */
+export interface LiveTargets {
+    readOnlyTools: string[];
+    allowedSubagentTypes: string[];
+    toolLabels: ToolLabels;
+    status: ExtensionsStatus;
+    facts: StaticSessionFacts;
+    /** The running session's controls, once it has started. */
+    controls: () => SessionLive;
+}
+/**
+ * Turns `name` on or off in the running session; false when it can't be done here (it wasn't
+ * running when the session opened, the session hasn't started, or its files changed since it
+ * was installed), and the session must be opened again.
+ */
+export type ExtensionSwitch = (name: string, enabled: boolean) => Promise<boolean>;
+/** The switch for a session's installed extensions. */
+export declare function createExtensionSwitch(extensions: readonly LiveExtension[], targets: LiveTargets): ExtensionSwitch;

package/dist/core/liveExtensions.js

@@ -0,0 +1,70 @@
+import { cp, readdir, rm } from "node:fs/promises";
+import path from "node:path";
+import { hashExtension, listInstalled, readLock } from "./externalExtensions.js";
+/** The switch for a session's installed extensions. */
+export function createExtensionSwitch(extensions, targets) {
+    const off = new Set();
+    return async (name, enabled) => {
+        const extension = extensions.find((candidate) => candidate.name === name);
+        const controls = targets.controls();
+        if (!extension || !controls.toggleMcpServer || !controls.reloadPlugins)
+            return false;
+        if (enabled === !off.has(name))
+            return true; // already as asked
+        if (enabled) {
+            // Its files as they were installed, or nothing: a changed one is for a new session to judge.
+            const lock = (await readLock(extension.scopeDir))[name];
+            if (!lock || lock.sha256 !== (await hashExtension(extension.installedDir)))
+                return false;
+            await cp(extension.installedDir, extension.pluginCopy, { recursive: true });
+        }
+        else {
+            for (const entry of await readdir(extension.pluginCopy))
+                await rm(path.join(extension.pluginCopy, entry), { recursive: true, force: true });
+        }
+        await controls.reloadPlugins();
+        for (const server of extension.servers)
+            await controls.toggleMcpServer(server, enabled);
+        if (enabled)
+            off.delete(name);
+        else
+            off.add(name);
+        follow(extension, enabled, targets);
+        targets.status.installed = await listInstalled(targets.status.dirs);
+        return true;
+    };
+}
+/** The kit's lists, as the extension is now. */
+function follow(extension, enabled, targets) {
+    const without = (list, items) => {
+        for (const item of items) {
+            const index = list.indexOf(item);
+            if (index >= 0)
+                list.splice(index, 1);
+        }
+    };
+    const { status, facts } = targets;
+    if (enabled) {
+        targets.readOnlyTools.push(...extension.readOnlyTools);
+        targets.allowedSubagentTypes.push(...extension.agents);
+        Object.assign(targets.toolLabels, extension.toolLabels);
+        status.active.push(extension.name);
+        status.about[extension.name] = { description: extension.description, provides: extension.provides };
+        status.inactive = status.inactive.filter((entry) => entry.name !== extension.name);
+        facts.extensions.active.push({ name: extension.name, description: extension.description, provides: extension.provides, servers: extension.servers, help: extension.help });
+        facts.extensions.inactive = facts.extensions.inactive.filter((entry) => entry.name !== extension.name);
+    }
+    else {
+        without(targets.readOnlyTools, extension.readOnlyTools);
+        without(targets.allowedSubagentTypes, extension.agents);
+        // The same object the chat reads its labels from: changed in place, readonly to everyone else.
+        for (const tool of Object.keys(extension.toolLabels))
+            delete targets.toolLabels[tool];
+        without(status.active, [extension.name]);
+        delete status.about[extension.name];
+        const reason = { name: extension.name, reason: "was turned off in this session" };
+        status.inactive.push(reason);
+        facts.extensions.active = facts.extensions.active.filter((entry) => entry.name !== extension.name);
+        facts.extensions.inactive.push(reason);
+    }
+}

package/dist/core/marketplaces.d.ts

@@ -0,0 +1,118 @@
+/** Where a marketplace's plugin comes from, as `marketplace.json` says (Claude Code's forms). */
+export type PluginSource = string | {
+    source: "github";
+    repo: string;
+    ref?: string;
+    sha?: string;
+} | {
+    source: "url";
+    url: string;
+    ref?: string;
+    sha?: string;
+} | {
+    source: "git-subdir";
+    url: string;
+    path: string;
+    ref?: string;
+    sha?: string;
+} | {
+    source: string;
+    [field: string]: unknown;
+};
+/** A plugin a marketplace offers. */
+export interface MarketplacePlugin {
+    name: string;
+    source: PluginSource;
+    description?: string;
+    version?: string;
+    category?: string;
+    tags?: string[];
+    keywords?: string[];
+}
+/** A marketplace's `marketplace.json`, as the kit reads it. */
+export interface MarketplaceManifest {
+    name: string;
+    owner: {
+        name: string;
+        email?: string;
+        url?: string;
+    };
+    description?: string;
+    /** Where bare plugin sources resolve, relative to the marketplace's root. */
+    pluginRoot?: string;
+    plugins: MarketplacePlugin[];
+}
+/** A marketplace an agent knows. */
+export interface KnownMarketplace {
+    name: string;
+    /** Where it came from: a folder, a git URL (`#ref`), or `owner/repo`. */
+    source: string;
+    /** The commit its copy was taken at, for a git one. */
+    commit?: string;
+    /** The agent's own: known without asking, and its plugins installed without a confirmation. */
+    official: boolean;
+    /** When its copy was taken, ISO 8601 in UTC. */
+    updated: string;
+    /** Its copy, inside the agent's extensions folder. */
+    dir: string;
+    manifest?: MarketplaceManifest;
+}
+/** Reads and checks a marketplace's `.claude-plugin/marketplace.json`. */
+export declare function readMarketplaceManifest(root: string): Promise<MarketplaceManifest>;
+/** Reads a marketplace from a folder, a git URL (`#ref`) or `owner/repo` without adding it: what to show before asking. */
+export declare function inspectMarketplace(source: string): Promise<MarketplaceManifest>;
+/**
+ * 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 declare function addMarketplace(source: string, dir: string, options?: {
+    official?: boolean;
+}): Promise<{
+    name: string;
+    replaced: boolean;
+    manifest: MarketplaceManifest;
+    commit?: string;
+}>;
+/** The marketplaces the agent knows, with their manifests when they can be read. */
+export declare function listMarketplaces(dir: string): Promise<KnownMarketplace[]>;
+/** Takes a fresh copy of a known marketplace from where it came from. */
+export declare function updateMarketplace(dir: string, name: string): Promise<{
+    commit?: string;
+}>;
+/** Forgets a marketplace (its copy and its entry); the extensions installed from it stay. False when it wasn't known. */
+export declare function removeMarketplace(dir: string, name: string): Promise<boolean>;
+/** A plugin found in the known marketplaces: `<name>@<marketplace>`, or a name only one of them offers. */
+export declare function findPlugin(dir: string, spec: string): Promise<{
+    marketplace: KnownMarketplace;
+    plugin: MarketplacePlugin;
+}>;
+/** Where a plugin comes from: a folder or git repository for `addExtension()`, or a download (npm, archive). */
+export type ResolvedSource = {
+    source: string;
+    subdir?: string;
+    sha?: string;
+} | {
+    npm: {
+        name: string;
+        version?: string;
+        registry?: string;
+    };
+} | {
+    archive: {
+        url: string;
+        sha256?: string;
+    };
+};
+/** Where a plugin's source points: a folder of the marketplace's copy, a git repository, an npm package or a zip. */
+export declare function resolvePluginSource(marketplace: KnownMarketplace, plugin: MarketplacePlugin): ResolvedSource;
+/**
+ * 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 declare function installFromMarketplace(dir: string, spec: string, scopeDir: string): Promise<{
+    name: string;
+    replaced: boolean;
+    commit?: string;
+    marketplace: string;
+}>;

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;
+}>;