@elizaos/agent 2.0.0-alpha.421 → 2.0.0-alpha.425

package/packages/typescript/src/features/plugin-manager/actions/plugin-handlers/create.js

@@ -0,0 +1,502 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { logger } from "../../../../logger.js";
+export const PLUGIN_CREATE_INTENT_TAG = "plugin-create-intent";
+const TEMPLATE_CANDIDATES = [
+    "eliza/templates/min-plugin",
+    "templates/min-plugin",
+];
+const PLUGINS_DIR_CANDIDATES = ["eliza/plugins", "plugins"];
+const NAME_PLACEHOLDER = "__PLUGIN_NAME__";
+const DISPLAY_NAME_PLACEHOLDER = "__PLUGIN_DISPLAY_NAME__";
+const CHOICE_RE = /^(new|edit-\d+|cancel)$/i;
+const STOP_WORDS = new Set([
+    "a",
+    "an",
+    "the",
+    "to",
+    "for",
+    "of",
+    "and",
+    "or",
+    "plugin",
+    "plugins",
+    "that",
+    "this",
+    "my",
+    "new",
+    "please",
+    "create",
+    "build",
+    "make",
+    "i",
+    "want",
+    "need",
+]);
+const KEBAB_RE = /^[a-z][a-z0-9-]{1,38}[a-z0-9]$/;
+function tokenize(value) {
+    return value
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 1 && !STOP_WORDS.has(token));
+}
+function deriveNames(intent) {
+    const tokens = tokenize(intent).slice(0, 4);
+    const rawSlug = tokens.join("-") || "runtime-plugin";
+    const slug = KEBAB_RE.test(rawSlug) ? rawSlug : "runtime-plugin";
+    const bareName = slug.startsWith("plugin-") ? slug : `plugin-${slug}`;
+    const displayName = tokens.length
+        ? tokens.map((token) => token.charAt(0).toUpperCase() + token.slice(1)).join(" ")
+        : "Runtime Plugin";
+    return { packageName: `@elizaos/${bareName}`, displayName };
+}
+function readStringOption(options, key) {
+    const direct = options?.[key];
+    if (typeof direct === "string" && direct.trim())
+        return direct.trim();
+    const parameters = options?.parameters;
+    if (typeof parameters === "object" &&
+        parameters !== null &&
+        !Array.isArray(parameters)) {
+        const nested = parameters[key];
+        if (typeof nested === "string" && nested.trim())
+            return nested.trim();
+    }
+    return undefined;
+}
+function isDirectory(file) {
+    return fs.stat(file).then((stat) => stat.isDirectory(), () => false);
+}
+async function resolveExistingDirectory(repoRoot, candidates, label) {
+    for (const rel of candidates) {
+        const candidate = path.join(repoRoot, rel);
+        if (await isDirectory(candidate))
+            return candidate;
+    }
+    throw new Error(`Cannot find ${label}. Tried: ${candidates.map((rel) => path.join(repoRoot, rel)).join(", ")}`);
+}
+async function findFreePluginDir(repoRoot, packageName) {
+    const pluginsDir = await resolveExistingDirectory(repoRoot, PLUGINS_DIR_CANDIDATES, "plugins directory");
+    const baseName = packageName.replace(/^@[^/]+\//, "");
+    let candidate = path.join(pluginsDir, baseName);
+    let suffix = 2;
+    while (await isDirectory(candidate)) {
+        candidate = path.join(pluginsDir, `${baseName}-${suffix}`);
+        suffix += 1;
+        if (suffix > 50) {
+            throw new Error(`Could not find a free plugin directory for ${packageName}`);
+        }
+    }
+    return candidate;
+}
+async function copyTemplate(src, dest, replacements) {
+    const stack = [{ from: src, to: dest }];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            break;
+        const stat = await fs.stat(current.from);
+        if (stat.isDirectory()) {
+            await fs.mkdir(current.to, { recursive: true });
+            for (const entry of await fs.readdir(current.from)) {
+                stack.push({
+                    from: path.join(current.from, entry),
+                    to: path.join(current.to, entry),
+                });
+            }
+            continue;
+        }
+        if (!stat.isFile())
+            continue;
+        const raw = await fs.readFile(current.from);
+        const text = raw.toString("utf8");
+        if (Buffer.byteLength(text, "utf8") === raw.length) {
+            let rewritten = text;
+            for (const [token, value] of Object.entries(replacements)) {
+                rewritten = rewritten.split(token).join(value);
+            }
+            await fs.writeFile(current.to, rewritten, "utf8");
+        }
+        else {
+            await fs.writeFile(current.to, raw);
+        }
+    }
+}
+function readStringField(source, key) {
+    const value = source[key];
+    return typeof value === "string" && value.trim().length > 0
+        ? value
+        : undefined;
+}
+function readTaskAgents(result) {
+    const agents = result?.data?.agents;
+    if (!Array.isArray(agents))
+        return [];
+    return agents.flatMap((agent) => {
+        if (!agent || typeof agent !== "object" || Array.isArray(agent))
+            return [];
+        const record = agent;
+        const sessionId = readStringField(record, "sessionId");
+        const agentType = readStringField(record, "agentType");
+        const workdir = readStringField(record, "workdir");
+        const label = readStringField(record, "label");
+        const status = readStringField(record, "status");
+        if (!sessionId || !agentType || !workdir || !label || !status)
+            return [];
+        return [
+            {
+                sessionId,
+                agentType,
+                workdir,
+                label,
+                status,
+                workspaceId: readStringField(record, "workspaceId"),
+                branch: readStringField(record, "branch"),
+                error: readStringField(record, "error"),
+            },
+        ];
+    });
+}
+async function dispatchCodingAgent({ runtime, prompt, label, workdir, pluginName, callback, }) {
+    const createTask = runtime.actions?.find((action) => action.name === "CREATE_TASK");
+    if (!createTask) {
+        return { dispatched: false, reason: "CREATE_TASK action not registered" };
+    }
+    const fakeMessage = {
+        entityId: runtime.agentId,
+        roomId: runtime.agentId,
+        agentId: runtime.agentId,
+        content: { text: prompt },
+    };
+    const handlerOptions = {
+        parameters: {
+            task: prompt,
+            label,
+            approvalPreset: "permissive",
+            validator: {
+                service: "app-verification",
+                method: "verifyPlugin",
+                params: { workdir, pluginName },
+            },
+            onVerificationFail: "retry",
+        },
+    };
+    const result = await createTask.handler(runtime, fakeMessage, undefined, handlerOptions, callback);
+    if (!result?.success) {
+        return {
+            dispatched: false,
+            reason: result?.text ??
+                (typeof result?.error === "string"
+                    ? result.error
+                    : "CREATE_TASK failed to start"),
+        };
+    }
+    const agents = readTaskAgents(result);
+    if (agents.length === 0) {
+        return {
+            dispatched: false,
+            reason: "CREATE_TASK did not return a tracked task status",
+        };
+    }
+    return { dispatched: true, agents };
+}
+function buildCreatePrompt(intent, pluginName, displayName, workdir) {
+    return [
+        `You are building a new Eliza plugin called "${displayName}".`,
+        `The user's intent: ${intent}`,
+        `The plugin source directory is ${workdir}. It has already been scaffolded from the min-plugin template.`,
+        "Work in that source directory.",
+        "Read SCAFFOLD.md before editing.",
+        "Before signaling completion, run from the plugin directory: bun run typecheck, then bun run lint, then bun run test.",
+        "After all three commands pass, emit exactly one completion line in this canonical schema:",
+        `PLUGIN_CREATE_DONE {"pluginName":"${pluginName}","files":["src/index.ts"],"tests":{"passed":1,"failed":0},"lint":"ok","typecheck":"ok"}`,
+        "Use files changed or added relative to the source directory.",
+    ].join("\n");
+}
+function buildEditPrompt(intent, plugin, workdir) {
+    return [
+        `You are modifying the existing Eliza plugin "${plugin.name}".`,
+        `Source lives in ${workdir}.`,
+        `User's request: ${intent}`,
+        "Implement the requested change without refactoring unrelated code.",
+        "Before signaling completion, run from the plugin directory: bun run typecheck, then bun run lint, then bun run test.",
+        "After all three commands pass, emit exactly one completion line in this canonical schema:",
+        `PLUGIN_CREATE_DONE {"pluginName":"${plugin.name}","files":["src/index.ts"],"tests":{"passed":1,"failed":0},"lint":"ok","typecheck":"ok"}`,
+    ].join("\n");
+}
+function rankMatches(intent, plugins) {
+    const intentTokens = new Set(tokenize(intent));
+    if (intentTokens.size === 0)
+        return [];
+    const ranked = [];
+    for (const plugin of plugins) {
+        const haystack = tokenize(`${plugin.name} ${plugin.path}`);
+        let score = 0;
+        for (const token of haystack) {
+            if (intentTokens.has(token))
+                score += 1;
+        }
+        if (score > 0)
+            ranked.push({ plugin, score });
+    }
+    return ranked.sort((a, b) => b.score - a.score).slice(0, 5);
+}
+function renderChoiceBlock(choiceId, matches) {
+    const lines = [`[CHOICE:plugin-create id=${choiceId}]`, "new = Create new plugin"];
+    matches.forEach((match, idx) => {
+        lines.push(`edit-${idx + 1} = Edit existing: ${match.plugin.name}`);
+    });
+    lines.push("cancel = Cancel", "[/CHOICE]");
+    return lines.join("\n");
+}
+async function listKnownPlugins(runtime) {
+    const service = runtime.getService("plugin_manager");
+    if (!service)
+        return [];
+    const loaded = service.getAllPlugins().map((plugin) => ({
+        name: plugin.name,
+        path: "",
+        version: "loaded",
+        upstream: null,
+    }));
+    const installed = await service.listInstalledPlugins();
+    const ejected = await service.listEjectedPlugins();
+    const byName = new Map();
+    for (const plugin of [...loaded, ...installed, ...ejected]) {
+        byName.set(plugin.name, plugin);
+    }
+    return Array.from(byName.values());
+}
+async function findExistingIntentTask(runtime, roomId) {
+    const tasks = await runtime.getTasks({
+        agentIds: [runtime.agentId],
+        tags: [PLUGIN_CREATE_INTENT_TAG],
+    });
+    const matching = tasks
+        .filter((task) => {
+        const meta = task.metadata;
+        return meta?.roomId === roomId;
+    })
+        .sort((a, b) => {
+        const aMeta = a.metadata;
+        const bMeta = b.metadata;
+        const aAt = typeof aMeta?.intentCreatedAt === "string"
+            ? Date.parse(aMeta.intentCreatedAt)
+            : 0;
+        const bAt = typeof bMeta?.intentCreatedAt === "string"
+            ? Date.parse(bMeta.intentCreatedAt)
+            : 0;
+        return bAt - aAt;
+    });
+    const top = matching[0];
+    if (!top?.id)
+        return null;
+    const meta = top.metadata;
+    if (!meta || typeof meta.intent !== "string")
+        return null;
+    const choicesRaw = Array.isArray(meta.choices) ? meta.choices : [];
+    const choices = choicesRaw
+        .filter((choice) => typeof choice === "object" &&
+        choice !== null &&
+        typeof choice.key === "string" &&
+        typeof choice.label === "string")
+        .map((choice) => ({
+        key: choice.key,
+        label: choice.label,
+        pluginName: typeof choice.pluginName === "string" ? choice.pluginName : undefined,
+        pluginPath: typeof choice.pluginPath === "string" ? choice.pluginPath : undefined,
+    }));
+    return {
+        taskId: top.id,
+        metadata: {
+            roomId,
+            intent: meta.intent,
+            choices,
+            intentCreatedAt: typeof meta.intentCreatedAt === "string"
+                ? meta.intentCreatedAt
+                : new Date().toISOString(),
+        },
+    };
+}
+async function persistIntentTask(runtime, metadata) {
+    await runtime.createTask({
+        name: "PLUGIN_CREATE intent",
+        description: `Awaiting user choice for: ${metadata.intent}`,
+        tags: [PLUGIN_CREATE_INTENT_TAG],
+        metadata,
+    });
+}
+async function deleteIntentTask(runtime, taskId) {
+    await runtime.deleteTask(taskId);
+}
+async function createNewPlugin({ runtime, intent, repoRoot, callback, }) {
+    const { packageName, displayName } = deriveNames(intent);
+    const templateSrc = await resolveExistingDirectory(repoRoot, TEMPLATE_CANDIDATES, "min-plugin template");
+    const workdir = await findFreePluginDir(repoRoot, packageName);
+    await copyTemplate(templateSrc, workdir, {
+        [NAME_PLACEHOLDER]: packageName,
+        [DISPLAY_NAME_PLACEHOLDER]: displayName,
+    });
+    const dispatch = await dispatchCodingAgent({
+        runtime,
+        prompt: buildCreatePrompt(intent, packageName, displayName, workdir),
+        label: `create-plugin:${packageName}`,
+        workdir,
+        pluginName: packageName,
+        callback,
+    });
+    if (dispatch.dispatched === false) {
+        const text = `Scaffolded ${displayName} at ${workdir}, but could not dispatch a coding agent: ${dispatch.reason}.`;
+        await callback?.({ text });
+        return { success: false, text, values: { mode: "create", workdir } };
+    }
+    const task = dispatch.agents[0];
+    const text = `Started plugin create task for ${displayName} at ${workdir}. Task session ${task.sessionId} is ${task.status}; verification will run when it emits PLUGIN_CREATE_DONE.`;
+    await callback?.({ text });
+    logger.info(`[plugin-manager] PLUGIN/create new name=${packageName} workdir=${workdir} session=${task.sessionId}`);
+    return {
+        success: true,
+        text,
+        values: {
+            mode: "create",
+            subMode: "new",
+            name: packageName,
+            displayName,
+            workdir,
+            taskStatus: task.status,
+            taskSessionId: task.sessionId,
+        },
+        data: { name: packageName, displayName, workdir, task, agents: dispatch.agents },
+    };
+}
+async function editExistingPlugin({ runtime, intent, plugin, callback, }) {
+    if (!plugin.path) {
+        const text = `Plugin "${plugin.name}" has no local source path. Eject it before editing.`;
+        await callback?.({ text });
+        return { success: false, text };
+    }
+    const dispatch = await dispatchCodingAgent({
+        runtime,
+        prompt: buildEditPrompt(intent, plugin, plugin.path),
+        label: `edit-plugin:${plugin.name}`,
+        workdir: plugin.path,
+        pluginName: plugin.name,
+        callback,
+    });
+    if (dispatch.dispatched === false) {
+        const text = `Could not dispatch a coding agent to edit ${plugin.name}: ${dispatch.reason}.`;
+        await callback?.({ text });
+        return { success: false, text };
+    }
+    const task = dispatch.agents[0];
+    const text = `Started plugin edit task for ${plugin.name} at ${plugin.path}. Task session ${task.sessionId} is ${task.status}; verification will run when it emits PLUGIN_CREATE_DONE.`;
+    await callback?.({ text });
+    return {
+        success: true,
+        text,
+        values: {
+            mode: "create",
+            subMode: "edit",
+            name: plugin.name,
+            workdir: plugin.path,
+            taskStatus: task.status,
+            taskSessionId: task.sessionId,
+        },
+        data: { plugin, task, agents: dispatch.agents },
+    };
+}
+export function isPluginCreateChoiceReply(text) {
+    return CHOICE_RE.test(text.trim());
+}
+export async function runCreate({ runtime, message, options, callback, intent: explicitIntent, choice: explicitChoice, editTarget, repoRoot, }) {
+    const roomId = typeof message.roomId === "string" ? message.roomId : runtime.agentId;
+    const userText = (message.content?.text ?? "").trim();
+    const optionChoice = readStringOption(options, "choice");
+    const optionIntent = readStringOption(options, "intent");
+    const optionEditTarget = readStringOption(options, "editTarget");
+    const choiceText = explicitChoice ?? optionChoice ?? userText;
+    const intent = explicitIntent ?? optionIntent ?? userText;
+    const existing = await findExistingIntentTask(runtime, roomId);
+    if (existing && isPluginCreateChoiceReply(choiceText)) {
+        const normalized = choiceText.toLowerCase().trim();
+        await deleteIntentTask(runtime, existing.taskId);
+        if (normalized === "cancel") {
+            const text = "Canceled. No plugin changes made.";
+            await callback?.({ text });
+            return { success: true, text, values: { mode: "create", subMode: "cancel" } };
+        }
+        if (normalized === "new") {
+            return createNewPlugin({
+                runtime,
+                intent: existing.metadata.intent,
+                repoRoot,
+                callback,
+            });
+        }
+        const idxMatch = normalized.match(/^edit-(\d+)$/);
+        const idx = idxMatch ? Number(idxMatch[1]) - 1 : -1;
+        const choice = existing.metadata.choices.filter((entry) => entry.key.startsWith("edit-"))[idx];
+        const plugins = await listKnownPlugins(runtime);
+        const target = plugins.find((plugin) => plugin.name === choice?.pluginName || plugin.path === choice?.pluginPath);
+        if (!target) {
+            const text = `Plugin edit target "${normalized}" is no longer available.`;
+            await callback?.({ text });
+            return { success: false, text };
+        }
+        return editExistingPlugin({
+            runtime,
+            intent: existing.metadata.intent,
+            plugin: target,
+            callback,
+        });
+    }
+    const targetName = editTarget ?? optionEditTarget;
+    if (targetName) {
+        const plugins = await listKnownPlugins(runtime);
+        const target = plugins.find((plugin) => plugin.name === targetName || plugin.path === targetName);
+        if (!target) {
+            const text = `Cannot find a local plugin named "${targetName}".`;
+            await callback?.({ text });
+            return { success: false, text };
+        }
+        return editExistingPlugin({ runtime, intent, plugin: target, callback });
+    }
+    if (!intent) {
+        const text = "Tell me what plugin you want to build.";
+        await callback?.({ text });
+        return { success: false, text };
+    }
+    const plugins = await listKnownPlugins(runtime);
+    const matches = rankMatches(intent, plugins).filter((match) => match.plugin.path);
+    if (matches.length === 0) {
+        return createNewPlugin({ runtime, intent, repoRoot, callback });
+    }
+    const choices = [
+        { key: "new", label: "Create new plugin" },
+        ...matches.map((match, idx) => ({
+            key: `edit-${idx + 1}`,
+            label: `Edit existing: ${match.plugin.name}`,
+            pluginName: match.plugin.name,
+            pluginPath: match.plugin.path,
+        })),
+        { key: "cancel", label: "Cancel" },
+    ];
+    await persistIntentTask(runtime, {
+        roomId,
+        intent,
+        choices,
+        intentCreatedAt: new Date().toISOString(),
+    });
+    const text = renderChoiceBlock(`plugin-create-${Date.now().toString(36)}`, matches);
+    await callback?.({ text });
+    return {
+        success: true,
+        text: "Picking next step...",
+        values: { mode: "create", subMode: "choice", matchCount: matches.length },
+        data: { choices, intent },
+    };
+}
+export async function hasPendingPluginCreateIntent(runtime, roomId) {
+    return (await findExistingIntentTask(runtime, roomId)) !== null;
+}

