@agentmemory/agentmemory 0.7.0

package/src/viewer/server.ts

@@ -0,0 +1,207 @@
+import {
+  createServer,
+  type Server,
+  type IncomingMessage,
+  type ServerResponse,
+} from "node:http";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { timingSafeCompare, VIEWER_CSP } from "../auth.js";
+
+const ALLOWED_ORIGINS = (
+  process.env.VIEWER_ALLOWED_ORIGINS ||
+  "http://localhost:3111,http://localhost:3113,http://127.0.0.1:3111,http://127.0.0.1:3113"
+)
+  .split(",")
+  .map((o) => o.trim());
+
+function corsHeaders(req: IncomingMessage): Record<string, string> {
+  const origin = req.headers.origin || "";
+  const allowed = ALLOWED_ORIGINS.includes(origin)
+    ? origin
+    : ALLOWED_ORIGINS[0];
+  return {
+    "Access-Control-Allow-Origin": allowed,
+    "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization",
+    Vary: "Origin",
+  };
+}
+
+function json(
+  res: ServerResponse,
+  status: number,
+  data: unknown,
+  req?: IncomingMessage,
+): void {
+  const body = JSON.stringify(data);
+  const cors = req
+    ? corsHeaders(req)
+    : { "Access-Control-Allow-Origin": ALLOWED_ORIGINS[0], Vary: "Origin" };
+  res.writeHead(status, { ...cors, "Content-Type": "application/json" });
+  res.end(body);
+}
+
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    let size = 0;
+    req.on("data", (chunk: Buffer) => {
+      size += chunk.length;
+      if (size > 1_000_000) {
+        req.destroy();
+        reject(new Error("too large"));
+        return;
+      }
+      data += chunk.toString();
+    });
+    req.on("end", () => resolve(data));
+    req.on("error", reject);
+  });
+}
+
+function checkAuth(req: IncomingMessage, secret: string | undefined): boolean {
+  if (!secret) return true;
+  const auth = req.headers["authorization"] || "";
+  return (
+    typeof auth === "string" && timingSafeCompare(auth, `Bearer ${secret}`)
+  );
+}
+
+export function startViewerServer(
+  port: number,
+  _kv: unknown,
+  _sdk: unknown,
+  secret?: string,
+  restPort?: number,
+): Server {
+  const resolvedRestPort = restPort ?? port - 2;
+
+  const server = createServer(async (req, res) => {
+    const raw = req.url || "/";
+    const qIdx = raw.indexOf("?");
+    const pathname = qIdx >= 0 ? raw.slice(0, qIdx) : raw;
+    const qs = qIdx >= 0 ? raw.slice(qIdx + 1) : "";
+    const method = req.method || "GET";
+
+    if (method === "OPTIONS") {
+      res.writeHead(204, {
+        ...corsHeaders(req),
+        "Access-Control-Max-Age": "86400",
+      });
+      res.end();
+      return;
+    }
+
+    if (
+      method === "GET" &&
+      (pathname === "/" ||
+        pathname === "/viewer" ||
+        pathname === "/agentmemory/viewer")
+    ) {
+      const base = dirname(fileURLToPath(import.meta.url));
+      const candidates = [
+        join(base, "..", "src", "viewer", "index.html"),
+        join(base, "..", "viewer", "index.html"),
+        join(base, "viewer", "index.html"),
+      ];
+      for (const p of candidates) {
+        try {
+          const html = readFileSync(p, "utf-8");
+          res.writeHead(200, {
+            "Content-Type": "text/html; charset=utf-8",
+            "Content-Security-Policy": VIEWER_CSP,
+            "Cache-Control": "no-cache",
+          });
+          res.end(html);
+          return;
+        } catch {}
+      }
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("viewer not found");
+      return;
+    }
+
+    if (!checkAuth(req, secret)) {
+      json(res, 401, { error: "unauthorized" }, req);
+      return;
+    }
+
+    try {
+      await proxyToRestApi(resolvedRestPort, pathname, qs, method, req, res, secret);
+    } catch (err) {
+      console.error(`[viewer] proxy error on ${method} ${pathname}:`, err);
+      json(res, 502, { error: "upstream error" }, req);
+    }
+  });
+
+  server.listen(port, "127.0.0.1", () => {
+    console.log(`[agentmemory] Viewer: http://localhost:${port}`);
+  });
+
+  return server;
+}
+
+async function proxyToRestApi(
+  restPort: number,
+  pathname: string,
+  qs: string,
+  method: string,
+  req: IncomingMessage,
+  res: ServerResponse,
+  secret?: string,
+): Promise<void> {
+  const upstreamPath = pathname.startsWith("/agentmemory/")
+    ? pathname
+    : `/agentmemory${pathname.startsWith("/") ? pathname : "/" + pathname}`;
+
+  const upstreamUrl = `http://127.0.0.1:${restPort}${upstreamPath}${qs ? "?" + qs : ""}`;
+
+  const headers: Record<string, string> = {};
+  if (secret) {
+    headers["Authorization"] = `Bearer ${secret}`;
+  }
+  const ct = req.headers["content-type"];
+  if (ct) {
+    headers["Content-Type"] = ct;
+  }
+
+  let body: string | undefined;
+  if (method === "POST" || method === "PUT" || method === "DELETE" || method === "PATCH") {
+    body = await readBody(req);
+  }
+
+  const controller = new AbortController();
+  const fetchTimeout = setTimeout(() => controller.abort(), 10000);
+  let upstream: Response;
+  try {
+    upstream = await fetch(upstreamUrl, {
+      method,
+      headers,
+      body: body || undefined,
+      signal: controller.signal,
+    });
+    clearTimeout(fetchTimeout);
+  } catch (err) {
+    clearTimeout(fetchTimeout);
+    if (err instanceof Error && err.name === "AbortError") {
+      json(res, 504, { error: "upstream timeout" }, req);
+      return;
+    }
+    throw err;
+  }
+
+  const cors = corsHeaders(req);
+  const responseBody = await upstream.text();
+  const responseHeaders: Record<string, string> = {
+    ...cors,
+  };
+  const upstreamCt = upstream.headers.get("content-type");
+  if (upstreamCt) {
+    responseHeaders["Content-Type"] = upstreamCt;
+  }
+
+  res.writeHead(upstream.status, responseHeaders);
+  res.end(responseBody);
+}

