@elizaos/autonomous 2.0.0-alpha.10

package/test/api/permissions-routes.test.ts

@@ -0,0 +1,185 @@
+import { describe, test, expect, vi } from "vitest";
+import {
+  createMockIncomingMessage,
+  createMockHttpResponse,
+} from "../../src/test-support/test-helpers";
+import { handlePermissionRoutes } from "../../src/api/permissions-routes";
+import type { PermissionRouteContext } from "../../src/api/permissions-routes";
+
+function buildCtx(
+  method: string,
+  pathname: string,
+  overrides?: Partial<PermissionRouteContext>,
+): PermissionRouteContext {
+  const { res } = createMockHttpResponse();
+  return {
+    req: createMockIncomingMessage({ method, url: pathname }),
+    res,
+    method,
+    pathname,
+    json: vi.fn((r, data, status = 200) => {
+      r.writeHead(status);
+      r.end(JSON.stringify(data));
+    }),
+    error: vi.fn((r, msg, status = 500) => {
+      r.writeHead(status);
+      r.end(JSON.stringify({ error: msg }));
+    }),
+    readJsonBody: vi.fn(async () => ({})),
+    state: {
+      runtime: null,
+      config: { features: { shellEnabled: false } },
+      permissionStates: {},
+      shellEnabled: false,
+    },
+    saveConfig: vi.fn(),
+    scheduleRuntimeRestart: vi.fn(),
+    ...overrides,
+  } as PermissionRouteContext;
+}
+
+describe("permissions-routes", () => {
+  describe("GET /api/permissions", () => {
+    test("returns permission states with platform", async () => {
+      const ctx = buildCtx("GET", "/api/permissions");
+      const handled = await handlePermissionRoutes(ctx);
+      expect(handled).toBe(true);
+      expect(ctx.json).toHaveBeenCalledOnce();
+      const payload = (ctx.json as ReturnType<typeof vi.fn>).mock.calls[0][1];
+      expect(payload).toHaveProperty("_platform");
+      expect(payload).toHaveProperty("_shellEnabled");
+    });
+  });
+
+  describe("GET /api/permissions/shell", () => {
+    test("returns shell permission state", async () => {
+      const ctx = buildCtx("GET", "/api/permissions/shell");
+      const handled = await handlePermissionRoutes(ctx);
+      expect(handled).toBe(true);
+      const payload = (ctx.json as ReturnType<typeof vi.fn>).mock.calls[0][1];
+      expect(payload).toHaveProperty("enabled");
+      expect(payload).toHaveProperty("permission");
+    });
+  });
+
+  describe("GET /api/permissions/:id", () => {
+    test("returns not-applicable for unknown permission", async () => {
+      const ctx = buildCtx("GET", "/api/permissions/camera");
+      const handled = await handlePermissionRoutes(ctx);
+      expect(handled).toBe(true);
+      const payload = (ctx.json as ReturnType<typeof vi.fn>).mock.calls[0][1];
+      expect(payload.status).toBe("not-applicable");
+    });
+
+    test("returns stored state for known permission", async () => {
+      const ctx = buildCtx("GET", "/api/permissions/camera", {
+        state: {
+          runtime: null,
+          config: {},
+          permissionStates: {
+            camera: {
+              id: "camera",
+              status: "granted",
+              lastChecked: Date.now(),
+              canRequest: false,
+            },
+          },
+        },
+      });
+      const handled = await handlePermissionRoutes(ctx);
+      expect(handled).toBe(true);
+      const payload = (ctx.json as ReturnType<typeof vi.fn>).mock.calls[0][1];
+      expect(payload.status).toBe("granted");
+    });
+  });
+
+  describe("PUT /api/permissions/shell", () => {
+    test("enables shell and saves config", async () => {
+      const ctx = buildCtx("PUT", "/api/permissions/shell", {
+        readJsonBody: vi.fn(async () => ({ enabled: true })),
+      });
+      await handlePermissionRoutes(ctx);
+      expect(ctx.saveConfig).toHaveBeenCalled();
+      expect(ctx.state.shellEnabled).toBe(true);
+    });
+
+    test("schedules restart when runtime exists", async () => {
+      const ctx = buildCtx("PUT", "/api/permissions/shell", {
+        readJsonBody: vi.fn(async () => ({ enabled: true })),
+        state: {
+          runtime: {} as any,
+          config: { features: {} },
+          shellEnabled: false,
+        },
+      });
+      await handlePermissionRoutes(ctx);
+      expect(ctx.scheduleRuntimeRestart).toHaveBeenCalled();
+    });
+
+    test("does not schedule restart when no runtime", async () => {
+      const ctx = buildCtx("PUT", "/api/permissions/shell", {
+        readJsonBody: vi.fn(async () => ({ enabled: true })),
+      });
+      await handlePermissionRoutes(ctx);
+      expect(ctx.scheduleRuntimeRestart).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("POST /api/permissions/refresh", () => {
+    test("returns refresh message", async () => {
+      const ctx = buildCtx("POST", "/api/permissions/refresh");
+      const handled = await handlePermissionRoutes(ctx);
+      expect(handled).toBe(true);
+      const payload = (ctx.json as ReturnType<typeof vi.fn>).mock.calls[0][1];
+      expect(payload.action).toBe("ipc:permissions:refresh");
+    });
+  });
+
+  describe("POST /api/permissions/:id/request", () => {
+    test("returns request action", async () => {
+      const ctx = buildCtx("POST", "/api/permissions/camera/request");
+      const handled = await handlePermissionRoutes(ctx);
+      expect(handled).toBe(true);
+      const payload = (ctx.json as ReturnType<typeof vi.fn>).mock.calls[0][1];
+      expect(payload.action).toBe("ipc:permissions:request:camera");
+    });
+  });
+
+  describe("POST /api/permissions/:id/open-settings", () => {
+    test("returns open-settings action", async () => {
+      const ctx = buildCtx("POST", "/api/permissions/microphone/open-settings");
+      const handled = await handlePermissionRoutes(ctx);
+      expect(handled).toBe(true);
+      const payload = (ctx.json as ReturnType<typeof vi.fn>).mock.calls[0][1];
+      expect(payload.action).toBe("ipc:permissions:openSettings:microphone");
+    });
+  });
+
+  describe("PUT /api/permissions/state", () => {
+    test("updates permission states", async () => {
+      const ctx = buildCtx("PUT", "/api/permissions/state", {
+        readJsonBody: vi.fn(async () => ({
+          permissions: {
+            camera: {
+              id: "camera",
+              status: "granted",
+              lastChecked: Date.now(),
+              canRequest: false,
+            },
+          },
+        })),
+      });
+      const handled = await handlePermissionRoutes(ctx);
+      expect(handled).toBe(true);
+      const payload = (ctx.json as ReturnType<typeof vi.fn>).mock.calls[0][1];
+      expect(payload.updated).toBe(true);
+    });
+  });
+
+  describe("routing", () => {
+    test("unrelated path returns false", async () => {
+      const ctx = buildCtx("GET", "/api/other");
+      expect(await handlePermissionRoutes(ctx)).toBe(false);
+    });
+  });
+});

package/test/api/registry-routes.test.ts

@@ -0,0 +1,157 @@
+import { describe, test, expect, vi } from "vitest";
+import {
+  createMockIncomingMessage,
+  createMockHttpResponse,
+} from "../../src/test-support/test-helpers";
+import { handleRegistryRoutes } from "../../src/api/registry-routes";
+import type { RegistryRouteContext } from "../../src/api/registry-routes";
+
+function buildCtx(
+  method: string,
+  pathname: string,
+  overrides?: Partial<RegistryRouteContext>,
+): RegistryRouteContext & { getStatus: () => number; getJson: () => unknown } {
+  const { res, getStatus, getJson } = createMockHttpResponse();
+  const urlString = `http://localhost:2138${pathname}`;
+  const req = createMockIncomingMessage({ method, url: pathname });
+  const ctx = {
+    req,
+    res,
+    method,
+    pathname,
+    url: new URL(urlString),
+    json: vi.fn((r, data, status = 200) => {
+      r.writeHead(status);
+      r.end(JSON.stringify(data));
+    }),
+    error: vi.fn((r, msg, status = 500) => {
+      r.writeHead(status);
+      r.end(JSON.stringify({ error: msg }));
+    }),
+    getPluginManager: () => ({
+      refreshRegistry: vi.fn(async () => new Map()),
+      listInstalledPlugins: vi.fn(async () => []),
+      getRegistryPlugin: vi.fn(async () => null),
+      searchRegistry: vi.fn(async () => []),
+    }),
+    getLoadedPluginNames: () => [],
+    getBundledPluginIds: () => new Set<string>(),
+    classifyRegistryPluginRelease: () => "compatible",
+    ...overrides,
+  } as RegistryRouteContext & {
+    getStatus: () => number;
+    getJson: () => unknown;
+  };
+  (ctx as any).getStatus = getStatus;
+  (ctx as any).getJson = getJson;
+  return ctx;
+}
+
+describe("registry-routes", () => {
+  describe("GET /api/registry/plugins", () => {
+    test("returns empty plugin list from empty registry", async () => {
+      const ctx = buildCtx("GET", "/api/registry/plugins");
+      const handled = await handleRegistryRoutes(ctx);
+      expect(handled).toBe(true);
+      expect(ctx.json).toHaveBeenCalledOnce();
+      const payload = (ctx.json as ReturnType<typeof vi.fn>).mock.calls[0][1];
+      expect(payload.count).toBe(0);
+      expect(payload.plugins).toEqual([]);
+    });
+
+    test("returns plugins with installed/loaded/bundled flags", async () => {
+      const registry = new Map([
+        [
+          "@elizaos/plugin-foo",
+          { name: "@elizaos/plugin-foo", kind: "plugin" },
+        ],
+      ]);
+      const pluginManager = {
+        refreshRegistry: vi.fn(async () => registry),
+        listInstalledPlugins: vi.fn(async () => [
+          { name: "@elizaos/plugin-foo", version: "1.0.0" },
+        ]),
+        getRegistryPlugin: vi.fn(async () => null),
+        searchRegistry: vi.fn(async () => []),
+      };
+      const ctx = buildCtx("GET", "/api/registry/plugins", {
+        getPluginManager: () => pluginManager,
+        getLoadedPluginNames: () => ["@elizaos/plugin-foo"],
+        getBundledPluginIds: () => new Set(["foo"]),
+      });
+      const handled = await handleRegistryRoutes(ctx);
+      expect(handled).toBe(true);
+      const payload = (ctx.json as ReturnType<typeof vi.fn>).mock.calls[0][1];
+      expect(payload.count).toBe(1);
+      expect(payload.plugins[0].installed).toBe(true);
+      expect(payload.plugins[0].loaded).toBe(true);
+      expect(payload.plugins[0].bundled).toBe(true);
+    });
+
+    test("returns 502 when registry refresh throws", async () => {
+      const pluginManager = {
+        refreshRegistry: vi.fn(async () => {
+          throw new Error("network error");
+        }),
+        listInstalledPlugins: vi.fn(async () => []),
+        getRegistryPlugin: vi.fn(async () => null),
+        searchRegistry: vi.fn(async () => []),
+      };
+      const ctx = buildCtx("GET", "/api/registry/plugins", {
+        getPluginManager: () => pluginManager,
+      });
+      const handled = await handleRegistryRoutes(ctx);
+      expect(handled).toBe(true);
+      expect(ctx.error).toHaveBeenCalledOnce();
+      const args = (ctx.error as ReturnType<typeof vi.fn>).mock.calls[0];
+      expect(args[2]).toBe(502);
+      expect(args[1]).toContain("network error");
+    });
+  });
+
+  describe("GET /api/registry/search", () => {
+    test("returns 400 when query parameter is empty", async () => {
+      const ctx = buildCtx("GET", "/api/registry/search");
+      const handled = await handleRegistryRoutes(ctx);
+      expect(handled).toBe(true);
+      expect(ctx.error).toHaveBeenCalledOnce();
+      const args = (ctx.error as ReturnType<typeof vi.fn>).mock.calls[0];
+      expect(args[2]).toBe(400);
+      expect(args[1]).toContain("'q' is required");
+    });
+
+    test("returns results when query is provided", async () => {
+      const searchResults = [{ name: "@elizaos/plugin-foo" }];
+      const pluginManager = {
+        refreshRegistry: vi.fn(async () => new Map()),
+        listInstalledPlugins: vi.fn(async () => []),
+        getRegistryPlugin: vi.fn(async () => null),
+        searchRegistry: vi.fn(async () => searchResults),
+      };
+      const ctx = buildCtx("GET", "/api/registry/search?q=foo", {
+        getPluginManager: () => pluginManager,
+        url: new URL("http://localhost:2138/api/registry/search?q=foo"),
+      });
+      ctx.pathname = "/api/registry/search";
+      const handled = await handleRegistryRoutes(ctx);
+      expect(handled).toBe(true);
+      expect(ctx.json).toHaveBeenCalledOnce();
+      const payload = (ctx.json as ReturnType<typeof vi.fn>).mock.calls[0][1];
+      expect(payload.query).toBe("foo");
+      expect(payload.count).toBe(1);
+      expect(payload.results).toEqual(searchResults);
+    });
+  });
+
+  describe("routing", () => {
+    test("unrelated path returns false", async () => {
+      const ctx = buildCtx("GET", "/api/other");
+      expect(await handleRegistryRoutes(ctx)).toBe(false);
+    });
+
+    test("POST to /api/registry/plugins returns false (wrong method)", async () => {
+      const ctx = buildCtx("POST", "/api/registry/plugins");
+      expect(await handleRegistryRoutes(ctx)).toBe(false);
+    });
+  });
+});

package/test/api/signal-routes.test.ts

@@ -0,0 +1,113 @@
+import { describe, test, expect, vi } from "vitest";
+import {
+  createMockIncomingMessage,
+  createMockHttpResponse,
+} from "../../src/test-support/test-helpers";
+import type {
+  SignalRouteState,
+  SignalRouteDeps,
+} from "../../src/api/signal-routes";
+import { handleSignalRoute } from "../../src/api/signal-routes";
+
+function buildState(
+  overrides: Partial<SignalRouteState> = {},
+): SignalRouteState {
+  return {
+    signalPairingSessions: new Map(),
+    broadcastWs: vi.fn(),
+    config: {},
+    runtime: undefined,
+    saveConfig: vi.fn(),
+    workspaceDir: "/tmp/test-workspace",
+    ...overrides,
+  };
+}
+
+function buildDeps(overrides: Partial<SignalRouteDeps> = {}): SignalRouteDeps {
+  return {
+    sanitizeAccountId: vi.fn((id: string) => id),
+    signalAuthExists: vi.fn(() => false),
+    signalLogout: vi.fn(),
+    createSignalPairingSession: vi.fn(() => ({
+      start: vi.fn(async () => {}),
+      stop: vi.fn(),
+      getStatus: vi.fn(() => "pairing"),
+    })),
+    ...overrides,
+  };
+}
+
+describe("handleSignalRoute", () => {
+  test("returns false for unrelated path", async () => {
+    const req = createMockIncomingMessage({ method: "GET", url: "/api/other" });
+    const { res } = createMockHttpResponse();
+    const state = buildState();
+    const deps = buildDeps();
+
+    const handled = await handleSignalRoute(
+      req,
+      res,
+      "/api/other",
+      "GET",
+      state,
+      deps,
+    );
+
+    expect(handled).toBe(false);
+  });
+
+  test("POST /api/signal/pair creates a pairing session", async () => {
+    const req = createMockIncomingMessage({
+      method: "POST",
+      url: "/api/signal/pair",
+      body: JSON.stringify({ accountId: "test-account" }),
+      headers: { host: "localhost:2138", "content-type": "application/json" },
+    });
+    const { res, getStatus, getJson } = createMockHttpResponse();
+    const state = buildState();
+    const deps = buildDeps();
+
+    const handled = await handleSignalRoute(
+      req,
+      res,
+      "/api/signal/pair",
+      "POST",
+      state,
+      deps,
+    );
+
+    expect(handled).toBe(true);
+    expect(getStatus()).toBe(200);
+    const json = getJson<{ ok: boolean; accountId: string }>();
+    expect(json.ok).toBe(true);
+  });
+
+  test("POST /api/signal/pair returns 400 when sanitizeAccountId throws", async () => {
+    const req = createMockIncomingMessage({
+      method: "POST",
+      url: "/api/signal/pair",
+      body: JSON.stringify({ accountId: "" }),
+      headers: { host: "localhost:2138", "content-type": "application/json" },
+    });
+    const { res, getStatus, getJson } = createMockHttpResponse();
+    const state = buildState();
+    const deps = buildDeps({
+      sanitizeAccountId: vi.fn(() => {
+        throw new Error("Invalid account ID");
+      }),
+    });
+
+    const handled = await handleSignalRoute(
+      req,
+      res,
+      "/api/signal/pair",
+      "POST",
+      state,
+      deps,
+    );
+
+    expect(handled).toBe(true);
+    expect(getStatus()).toBe(400);
+    expect(getJson<{ error: string }>().error).toBe("Invalid account ID");
+  });
+});

package/test/api/subscription-routes.test.ts

@@ -0,0 +1,90 @@
+import { describe, test, expect, vi } from "vitest";
+import {
+  createMockIncomingMessage,
+  createMockHttpResponse,
+} from "../../src/test-support/test-helpers";
+import type { SubscriptionRouteContext } from "../../src/api/subscription-routes";
+import { handleSubscriptionRoutes } from "../../src/api/subscription-routes";
+
+function buildCtx(
+  overrides: Partial<SubscriptionRouteContext> = {},
+): SubscriptionRouteContext {
+  const { res } = createMockHttpResponse();
+  return {
+    req: createMockIncomingMessage({ method: "GET", url: "/" }),
+    res,
+    method: "GET",
+    pathname: "/",
+    json: vi.fn((r, data, status = 200) => {
+      r.writeHead(status);
+      r.end(JSON.stringify(data));
+    }),
+    error: vi.fn((r, message, status = 500) => {
+      r.writeHead(status);
+      r.end(JSON.stringify({ error: message }));
+    }),
+    readJsonBody: vi.fn(async () => null),
+    state: {
+      config: {},
+    },
+    saveConfig: vi.fn(),
+    loadSubscriptionAuth: vi.fn(async () => ({
+      getSubscriptionStatus: vi.fn(() => ({ anthropic: "active" })),
+      startAnthropicLogin: vi.fn(),
+      startCodexLogin: vi.fn(),
+      saveCredentials: vi.fn(),
+      applySubscriptionCredentials: vi.fn(),
+      deleteCredentials: vi.fn(),
+    })),
+    ...overrides,
+  };
+}
+
+describe("handleSubscriptionRoutes", () => {
+  test("returns false for unrelated path", async () => {
+    const ctx = buildCtx({ pathname: "/api/other" });
+    const handled = await handleSubscriptionRoutes(ctx);
+    expect(handled).toBe(false);
+  });
+
+  test("GET /api/subscription/status returns provider status", async () => {
+    const { res, getStatus, getJson } = createMockHttpResponse();
+    const providerStatuses = { anthropic: "active", openai: "inactive" };
+    const ctx = buildCtx({
+      method: "GET",
+      pathname: "/api/subscription/status",
+      res,
+      loadSubscriptionAuth: vi.fn(async () => ({
+        getSubscriptionStatus: vi.fn(() => providerStatuses),
+        startAnthropicLogin: vi.fn(),
+        startCodexLogin: vi.fn(),
+        saveCredentials: vi.fn(),
+        applySubscriptionCredentials: vi.fn(),
+        deleteCredentials: vi.fn(),
+      })),
+    });
+
+    const handled = await handleSubscriptionRoutes(ctx);
+
+    expect(handled).toBe(true);
+    expect(getStatus()).toBe(200);
+    expect(getJson()).toEqual({ providers: providerStatuses });
+  });
+
+  test("GET /api/subscription/status returns 500 when loadSubscriptionAuth throws", async () => {
+    const { res, getStatus } = createMockHttpResponse();
+    const ctx = buildCtx({
+      method: "GET",
+      pathname: "/api/subscription/status",
+      res,
+      loadSubscriptionAuth: vi.fn(async () => {
+        throw new Error("auth module unavailable");
+      }),
+    });
+
+    const handled = await handleSubscriptionRoutes(ctx);
+
+    expect(handled).toBe(true);
+    expect(getStatus()).toBe(500);
+  });
+});

package/test/api/trigger-routes.test.ts

@@ -0,0 +1,87 @@
+import { describe, test, expect, vi } from "vitest";
+import {
+  createMockIncomingMessage,
+  createMockHttpResponse,
+} from "../../src/test-support/test-helpers";
+import type { TriggerRouteContext } from "../../src/api/trigger-routes";
+import { handleTriggerRoutes } from "../../src/api/trigger-routes";
+
+function buildCtx(
+  overrides: Partial<TriggerRouteContext> = {},
+): TriggerRouteContext {
+  const { res } = createMockHttpResponse();
+  return {
+    req: createMockIncomingMessage({ method: "GET", url: "/" }),
+    res,
+    method: "GET",
+    pathname: "/",
+    json: vi.fn((r, data, status = 200) => {
+      r.writeHead(status);
+      r.end(JSON.stringify(data));
+    }),
+    error: vi.fn((r, message, status = 500) => {
+      r.writeHead(status);
+      r.end(JSON.stringify({ error: message }));
+    }),
+    readJsonBody: vi.fn(async () => null),
+    runtime: null,
+    executeTriggerTask: vi.fn(),
+    getTriggerHealthSnapshot: vi.fn(async () => ({ healthy: true })),
+    getTriggerLimit: vi.fn(() => 10),
+    listTriggerTasks: vi.fn(async () => []),
+    readTriggerConfig: vi.fn(() => null),
+    readTriggerRuns: vi.fn(() => []),
+    taskToTriggerSummary: vi.fn(() => null),
+    triggersFeatureEnabled: vi.fn(() => true),
+    buildTriggerConfig: vi.fn(),
+    buildTriggerMetadata: vi.fn(() => null),
+    normalizeTriggerDraft: vi.fn(() => ({ draft: undefined, error: "noop" })),
+    DISABLED_TRIGGER_INTERVAL_MS: 86_400_000,
+    TRIGGER_TASK_NAME: "trigger",
+    TRIGGER_TASK_TAGS: ["trigger"],
+    ...overrides,
+  };
+}
+
+describe("handleTriggerRoutes", () => {
+  test("returns false for unrelated path", async () => {
+    const ctx = buildCtx({ pathname: "/api/other" });
+    const handled = await handleTriggerRoutes(ctx);
+    expect(handled).toBe(false);
+  });
+
+  test("returns 503 when runtime is null", async () => {
+    const { res, getStatus, getJson } = createMockHttpResponse();
+    const ctx = buildCtx({
+      method: "GET",
+      pathname: "/api/triggers",
+      res,
+      runtime: null,
+    });
+
+    const handled = await handleTriggerRoutes(ctx);
+
+    expect(handled).toBe(true);
+    expect(getStatus()).toBe(503);
+    expect(getJson()).toEqual({ error: "Agent is not running" });
+  });
+
+  test("GET /api/triggers/health returns snapshot even without runtime features enabled", async () => {
+    const { res, getStatus, getJson } = createMockHttpResponse();
+    const snapshot = { healthy: true, triggers: 0 };
+    const ctx = buildCtx({
+      method: "GET",
+      pathname: "/api/triggers/health",
+      res,
+      runtime: {} as TriggerRouteContext["runtime"],
+      triggersFeatureEnabled: vi.fn(() => false),
+      getTriggerHealthSnapshot: vi.fn(async () => snapshot),
+    });
+
+    const handled = await handleTriggerRoutes(ctx);
+
+    expect(handled).toBe(true);
+    expect(getStatus()).toBe(200);
+    expect(getJson()).toEqual(snapshot);
+  });
+});