package/packages/typescript/src/features/plugin-manager/actions/plugin-handlers/eject.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @module features/plugin-manager/actions/plugin-handlers/eject
+ *
+ * `eject` sub-mode of the unified PLUGIN action. Clones a registry plugin
+ * into the local ejected directory so the user can edit + sync against
+ * upstream.
+ */
+import type { ActionResult, HandlerCallback } from "../../../../types/components.ts";
+import type { IAgentRuntime } from "../../../../types/runtime.ts";
+export interface EjectInput {
+    runtime: IAgentRuntime;
+    name: string;
+    callback?: HandlerCallback;
+}
+export declare function runEject({ runtime, name, callback, }: EjectInput): Promise<ActionResult>;
+//# sourceMappingURL=eject.d.ts.map

package/packages/typescript/src/features/plugin-manager/actions/plugin-handlers/eject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eject.d.ts","sourceRoot":"","sources":["../../../../../../../../../typescript/src/features/plugin-manager/actions/plugin-handlers/eject.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACX,YAAY,EACZ,eAAe,EACf,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAGlE,MAAM,WAAW,UAAU;IAC1B,OAAO,EAAE,aAAa,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC3B;AAED,wBAAsB,QAAQ,CAAC,EAC9B,OAAO,EACP,IAAI,EACJ,QAAQ,GACR,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC,CA8CpC"}

