@elizaos/agent 2.0.0-alpha.97 → 2.0.0-beta.1

package/dist/packages/agent/src/api/misc-routes.js

@@ -0,0 +1,565 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import crypto from "node:crypto";
+import { composePrompt, customActionGenerateTemplate, ModelType, } from "@elizaos/core";
+import { asRecord } from "@elizaos/shared";
+import { loadElizaConfig, saveElizaConfig } from "../config/config.js";
+import { buildTestHandler, registerCustomActionLive, } from "../runtime/custom-actions.js";
+import { resolveTerminalRunLimits } from "./terminal-run-limits.js";
+const COMPANION_EMOTES_MODULE = "@elizaos/app-companion";
+let companionEmotesPromise = null;
+async function loadCompanionEmotes() {
+    companionEmotesPromise ??= import(__rewriteRelativeImportExtension(/* @vite-ignore */ COMPANION_EMOTES_MODULE))
+        .then((loaded) => {
+        const catalog = Array.isArray(loaded.EMOTE_CATALOG)
+            ? loaded.EMOTE_CATALOG
+            : [];
+        const byId = loaded.EMOTE_BY_ID instanceof Map
+            ? loaded.EMOTE_BY_ID
+            : new Map(catalog.map((emote) => [emote.id, emote]));
+        return { catalog, byId };
+    })
+        .catch(() => ({ catalog: [], byId: new Map() }));
+    return companionEmotesPromise;
+}
+function toTerminalRunRequestBody(body) {
+    return {
+        command: typeof body.command === "string" ? body.command : undefined,
+        clientId: body.clientId,
+        terminalToken: typeof body.terminalToken === "string" ? body.terminalToken : undefined,
+    };
+}
+function isCustomActionHandler(value) {
+    const handler = asRecord(value);
+    if (!handler || typeof handler.type !== "string") {
+        return false;
+    }
+    if (handler.type === "http") {
+        return (typeof handler.method === "string" &&
+            typeof handler.url === "string" &&
+            (handler.headers === undefined || asRecord(handler.headers) !== null) &&
+            (handler.bodyTemplate === undefined ||
+                typeof handler.bodyTemplate === "string"));
+    }
+    if (handler.type === "shell") {
+        return typeof handler.command === "string";
+    }
+    if (handler.type === "code") {
+        return typeof handler.code === "string";
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Route handler
+// ---------------------------------------------------------------------------
+export async function handleMiscRoutes(ctx) {
+    const { req, res, method, pathname, url, state, json, error, readJsonBody } = ctx;
+    // ── POST /api/restart ───────────────────────────────────────────────
+    if (method === "POST" && pathname === "/api/restart") {
+        state.agentState = "restarting";
+        state.startup = {
+            ...state.startup,
+            phase: "restarting",
+        };
+        state.broadcastStatus?.();
+        json(res, { ok: true, message: "Restarting...", restarting: true });
+        setTimeout(() => process.exit(0), 1000);
+        return true;
+    }
+    // ── POST /api/ingest/share ───────────────────────────────────────────
+    if (method === "POST" && pathname === "/api/ingest/share") {
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        const item = {
+            id: crypto.randomUUID(),
+            source: body.source ?? "unknown",
+            title: body.title,
+            url: body.url,
+            text: body.text,
+            suggestedPrompt: body.title
+                ? `What do you think about "${body.title}"?`
+                : body.url
+                    ? `Can you analyze this: ${body.url}`
+                    : body.text
+                        ? `What are your thoughts on: ${body.text.slice(0, 100)}`
+                        : "What do you think about this shared content?",
+            receivedAt: Date.now(),
+        };
+        state.shareIngestQueue.push(item);
+        json(res, { ok: true, item });
+        return true;
+    }
+    // ── GET /api/ingest/share ────────────────────────────────────────────
+    if (method === "GET" && pathname === "/api/ingest/share") {
+        const consume = url.searchParams.get("consume") === "1";
+        if (consume) {
+            const items = [...state.shareIngestQueue];
+            state.shareIngestQueue.length = 0;
+            json(res, { items });
+        }
+        else {
+            json(res, { items: state.shareIngestQueue });
+        }
+        return true;
+    }
+    // ── GET /api/emotes ──────────────────────────────────────────────────
+    if (method === "GET" && pathname === "/api/emotes") {
+        const emotes = await loadCompanionEmotes();
+        json(res, { emotes: emotes.catalog });
+        return true;
+    }
+    // ── POST /api/emote ─────────────────────────────────────────────────
+    if (method === "POST" && pathname === "/api/emote") {
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        const emotes = await loadCompanionEmotes();
+        const emote = body.emoteId ? emotes.byId.get(body.emoteId) : undefined;
+        if (!emote) {
+            error(res, `Unknown emote: ${body.emoteId ?? "(none)"}`);
+            return true;
+        }
+        state.broadcastWs?.({
+            type: "emote",
+            emoteId: emote.id,
+            path: emote.path,
+            duration: emote.duration,
+            loop: false,
+        });
+        json(res, { ok: true });
+        return true;
+    }
+    // ── POST /api/agent/event ──────────────────────────────────────────────
+    if (method === "POST" && pathname === "/api/agent/event") {
+        const body = await readJsonBody(req, res);
+        if (!body?.stream) {
+            error(res, "Missing 'stream' field");
+            return true;
+        }
+        if (!ctx.AGENT_EVENT_ALLOWED_STREAMS.has(body.stream)) {
+            error(res, `Invalid stream: ${body.stream}. Allowed: ${[...ctx.AGENT_EVENT_ALLOWED_STREAMS].join(", ")}`, 400);
+            return true;
+        }
+        const envelope = {
+            type: "agent_event",
+            version: 1,
+            eventId: `evt-${state.nextEventId}`,
+            ts: Date.now(),
+            stream: body.stream,
+            agentId: state.runtime?.agentId
+                ? String(state.runtime.agentId)
+                : undefined,
+            roomId: body.roomId,
+            payload: body.data ?? {},
+        };
+        state.nextEventId += 1;
+        state.eventBuffer.push(envelope);
+        if (state.eventBuffer.length > 1500) {
+            state.eventBuffer.splice(0, state.eventBuffer.length - 1500);
+        }
+        state.broadcastWs?.({ ...envelope });
+        json(res, { ok: true });
+        return true;
+    }
+    // ── POST /api/terminal/run ──────────────────────────────────────────
+    if (method === "POST" && pathname === "/api/terminal/run") {
+        if (state.shellEnabled === false) {
+            error(res, "Shell access is disabled", 403);
+            return true;
+        }
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        const terminalRejection = ctx.resolveTerminalRunRejection(req, body);
+        if (terminalRejection) {
+            error(res, terminalRejection.reason, terminalRejection.status);
+            return true;
+        }
+        const command = typeof body.command === "string" ? body.command.trim() : "";
+        if (!command) {
+            error(res, "Missing or empty command");
+            return true;
+        }
+        if (command.length > 4096) {
+            error(res, "Command exceeds maximum length (4096 chars)", 400);
+            return true;
+        }
+        if (command.includes("\n") ||
+            command.includes("\r") ||
+            command.includes("\0")) {
+            error(res, "Command must be a single line without control characters", 400);
+            return true;
+        }
+        const targetClientId = ctx.resolveTerminalRunClientId(req, body);
+        if (!targetClientId) {
+            error(res, "Missing client id. Provide X-Eliza-Client-Id header or clientId in the request body.", 400);
+            return true;
+        }
+        const emitTerminalEvent = (payload) => {
+            if (ctx.isSharedTerminalClientId(targetClientId)) {
+                state.broadcastWs?.(payload);
+                return;
+            }
+            if (typeof state.broadcastWsToClientId !== "function")
+                return;
+            state.broadcastWsToClientId(targetClientId, payload);
+        };
+        const { maxConcurrent, maxDurationMs } = resolveTerminalRunLimits();
+        if (ctx.activeTerminalRunCount >= maxConcurrent) {
+            error(res, `Too many active terminal runs (${maxConcurrent}). Wait for a command to finish.`, 429);
+            return true;
+        }
+        const captureOutput = body.captureOutput === true;
+        const MAX_CAPTURE_BYTES = 128 * 1024;
+        if (!captureOutput) {
+            json(res, { ok: true });
+        }
+        const { spawn } = await import("node:child_process");
+        const runId = `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        emitTerminalEvent({
+            type: "terminal-output",
+            runId,
+            event: "start",
+            command,
+            maxDurationMs,
+        });
+        const proc = spawn(command, {
+            shell: true,
+            cwd: process.cwd(),
+            env: { ...process.env, FORCE_COLOR: "0" },
+        });
+        ctx.setActiveTerminalRunCount(1);
+        let finalized = false;
+        let timedOut = false;
+        let stdout = "";
+        let stderr = "";
+        let truncated = false;
+        const appendOutput = (current, chunkText) => {
+            if (!captureOutput || truncated || !chunkText) {
+                return current;
+            }
+            const remaining = MAX_CAPTURE_BYTES - Buffer.byteLength(current, "utf8");
+            if (remaining <= 0) {
+                truncated = true;
+                return current;
+            }
+            const chunkBytes = Buffer.byteLength(chunkText, "utf8");
+            if (chunkBytes <= remaining) {
+                return current + chunkText;
+            }
+            truncated = true;
+            return (current +
+                Buffer.from(chunkText, "utf8").subarray(0, remaining).toString("utf8"));
+        };
+        const finalize = () => {
+            if (finalized)
+                return;
+            finalized = true;
+            ctx.setActiveTerminalRunCount(-1);
+            clearTimeout(timeoutHandle);
+        };
+        const timeoutHandle = setTimeout(() => {
+            if (proc.killed)
+                return;
+            timedOut = true;
+            proc.kill("SIGTERM");
+            emitTerminalEvent({
+                type: "terminal-output",
+                runId,
+                event: "timeout",
+                maxDurationMs,
+            });
+            setTimeout(() => {
+                if (!proc.killed)
+                    proc.kill("SIGKILL");
+            }, 3000);
+        }, maxDurationMs);
+        proc.stdout?.on("data", (chunk) => {
+            const text = chunk.toString("utf-8");
+            stdout = appendOutput(stdout, text);
+            emitTerminalEvent({
+                type: "terminal-output",
+                runId,
+                event: "stdout",
+                data: text,
+            });
+        });
+        proc.stderr?.on("data", (chunk) => {
+            const text = chunk.toString("utf-8");
+            stderr = appendOutput(stderr, text);
+            emitTerminalEvent({
+                type: "terminal-output",
+                runId,
+                event: "stderr",
+                data: text,
+            });
+        });
+        proc.on("close", (code) => {
+            finalize();
+            emitTerminalEvent({
+                type: "terminal-output",
+                runId,
+                event: "exit",
+                code: code ?? 1,
+            });
+            if (captureOutput) {
+                json(res, {
+                    ok: true,
+                    runId,
+                    command,
+                    exitCode: code ?? 1,
+                    stdout,
+                    stderr,
+                    timedOut,
+                    truncated,
+                    maxDurationMs,
+                });
+            }
+        });
+        proc.on("error", (err) => {
+            finalize();
+            emitTerminalEvent({
+                type: "terminal-output",
+                runId,
+                event: "error",
+                data: err.message,
+            });
+            if (captureOutput) {
+                error(res, err.message, 500);
+            }
+        });
+        return true;
+    }
+    // ── Custom Actions CRUD ──────────────────────────────────────────────
+    if (method === "GET" && pathname === "/api/custom-actions") {
+        const config = loadElizaConfig();
+        json(res, { actions: config.customActions ?? [] });
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/custom-actions") {
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        const name = typeof body.name === "string" ? body.name.trim() : "";
+        const description = typeof body.description === "string" ? body.description.trim() : "";
+        if (!name || !description) {
+            error(res, "name and description are required", 400);
+            return true;
+        }
+        const handler = body.handler;
+        const validHandlerTypes = new Set(["http", "shell", "code"]);
+        if (!handler?.type || !validHandlerTypes.has(handler.type)) {
+            error(res, "handler with valid type (http, shell, code) is required", 400);
+            return true;
+        }
+        if (handler.type === "shell" || handler.type === "code") {
+            const terminalRejection = ctx.resolveTerminalRunRejection(req, toTerminalRunRequestBody(body));
+            if (terminalRejection) {
+                error(res, `Creating ${handler.type} actions requires terminal authorization. ${terminalRejection.reason}`, terminalRejection.status);
+                return true;
+            }
+        }
+        if (handler.type === "http" &&
+            (typeof handler.url !== "string" || !handler.url.trim())) {
+            error(res, "HTTP handler requires a url", 400);
+            return true;
+        }
+        if (handler.type === "shell" &&
+            (typeof handler.command !== "string" || !handler.command.trim())) {
+            error(res, "Shell handler requires a command", 400);
+            return true;
+        }
+        if (handler.type === "code" &&
+            (typeof handler.code !== "string" || !handler.code.trim())) {
+            error(res, "Code handler requires code", 400);
+            return true;
+        }
+        const now = new Date().toISOString();
+        const actionDef = {
+            id: crypto.randomUUID(),
+            name: name.toUpperCase().replace(/\s+/g, "_"),
+            description,
+            similes: Array.isArray(body.similes)
+                ? body.similes.filter((s) => typeof s === "string")
+                : [],
+            parameters: Array.isArray(body.parameters)
+                ? body.parameters
+                : [],
+            handler,
+            enabled: body.enabled !== false,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const config = loadElizaConfig();
+        if (!config.customActions)
+            config.customActions = [];
+        config.customActions.push(actionDef);
+        saveElizaConfig(config);
+        if (actionDef.enabled) {
+            registerCustomActionLive(actionDef);
+        }
+        json(res, { ok: true, action: actionDef });
+        return true;
+    }
+    // Generate a custom action definition from a natural language prompt
+    if (method === "POST" && pathname === "/api/custom-actions/generate") {
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        const prompt = typeof body.prompt === "string" ? body.prompt.trim() : "";
+        if (!prompt) {
+            error(res, "prompt is required", 400);
+            return true;
+        }
+        const runtime = state.runtime;
+        if (!runtime) {
+            error(res, "Agent runtime not available", 503);
+            return true;
+        }
+        try {
+            const composedPrompt = composePrompt({
+                state: { request: prompt },
+                template: customActionGenerateTemplate,
+            });
+            const llmResponse = await runtime.useModel(ModelType.TEXT_SMALL, {
+                prompt: composedPrompt,
+            });
+            const text = typeof llmResponse === "string" ? llmResponse : String(llmResponse);
+            const jsonMatch = text.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                error(res, "Failed to generate action definition", 500);
+                return true;
+            }
+            const generated = JSON.parse(jsonMatch[0]);
+            json(res, { ok: true, generated });
+        }
+        catch (err) {
+            error(res, `Generation failed: ${err instanceof Error ? err.message : String(err)}`, 500);
+        }
+        return true;
+    }
+    const customActionMatch = pathname.match(/^\/api\/custom-actions\/([^/]+)$/);
+    const customActionTestMatch = pathname.match(/^\/api\/custom-actions\/([^/]+)\/test$/);
+    if (method === "POST" && customActionTestMatch) {
+        const actionId = decodeURIComponent(customActionTestMatch[1]);
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        const config = loadElizaConfig();
+        const def = (config.customActions ?? []).find((a) => a.id === actionId);
+        if (!def) {
+            error(res, "Action not found", 404);
+            return true;
+        }
+        if (def.handler.type === "shell" || def.handler.type === "code") {
+            const terminalRejection = ctx.resolveTerminalRunRejection(req, toTerminalRunRequestBody(body));
+            if (terminalRejection) {
+                error(res, `Testing ${def.handler.type} actions requires terminal authorization. ${terminalRejection.reason}`, terminalRejection.status);
+                return true;
+            }
+        }
+        const testParams = body.params ?? {};
+        const start = Date.now();
+        try {
+            const handler = buildTestHandler(def);
+            const result = await handler(testParams);
+            json(res, {
+                ok: result.ok,
+                output: result.output,
+                durationMs: Date.now() - start,
+            });
+        }
+        catch (err) {
+            json(res, {
+                ok: false,
+                output: "",
+                error: err instanceof Error ? err.message : String(err),
+                durationMs: Date.now() - start,
+            });
+        }
+        return true;
+    }
+    if (method === "PUT" && customActionMatch) {
+        const actionId = decodeURIComponent(customActionMatch[1]);
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        const config = loadElizaConfig();
+        const actions = config.customActions ?? [];
+        const idx = actions.findIndex((a) => a.id === actionId);
+        if (idx === -1) {
+            error(res, "Action not found", 404);
+            return true;
+        }
+        const existing = actions[idx];
+        let newHandler = existing.handler;
+        if (body.handler != null) {
+            const h = asRecord(body.handler);
+            const hValidTypes = new Set(["http", "shell", "code"]);
+            if (!h?.type || !hValidTypes.has(String(h.type))) {
+                error(res, "handler.type must be http, shell, or code", 400);
+                return true;
+            }
+            if (!isCustomActionHandler(h)) {
+                error(res, "handler payload is invalid", 400);
+                return true;
+            }
+            newHandler = h;
+        }
+        if (newHandler.type === "shell" || newHandler.type === "code") {
+            const terminalRejection = ctx.resolveTerminalRunRejection(req, toTerminalRunRequestBody(body));
+            if (terminalRejection) {
+                error(res, `Updating to ${newHandler.type} handler requires terminal authorization. ${terminalRejection.reason}`, terminalRejection.status);
+                return true;
+            }
+        }
+        const updated = {
+            ...existing,
+            name: typeof body.name === "string"
+                ? body.name.trim().toUpperCase().replace(/\s+/g, "_")
+                : existing.name,
+            description: typeof body.description === "string"
+                ? body.description.trim()
+                : existing.description,
+            similes: Array.isArray(body.similes)
+                ? body.similes.filter((s) => typeof s === "string")
+                : existing.similes,
+            parameters: Array.isArray(body.parameters)
+                ? body.parameters
+                : existing.parameters,
+            handler: newHandler,
+            enabled: typeof body.enabled === "boolean" ? body.enabled : existing.enabled,
+            updatedAt: new Date().toISOString(),
+        };
+        actions[idx] = updated;
+        config.customActions = actions;
+        saveElizaConfig(config);
+        json(res, { ok: true, action: updated });
+        return true;
+    }
+    if (method === "DELETE" && customActionMatch) {
+        const actionId = decodeURIComponent(customActionMatch[1]);
+        const config = loadElizaConfig();
+        const actions = config.customActions ?? [];
+        const idx = actions.findIndex((a) => a.id === actionId);
+        if (idx === -1) {
+            error(res, "Action not found", 404);
+            return true;
+        }
+        actions.splice(idx, 1);
+        config.customActions = actions;
+        saveElizaConfig(config);
+        json(res, { ok: true });
+        return true;
+    }
+    // Privy wallet routes (/api/privy/*) are now provided by the
+    // @elizaos/app-steward plugin via the runtime route registry.
+    return false;
+}

package/dist/packages/agent/src/api/mobile-optional-routes.d.ts

@@ -0,0 +1,3 @@
+import type http from "node:http";
+export declare function handleMobileOptionalRoutes(req: http.IncomingMessage, res: http.ServerResponse, pathname: string, method: string): Promise<boolean>;
+//# sourceMappingURL=mobile-optional-routes.d.ts.map

package/dist/packages/agent/src/api/mobile-optional-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobile-optional-routes.d.ts","sourceRoot":"","sources":["../../../../../src/api/mobile-optional-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAuBlC,wBAAsB,0BAA0B,CAC9C,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,CAAC,CA0FlB"}

package/dist/packages/agent/src/api/mobile-optional-routes.js

@@ -0,0 +1,91 @@
+import { readRequestBody, sendJson, sendJsonError } from "@elizaos/core";
+import { readStreamSettings, validateStreamSettings, writeStreamSettings, } from "@elizaos/plugin-streaming";
+import { isMobilePlatform } from "@elizaos/shared";
+function mobileLocalCompatibilityEnabled() {
+    return (isMobilePlatform() ||
+        process.env.ELIZA_DEVICE_BRIDGE_ENABLED === "1" ||
+        process.env.ELIZA_MOBILE_LOCAL_AGENT === "1");
+}
+function parseJsonPayload(raw) {
+    if (typeof raw !== "string")
+        return raw;
+    if (raw.trim().length === 0)
+        return {};
+    return JSON.parse(raw);
+}
+export async function handleMobileOptionalRoutes(req, res, pathname, method) {
+    if (!mobileLocalCompatibilityEnabled()) {
+        return false;
+    }
+    if (method === "GET" && pathname === "/api/stream/settings") {
+        sendJson(res, { ok: true, settings: readStreamSettings() });
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/stream/settings") {
+        try {
+            const body = parseJsonPayload(await readRequestBody(req));
+            const result = validateStreamSettings(body?.settings);
+            if (result.error || !result.settings) {
+                sendJsonError(res, result.error ?? "Invalid settings", 400);
+                return true;
+            }
+            const settings = { ...readStreamSettings(), ...result.settings };
+            writeStreamSettings(settings);
+            sendJson(res, { ok: true, settings });
+        }
+        catch (err) {
+            sendJsonError(res, err instanceof Error ? err.message : "Invalid stream settings", 400);
+        }
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/catalog/apps") {
+        sendJson(res, []);
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/drop/status") {
+        sendJson(res, {
+            dropEnabled: false,
+            publicMintOpen: false,
+            whitelistMintOpen: false,
+            mintedOut: false,
+            currentSupply: 0,
+            maxSupply: 2138,
+            shinyPrice: "0.1",
+            userHasMinted: false,
+        });
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/coding-agents/preflight") {
+        sendJson(res, { installed: [], available: false });
+        return true;
+    }
+    if (method === "GET" &&
+        pathname === "/api/coding-agents/coordinator/status") {
+        sendJson(res, {
+            supervisionLevel: "unavailable",
+            taskCount: 0,
+            tasks: [],
+            pendingConfirmations: 0,
+            taskThreadCount: 0,
+            taskThreads: [],
+            frameworks: [],
+        });
+        return true;
+    }
+    if (pathname === "/api/lifeops/activity-signals") {
+        if (method === "GET") {
+            sendJson(res, { signals: [] });
+            return true;
+        }
+        if (method === "POST") {
+            await readRequestBody(req).catch(() => undefined);
+            sendJson(res, {
+                ok: true,
+                stored: false,
+                reason: "lifeops_unavailable_in_mobile_local_mode",
+            });
+            return true;
+        }
+    }
+    return false;
+}