@agentmemory/agentmemory 0.7.0 → 0.7.3

package/src/viewer/server.ts

@@ -1,207 +0,0 @@
-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

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

package/test/actions.test.ts

@@ -1,490 +0,0 @@
-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");
-    });
-  });
-});