package/packages/typescript/src/features/plugin-manager/actions/plugin-handlers/eject.js

@@ -0,0 +1,47 @@
+/**
+ * @module features/plugin-manager/actions/plugin-handlers/eject
+ *
+ * `eject` sub-mode of the unified PLUGIN action. Clones a registry plugin
+ * into the local ejected directory so the user can edit + sync against
+ * upstream.
+ */
+export async function runEject({ runtime, name, callback, }) {
+    const service = runtime.getService("plugin_manager");
+    if (!service) {
+        const text = "Plugin manager service not available";
+        await callback?.({ text });
+        return { success: false, text };
+    }
+    if (!name) {
+        const text = "Specify a plugin name to eject.";
+        await callback?.({ text });
+        return { success: false, text };
+    }
+    const result = await service.ejectPlugin(name);
+    if (!result.success) {
+        const text = `Failed to eject ${name}: ${result.error ?? "unknown error"}`;
+        await callback?.({ text });
+        return { success: false, text };
+    }
+    const text = `Ejected ${result.pluginName} to ${result.ejectedPath} ` +
+        `(commit ${result.upstreamCommit.slice(0, 8)})` +
+        (result.requiresRestart ? "\nRestart required to load the local copy." : "");
+    await callback?.({ text });
+    return {
+        success: true,
+        text,
+        values: {
+            mode: "eject",
+            name: result.pluginName,
+            ejectedPath: result.ejectedPath,
+            upstreamCommit: result.upstreamCommit,
+        },
+        data: {
+            success: result.success,
+            pluginName: result.pluginName,
+            ejectedPath: result.ejectedPath,
+            upstreamCommit: result.upstreamCommit,
+            requiresRestart: result.requiresRestart,
+        },
+    };
+}