package/src/xenova.d.ts

@@ -0,0 +1,3 @@
+declare module "@xenova/transformers" {
+  export function pipeline(task: string, model: string): Promise<any>;
+}

package/test/actions.test.ts

@@ -0,0 +1,490 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("iii-sdk", () => ({
+  getContext: () => ({
+    logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+  }),
+}));
+
+import { registerActionsFunction } from "../src/functions/actions.js";
+import type { Action, ActionEdge } from "../src/types.js";
+
+function mockKV() {
+  const store = new Map<string, Map<string, unknown>>();
+  return {
+    get: async <T>(scope: string, key: string): Promise<T | null> => {
+      return (store.get(scope)?.get(key) as T) ?? null;
+    },
+    set: async <T>(scope: string, key: string, data: T): Promise<T> => {
+      if (!store.has(scope)) store.set(scope, new Map());
+      store.get(scope)!.set(key, data);
+      return data;
+    },
+    delete: async (scope: string, key: string): Promise<void> => {
+      store.get(scope)?.delete(key);
+    },
+    list: async <T>(scope: string): Promise<T[]> => {
+      const entries = store.get(scope);
+      return entries ? (Array.from(entries.values()) as T[]) : [];
+    },
+  };
+}
+
+function mockSdk() {
+  const functions = new Map<string, Function>();
+  return {
+    registerFunction: (opts: { id: string }, handler: Function) => {
+      functions.set(opts.id, handler);
+    },
+    registerTrigger: () => {},
+    trigger: async (id: string, data: unknown) => {
+      const fn = functions.get(id);
+      if (!fn) throw new Error(`No function: ${id}`);
+      return fn(data);
+    },
+  };
+}
+
+describe("Actions Functions", () => {
+  let sdk: ReturnType<typeof mockSdk>;
+  let kv: ReturnType<typeof mockKV>;
+
+  beforeEach(() => {
+    sdk = mockSdk();
+    kv = mockKV();
+    registerActionsFunction(sdk as never, kv as never);
+  });
+
+  describe("mem::action-create", () => {
+    it("creates an action with valid data", async () => {
+      const result = (await sdk.trigger("mem::action-create", {
+        title: "Fix login bug",
+        description: "Users cannot log in with SSO",
+        priority: 7,
+        createdBy: "agent-1",
+        project: "webapp",
+        tags: ["bug", "auth"],
+      })) as { success: boolean; action: Action; edges: ActionEdge[] };
+
+      expect(result.success).toBe(true);
+      expect(result.action.id).toMatch(/^act_/);
+      expect(result.action.title).toBe("Fix login bug");
+      expect(result.action.description).toBe("Users cannot log in with SSO");
+      expect(result.action.status).toBe("pending");
+      expect(result.action.priority).toBe(7);
+      expect(result.action.createdBy).toBe("agent-1");
+      expect(result.action.project).toBe("webapp");
+      expect(result.action.tags).toEqual(["bug", "auth"]);
+      expect(result.action.createdAt).toBeDefined();
+      expect(result.action.updatedAt).toBeDefined();
+      expect(result.edges).toEqual([]);
+    });
+
+    it("returns error when title is missing", async () => {
+      const result = (await sdk.trigger("mem::action-create", {
+        description: "No title provided",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("title is required");
+    });
+
+    it("clamps priority 0 to default 5 (falsy fallback)", async () => {
+      const result = (await sdk.trigger("mem::action-create", {
+        title: "Zero priority task",
+        priority: 0,
+      })) as { success: boolean; action: Action };
+
+      expect(result.success).toBe(true);
+      expect(result.action.priority).toBe(5);
+    });
+
+    it("clamps negative priority to 1", async () => {
+      const result = (await sdk.trigger("mem::action-create", {
+        title: "Negative priority task",
+        priority: -3,
+      })) as { success: boolean; action: Action };
+
+      expect(result.success).toBe(true);
+      expect(result.action.priority).toBe(1);
+    });
+
+    it("clamps priority 15 to 10", async () => {
+      const result = (await sdk.trigger("mem::action-create", {
+        title: "High priority task",
+        priority: 15,
+      })) as { success: boolean; action: Action };
+
+      expect(result.success).toBe(true);
+      expect(result.action.priority).toBe(10);
+    });
+
+    it("validates parent action exists", async () => {
+      const result = (await sdk.trigger("mem::action-create", {
+        title: "Child task",
+        parentId: "nonexistent_parent",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("parent action not found");
+    });
+
+    it("creates action with valid parent", async () => {
+      const parentResult = (await sdk.trigger("mem::action-create", {
+        title: "Parent task",
+      })) as { success: boolean; action: Action };
+
+      const childResult = (await sdk.trigger("mem::action-create", {
+        title: "Child task",
+        parentId: parentResult.action.id,
+      })) as { success: boolean; action: Action };
+
+      expect(childResult.success).toBe(true);
+      expect(childResult.action.parentId).toBe(parentResult.action.id);
+    });
+
+    it("creates inline edges with valid types", async () => {
+      const targetResult = (await sdk.trigger("mem::action-create", {
+        title: "Target action",
+      })) as { success: boolean; action: Action };
+
+      const result = (await sdk.trigger("mem::action-create", {
+        title: "Source action",
+        edges: [
+          { type: "requires", targetActionId: targetResult.action.id },
+          { type: "unlocks", targetActionId: targetResult.action.id },
+        ],
+      })) as { success: boolean; action: Action; edges: ActionEdge[] };
+
+      expect(result.success).toBe(true);
+      expect(result.edges.length).toBe(2);
+      expect(result.edges[0].id).toMatch(/^ae_/);
+      expect(result.edges[0].type).toBe("requires");
+      expect(result.edges[0].sourceActionId).toBe(result.action.id);
+      expect(result.edges[0].targetActionId).toBe(targetResult.action.id);
+      expect(result.edges[1].type).toBe("unlocks");
+    });
+
+    it("returns error for inline edge with invalid type", async () => {
+      const targetResult = (await sdk.trigger("mem::action-create", {
+        title: "Target action",
+      })) as { success: boolean; action: Action };
+
+      const result = (await sdk.trigger("mem::action-create", {
+        title: "Source action",
+        edges: [
+          { type: "invalid_type", targetActionId: targetResult.action.id },
+        ],
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("invalid edge type");
+    });
+
+    it("returns error for inline edge with nonexistent target", async () => {
+      const result = (await sdk.trigger("mem::action-create", {
+        title: "Source action",
+        edges: [{ type: "requires", targetActionId: "nonexistent_id" }],
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("target action not found");
+    });
+  });
+
+  describe("mem::action-update", () => {
+    it("updates an action with valid data", async () => {
+      const createResult = (await sdk.trigger("mem::action-create", {
+        title: "Original title",
+        priority: 5,
+      })) as { success: boolean; action: Action };
+
+      const updateResult = (await sdk.trigger("mem::action-update", {
+        actionId: createResult.action.id,
+        title: "Updated title",
+        priority: 8,
+        status: "active",
+        assignedTo: "agent-2",
+        tags: ["updated"],
+      })) as { success: boolean; action: Action };
+
+      expect(updateResult.success).toBe(true);
+      expect(updateResult.action.title).toBe("Updated title");
+      expect(updateResult.action.priority).toBe(8);
+      expect(updateResult.action.status).toBe("active");
+      expect(updateResult.action.assignedTo).toBe("agent-2");
+      expect(updateResult.action.tags).toEqual(["updated"]);
+    });
+
+    it("returns error when actionId is missing", async () => {
+      const result = (await sdk.trigger("mem::action-update", {
+        title: "no id",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("actionId is required");
+    });
+
+    it("returns error for nonexistent action", async () => {
+      const result = (await sdk.trigger("mem::action-update", {
+        actionId: "nonexistent_id",
+        status: "done",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("action not found");
+    });
+
+    it("propagates completion when status set to done", async () => {
+      const actionB = (await sdk.trigger("mem::action-create", {
+        title: "Dependency B",
+      })) as { success: boolean; action: Action };
+
+      const actionA = (await sdk.trigger("mem::action-create", {
+        title: "Action A depends on B",
+        edges: [{ type: "requires", targetActionId: actionB.action.id }],
+      })) as { success: boolean; action: Action };
+
+      await sdk.trigger("mem::action-update", {
+        actionId: actionA.action.id,
+        status: "blocked",
+      });
+
+      await sdk.trigger("mem::action-update", {
+        actionId: actionB.action.id,
+        status: "done",
+      });
+
+      const getResult = (await sdk.trigger("mem::action-get", {
+        actionId: actionA.action.id,
+      })) as { success: boolean; action: Action };
+
+      expect(getResult.action.status).toBe("pending");
+    });
+  });
+
+  describe("mem::action-edge-create", () => {
+    it("creates an edge between two actions", async () => {
+      const source = (await sdk.trigger("mem::action-create", {
+        title: "Source",
+      })) as { success: boolean; action: Action };
+
+      const target = (await sdk.trigger("mem::action-create", {
+        title: "Target",
+      })) as { success: boolean; action: Action };
+
+      const result = (await sdk.trigger("mem::action-edge-create", {
+        sourceActionId: source.action.id,
+        targetActionId: target.action.id,
+        type: "requires",
+      })) as { success: boolean; edge: ActionEdge };
+
+      expect(result.success).toBe(true);
+      expect(result.edge.id).toMatch(/^ae_/);
+      expect(result.edge.type).toBe("requires");
+      expect(result.edge.sourceActionId).toBe(source.action.id);
+      expect(result.edge.targetActionId).toBe(target.action.id);
+      expect(result.edge.createdAt).toBeDefined();
+    });
+
+    it("returns error when required fields are missing", async () => {
+      const result = (await sdk.trigger("mem::action-edge-create", {
+        sourceActionId: "some_id",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("required");
+    });
+
+    it("returns error for invalid edge type", async () => {
+      const source = (await sdk.trigger("mem::action-create", {
+        title: "Source",
+      })) as { success: boolean; action: Action };
+
+      const target = (await sdk.trigger("mem::action-create", {
+        title: "Target",
+      })) as { success: boolean; action: Action };
+
+      const result = (await sdk.trigger("mem::action-edge-create", {
+        sourceActionId: source.action.id,
+        targetActionId: target.action.id,
+        type: "invalid_type",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("type must be one of");
+    });
+
+    it("returns error for nonexistent source action", async () => {
+      const target = (await sdk.trigger("mem::action-create", {
+        title: "Target",
+      })) as { success: boolean; action: Action };
+
+      const result = (await sdk.trigger("mem::action-edge-create", {
+        sourceActionId: "nonexistent",
+        targetActionId: target.action.id,
+        type: "requires",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("source action not found");
+    });
+
+    it("returns error for nonexistent target action", async () => {
+      const source = (await sdk.trigger("mem::action-create", {
+        title: "Source",
+      })) as { success: boolean; action: Action };
+
+      const result = (await sdk.trigger("mem::action-edge-create", {
+        sourceActionId: source.action.id,
+        targetActionId: "nonexistent",
+        type: "requires",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("target action not found");
+    });
+  });
+
+  describe("mem::action-list", () => {
+    beforeEach(async () => {
+      await sdk.trigger("mem::action-create", {
+        title: "Task A",
+        status: "pending",
+        project: "alpha",
+        tags: ["frontend"],
+      });
+      await new Promise((r) => setTimeout(r, 5));
+      await sdk.trigger("mem::action-create", {
+        title: "Task B",
+        project: "alpha",
+        tags: ["backend"],
+      });
+      await new Promise((r) => setTimeout(r, 5));
+      await sdk.trigger("mem::action-create", {
+        title: "Task C",
+        project: "beta",
+        tags: ["frontend", "backend"],
+      });
+    });
+
+    it("returns all actions", async () => {
+      const result = (await sdk.trigger("mem::action-list", {})) as {
+        success: boolean;
+        actions: Action[];
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.actions.length).toBe(3);
+    });
+
+    it("filters by status", async () => {
+      const all = (await sdk.trigger("mem::action-list", {})) as {
+        actions: Action[];
+      };
+      const firstAction = all.actions[0];
+
+      await sdk.trigger("mem::action-update", {
+        actionId: firstAction.id,
+        status: "done",
+      });
+
+      const result = (await sdk.trigger("mem::action-list", {
+        status: "done",
+      })) as { success: boolean; actions: Action[] };
+
+      expect(result.success).toBe(true);
+      expect(result.actions.length).toBe(1);
+      expect(result.actions[0].status).toBe("done");
+    });
+
+    it("filters by project", async () => {
+      const result = (await sdk.trigger("mem::action-list", {
+        project: "alpha",
+      })) as { success: boolean; actions: Action[] };
+
+      expect(result.success).toBe(true);
+      expect(result.actions.length).toBe(2);
+      expect(result.actions.every((a) => a.project === "alpha")).toBe(true);
+    });
+
+    it("filters by tags", async () => {
+      const result = (await sdk.trigger("mem::action-list", {
+        tags: ["backend"],
+      })) as { success: boolean; actions: Action[] };
+
+      expect(result.success).toBe(true);
+      expect(result.actions.length).toBe(2);
+      expect(
+        result.actions.every((a) => a.tags.includes("backend")),
+      ).toBe(true);
+    });
+
+    it("respects limit", async () => {
+      const result = (await sdk.trigger("mem::action-list", {
+        limit: 2,
+      })) as { success: boolean; actions: Action[] };
+
+      expect(result.success).toBe(true);
+      expect(result.actions.length).toBe(2);
+    });
+  });
+
+  describe("mem::action-get", () => {
+    it("returns action with edges and children", async () => {
+      const parent = (await sdk.trigger("mem::action-create", {
+        title: "Parent",
+      })) as { success: boolean; action: Action };
+
+      const child = (await sdk.trigger("mem::action-create", {
+        title: "Child",
+        parentId: parent.action.id,
+      })) as { success: boolean; action: Action };
+
+      const other = (await sdk.trigger("mem::action-create", {
+        title: "Other",
+      })) as { success: boolean; action: Action };
+
+      await sdk.trigger("mem::action-edge-create", {
+        sourceActionId: parent.action.id,
+        targetActionId: other.action.id,
+        type: "unlocks",
+      });
+
+      const result = (await sdk.trigger("mem::action-get", {
+        actionId: parent.action.id,
+      })) as {
+        success: boolean;
+        action: Action;
+        edges: ActionEdge[];
+        children: Action[];
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.action.id).toBe(parent.action.id);
+      expect(result.edges.length).toBe(1);
+      expect(result.edges[0].type).toBe("unlocks");
+      expect(result.children.length).toBe(1);
+      expect(result.children[0].id).toBe(child.action.id);
+    });
+
+    it("returns error for missing actionId", async () => {
+      const result = (await sdk.trigger("mem::action-get", {})) as {
+        success: boolean;
+        error: string;
+      };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("actionId is required");
+    });
+
+    it("returns error for nonexistent action", async () => {
+      const result = (await sdk.trigger("mem::action-get", {
+        actionId: "nonexistent",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("action not found");
+    });
+  });
+});