package/packages/typescript/src/features/plugin-manager/actions/plugin-handlers/install.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @module features/plugin-manager/actions/plugin-handlers/install
+ *
+ * `install` sub-mode of the unified PLUGIN action. Installs a plugin from
+ * the registry by canonical name. The underlying service handles the
+ * npm/git source selection internally — `source: "git"` simply forces a
+ * clone via the `PLUGIN_MANAGER_LOCAL_CLONE` env override on this call.
+ */
+import type { ActionResult, HandlerCallback } from "../../../../types/components.ts";
+import type { IAgentRuntime } from "../../../../types/runtime.ts";
+export interface InstallInput {
+    runtime: IAgentRuntime;
+    name: string;
+    source?: "npm" | "git";
+    callback?: HandlerCallback;
+}
+export declare function runInstall({ runtime, name, source, callback, }: InstallInput): Promise<ActionResult>;
+//# sourceMappingURL=install.d.ts.map

package/packages/typescript/src/features/plugin-manager/actions/plugin-handlers/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../../../../../../../../typescript/src/features/plugin-manager/actions/plugin-handlers/install.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EACX,YAAY,EACZ,eAAe,EACf,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAGlE,MAAM,WAAW,YAAY;IAC5B,OAAO,EAAE,aAAa,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IACvB,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC3B;AAED,wBAAsB,UAAU,CAAC,EAChC,OAAO,EACP,IAAI,EACJ,MAAM,EACN,QAAQ,GACR,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAyDtC"}

package/packages/typescript/src/features/plugin-manager/actions/plugin-handlers/install.js

@@ -0,0 +1,59 @@
+/**
+ * @module features/plugin-manager/actions/plugin-handlers/install
+ *
+ * `install` sub-mode of the unified PLUGIN action. Installs a plugin from
+ * the registry by canonical name. The underlying service handles the
+ * npm/git source selection internally — `source: "git"` simply forces a
+ * clone via the `PLUGIN_MANAGER_LOCAL_CLONE` env override on this call.
+ */
+import { logger } from "../../../../logger.js";
+export async function runInstall({ runtime, name, source, callback, }) {
+    const service = runtime.getService("plugin_manager");
+    if (!service) {
+        const text = "Plugin manager service not available";
+        await callback?.({ text });
+        return { success: false, text };
+    }
+    if (!name) {
+        const text = "Specify a plugin name to install (e.g. @elizaos/plugin-twitter).";
+        await callback?.({ text });
+        return { success: false, text };
+    }
+    const prevClone = process.env.PLUGIN_MANAGER_LOCAL_CLONE;
+    if (source === "git")
+        process.env.PLUGIN_MANAGER_LOCAL_CLONE = "true";
+    const result = await service.installPlugin(name, (progress) => {
+        logger.info(`[plugin-manager] install ${name} ${progress.phase}: ${progress.message}`);
+    });
+    if (source === "git") {
+        if (prevClone === undefined)
+            delete process.env.PLUGIN_MANAGER_LOCAL_CLONE;
+        else
+            process.env.PLUGIN_MANAGER_LOCAL_CLONE = prevClone;
+    }
+    if (!result.success) {
+        const text = `Failed to install ${name}: ${result.error ?? "unknown error"}`;
+        await callback?.({ text });
+        return { success: false, text };
+    }
+    const text = `Installed ${result.pluginName}@${result.version} at ${result.installPath}` +
+        (result.requiresRestart ? "\nRestart required to activate." : "");
+    await callback?.({ text });
+    return {
+        success: true,
+        text,
+        values: {
+            mode: "install",
+            name: result.pluginName,
+            version: result.version,
+            installPath: result.installPath,
+        },
+        data: {
+            success: result.success,
+            pluginName: result.pluginName,
+            version: result.version,
+            installPath: result.installPath,
+            requiresRestart: result.requiresRestart,
+        },
+    };
+}

package/packages/typescript/src/features/plugin-manager/actions/plugin-handlers/list-ejected.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @module features/plugin-manager/actions/plugin-handlers/list-ejected
+ *
+ * `list_ejected` sub-mode of the unified PLUGIN action. Lists plugins
+ * currently ejected to the local managed directory.
+ */
+import type { ActionResult, HandlerCallback } from "../../../../types/components.ts";
+import type { IAgentRuntime } from "../../../../types/runtime.ts";
+export interface ListEjectedInput {
+    runtime: IAgentRuntime;
+    callback?: HandlerCallback;
+}
+export declare function runListEjected({ runtime, callback, }: ListEjectedInput): Promise<ActionResult>;
+//# sourceMappingURL=list-ejected.d.ts.map

package/packages/typescript/src/features/plugin-manager/actions/plugin-handlers/list-ejected.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-ejected.d.ts","sourceRoot":"","sources":["../../../../../../../../../typescript/src/features/plugin-manager/actions/plugin-handlers/list-ejected.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACX,YAAY,EACZ,eAAe,EACf,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAGlE,MAAM,WAAW,gBAAgB;IAChC,OAAO,EAAE,aAAa,CAAC;IACvB,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC3B;AAED,wBAAsB,cAAc,CAAC,EACpC,OAAO,EACP,QAAQ,GACR,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CA6B1C"}