@poncho-ai/harness 0.35.0 → 0.36.1

package/test/isolate.test.ts

@@ -0,0 +1,252 @@
+import { describe, expect, it } from "vitest";
+import { createIsolateRuntime } from "../src/isolate/runtime.js";
+import type { IsolateBinding } from "../src/config.js";
+
+const DEFAULT_CONFIG = { memoryLimit: 64, timeout: 5000, outputLimit: 65536 };
+
+describe("IsolateRuntime", () => {
+  it("executes basic JavaScript and returns a result", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const res = await runtime.execute("return 1 + 2;", {}, null);
+
+    expect(res.error).toBeUndefined();
+    expect(res.result).toBe(3);
+    expect(res.executionTimeMs).toBeGreaterThan(0);
+  });
+
+  it("captures console.log output to stdout", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const res = await runtime.execute(
+      `console.log("hello"); console.log("world"); return 42;`,
+      {},
+      null,
+    );
+
+    expect(res.error).toBeUndefined();
+    expect(res.stdout).toBe("hello\nworld");
+    expect(res.result).toBe(42);
+  });
+
+  it("captures console.error/warn to stderr", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const res = await runtime.execute(
+      `console.error("err"); console.warn("warn");`,
+      {},
+      null,
+    );
+
+    expect(res.error).toBeUndefined();
+    expect(res.stderr).toBe("err\nwarn");
+  });
+
+  it("serializes non-string console arguments as JSON", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const res = await runtime.execute(
+      `console.log({ a: 1 }); console.log([1, 2, 3]);`,
+      {},
+      null,
+    );
+
+    expect(res.stdout).toContain('"a": 1');
+    expect(res.stdout).toContain("[");
+  });
+
+  it("returns error with line number for runtime errors", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const res = await runtime.execute(
+      `const x = 1;\nconst y = 2;\nthrow new Error("boom");`,
+      {},
+      null,
+    );
+
+    expect(res.error).toBeDefined();
+    expect(res.error!.message).toBe("boom");
+    expect(res.error!.name).toBe("Error");
+  });
+
+  it("handles syntax errors from V8", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const res = await runtime.execute("const x = {;", {}, null);
+
+    expect(res.error).toBeDefined();
+    expect(res.error!.message).toBeTruthy();
+  });
+
+  it("times out long-running code", async () => {
+    const runtime = createIsolateRuntime({ ...DEFAULT_CONFIG, timeout: 100 });
+    const res = await runtime.execute("while (true) {}", {}, null);
+
+    expect(res.error).toBeDefined();
+    expect(res.error!.message).toMatch(/timed out|timeout|Script execution/i);
+  });
+
+  it("truncates output at the configured limit", async () => {
+    const runtime = createIsolateRuntime({
+      ...DEFAULT_CONFIG,
+      outputLimit: 50,
+    });
+    const res = await runtime.execute(
+      `for (let i = 0; i < 100; i++) console.log("line " + i);`,
+      {},
+      null,
+    );
+
+    expect(res.stdout).toContain("[output truncated at 50 bytes]");
+  });
+
+  it("supports async code with await", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const res = await runtime.execute(
+      `const result = await Promise.resolve(99); return result;`,
+      {},
+      null,
+    );
+
+    expect(res.error).toBeUndefined();
+    expect(res.result).toBe(99);
+  });
+
+  it("handles abort signal (already aborted)", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const controller = new AbortController();
+    controller.abort();
+
+    const res = await runtime.execute("return 1;", {}, null, controller.signal);
+
+    expect(res.error).toBeDefined();
+    expect(res.error!.message).toBe("Execution cancelled");
+  });
+
+  it("handles abort signal during execution", async () => {
+    const runtime = createIsolateRuntime({ ...DEFAULT_CONFIG, timeout: 10000 });
+    const controller = new AbortController();
+
+    // Abort after a short delay
+    setTimeout(() => controller.abort(), 50);
+
+    const res = await runtime.execute(
+      "while (true) {}",
+      {},
+      null,
+      controller.signal,
+    );
+
+    expect(res.error).toBeDefined();
+    expect(res.error!.message).toMatch(/cancelled|disposed/i);
+  });
+});
+
+describe("IsolateRuntime bindings", () => {
+  it("calls async bindings and returns results", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const bindings: Record<string, IsolateBinding> = {
+      get_greeting: {
+        description: "Returns a greeting",
+        inputSchema: {
+          type: "object",
+          properties: { name: { type: "string" } },
+          required: ["name"],
+        },
+        handler: async (input) => `Hello, ${input.name}!`,
+      },
+    };
+
+    const res = await runtime.execute(
+      `const msg = await get_greeting({ name: "World" }); return msg;`,
+      bindings,
+      null,
+    );
+
+    expect(res.error).toBeUndefined();
+    expect(res.result).toBe("Hello, World!");
+  });
+
+  it("handles binding errors gracefully", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const bindings: Record<string, IsolateBinding> = {
+      fail: {
+        description: "Always fails",
+        inputSchema: { type: "object" },
+        handler: async () => {
+          throw new Error("binding error");
+        },
+      },
+    };
+
+    const res = await runtime.execute(
+      `try { await fail({}); } catch (e) { return e.message; }`,
+      bindings,
+      null,
+    );
+
+    expect(res.error).toBeUndefined();
+    expect(res.result).toBe("binding error");
+  });
+
+  it("supports multiple bindings in the same execution", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const bindings: Record<string, IsolateBinding> = {
+      add: {
+        description: "Add two numbers",
+        inputSchema: { type: "object" },
+        handler: async (input) =>
+          (input.a as number) + (input.b as number),
+      },
+      multiply: {
+        description: "Multiply two numbers",
+        inputSchema: { type: "object" },
+        handler: async (input) =>
+          (input.a as number) * (input.b as number),
+      },
+    };
+
+    const res = await runtime.execute(
+      `const sum = await add({ a: 3, b: 4 }); const prod = await multiply({ a: sum, b: 2 }); return prod;`,
+      bindings,
+      null,
+    );
+
+    expect(res.error).toBeUndefined();
+    expect(res.result).toBe(14);
+  });
+});
+
+describe("IsolateRuntime preamble", () => {
+  it("evaluates library preamble before user code", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const preamble = `var __lib_mylib = { greet: function(n) { return "Hi " + n; } };
+var __modules = { mylib: __lib_mylib };
+function require(name) {
+  if (!__modules[name]) throw new Error('Module "' + name + '" not found');
+  return __modules[name];
+}`;
+
+    const res = await runtime.execute(
+      `const lib = require("mylib"); return lib.greet("Test");`,
+      {},
+      preamble,
+    );
+
+    expect(res.error).toBeUndefined();
+    expect(res.result).toBe("Hi Test");
+  });
+
+  it("preamble errors don't affect user code line numbers", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    // A valid preamble with many lines
+    const preamble = Array(50).fill("var _unused = 0;").join("\n");
+
+    const res = await runtime.execute(
+      `const x = 1;\nthrow new Error("line2");`,
+      {},
+      preamble,
+    );
+
+    expect(res.error).toBeDefined();
+    expect(res.error!.message).toBe("line2");
+    // Line should refer to the user code, not the preamble
+    if (res.error!.line !== undefined) {
+      expect(res.error!.line).toBeLessThanOrEqual(3);
+    }
+  });
+});

package/test/state.test.ts

@@ -1,9 +1,5 @@
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
 import { describe, expect, it } from "vitest";
 import { createConversationStore, createStateStore } from "../src/state.js";
-import { ensureAgentIdentity, getAgentStoreDirectory } from "../src/agent-identity.js";
 
 describe("state store factory", () => {
   it("uses memory provider when explicitly requested", async () => {
@@ -45,29 +41,10 @@ describe("conversation store factory", () => {
     expect(found?.title).toBe("fallback");
   });
 
-  it("stores local conversations per file with index", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "poncho-state-local-layout-"));
-    await writeFile(
-      join(dir, "AGENT.md"),
-      `---
-name: local-layout-agent
-model:
-  provider: anthropic
-  name: claude-opus-4-5
----
-
-# Local layout
-`,
-      "utf8",
-    );
-    const store = createConversationStore({ provider: "local" }, { workingDir: dir });
+  it("local provider returns in-memory store (engine handles persistence)", async () => {
+    const store = createConversationStore({ provider: "local" });
     const created = await store.create("owner-c", "layout");
-    const identity = await ensureAgentIdentity(dir);
-    const agentDir = getAgentStoreDirectory(identity);
-    const indexPath = resolve(agentDir, "conversations", "index.json");
-    const indexContent = await readFile(indexPath, "utf8");
-    expect(indexContent).toContain(created.conversationId);
-    expect(indexContent).toContain('"schemaVersion": "v1"');
-    await rm(agentDir, { recursive: true, force: true });
+    const found = await store.get(created.conversationId);
+    expect(found?.title).toBe("layout");
   });
 });

package/test/storage-engine.test.ts

@@ -0,0 +1,250 @@
+import { describe, expect, it, beforeEach } from "vitest";
+import { InMemoryEngine } from "../src/storage/memory-engine.js";
+import { SqliteEngine } from "../src/storage/sqlite-engine.js";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { StorageEngine } from "../src/storage/engine.js";
+
+// ---------------------------------------------------------------------------
+// Shared test suite that runs against both InMemory and SQLite engines
+// ---------------------------------------------------------------------------
+
+function runEngineTests(name: string, factory: () => Promise<{ engine: StorageEngine; cleanup: () => Promise<void> }>) {
+  describe(`${name} engine`, () => {
+    let engine: StorageEngine;
+    let cleanup: () => Promise<void>;
+
+    beforeEach(async () => {
+      const ctx = await factory();
+      engine = ctx.engine;
+      cleanup = ctx.cleanup;
+    });
+
+    // -- Conversations --
+
+    describe("conversations", () => {
+      it("creates and retrieves a conversation", async () => {
+        const conv = await engine.conversations.create("owner1", "Hello", "tenant1");
+        expect(conv.title).toBe("Hello");
+        expect(conv.ownerId).toBe("owner1");
+
+        const got = await engine.conversations.get(conv.conversationId);
+        expect(got?.title).toBe("Hello");
+      });
+
+      it("lists conversations filtered by tenant", async () => {
+        await engine.conversations.create("o", "A", "t1");
+        await engine.conversations.create("o", "B", "t2");
+
+        const t1 = await engine.conversations.list(undefined, "t1");
+        expect(t1).toHaveLength(1);
+        expect(t1[0].title).toBe("A");
+      });
+
+      it("renames a conversation", async () => {
+        const conv = await engine.conversations.create("o", "Old");
+        const renamed = await engine.conversations.rename(conv.conversationId, "New");
+        expect(renamed?.title).toBe("New");
+      });
+
+      it("deletes a conversation", async () => {
+        const conv = await engine.conversations.create("o", "Del");
+        const deleted = await engine.conversations.delete(conv.conversationId);
+        expect(deleted).toBe(true);
+        const got = await engine.conversations.get(conv.conversationId);
+        expect(got).toBeUndefined();
+      });
+
+      it("searches conversations by title", async () => {
+        await engine.conversations.create("o", "alpha beta");
+        await engine.conversations.create("o", "gamma delta");
+
+        const results = await engine.conversations.search("beta");
+        expect(results).toHaveLength(1);
+        expect(results[0].title).toBe("alpha beta");
+      });
+    });
+
+    // -- Memory --
+
+    describe("memory", () => {
+      it("reads empty memory by default", async () => {
+        const mem = await engine.memory.get("t1");
+        expect(mem.content).toBe("");
+      });
+
+      it("updates and retrieves memory", async () => {
+        await engine.memory.update("remember this", "t1");
+        const mem = await engine.memory.get("t1");
+        expect(mem.content).toBe("remember this");
+      });
+
+      it("isolates memory by tenant", async () => {
+        await engine.memory.update("tenant A", "tA");
+        await engine.memory.update("tenant B", "tB");
+        expect((await engine.memory.get("tA")).content).toBe("tenant A");
+        expect((await engine.memory.get("tB")).content).toBe("tenant B");
+      });
+    });
+
+    // -- Todos --
+
+    describe("todos", () => {
+      it("stores and retrieves todos", async () => {
+        const items = [
+          { id: "1", content: "Buy milk", status: "pending" as const, priority: "medium" as const, createdAt: Date.now(), updatedAt: Date.now() },
+        ];
+        await engine.todos.set("conv1", items);
+        const got = await engine.todos.get("conv1");
+        expect(got).toHaveLength(1);
+        expect(got[0].content).toBe("Buy milk");
+      });
+
+      it("returns empty array for missing conversation", async () => {
+        const got = await engine.todos.get("nonexistent");
+        expect(got).toHaveLength(0);
+      });
+    });
+
+    // -- Reminders --
+
+    describe("reminders", () => {
+      it("creates and lists reminders", async () => {
+        const r = await engine.reminders.create({
+          task: "Call dentist",
+          scheduledAt: Date.now() + 3600_000,
+          conversationId: "conv1",
+        });
+        expect(r.task).toBe("Call dentist");
+
+        const list = await engine.reminders.list();
+        expect(list).toHaveLength(1);
+      });
+
+      it("cancels a reminder", async () => {
+        const r = await engine.reminders.create({
+          task: "Cancel me",
+          scheduledAt: Date.now(),
+          conversationId: "conv1",
+        });
+        const cancelled = await engine.reminders.cancel(r.id);
+        expect(cancelled.status).toBe("cancelled");
+      });
+    });
+
+    // -- VFS --
+
+    describe("vfs", () => {
+      it("writes and reads a file", async () => {
+        const content = new TextEncoder().encode("hello world");
+        await engine.vfs.writeFile("t1", "/test.txt", content);
+        const read = await engine.vfs.readFile("t1", "/test.txt");
+        expect(new TextDecoder().decode(read)).toBe("hello world");
+      });
+
+      it("creates directories recursively", async () => {
+        await engine.vfs.mkdir("t1", "/a/b/c", true);
+        const stat = await engine.vfs.stat("t1", "/a/b/c");
+        expect(stat?.type).toBe("directory");
+      });
+
+      it("lists directory contents", async () => {
+        await engine.vfs.writeFile("t1", "/dir/a.txt", new Uint8Array());
+        await engine.vfs.writeFile("t1", "/dir/b.txt", new Uint8Array());
+        const entries = await engine.vfs.readdir("t1", "/dir");
+        expect(entries.map((e) => e.name).sort()).toEqual(["a.txt", "b.txt"]);
+      });
+
+      it("deletes files and directories", async () => {
+        await engine.vfs.writeFile("t1", "/rm-me.txt", new TextEncoder().encode("bye"));
+        await engine.vfs.deleteFile("t1", "/rm-me.txt");
+        const stat = await engine.vfs.stat("t1", "/rm-me.txt");
+        expect(stat).toBeUndefined();
+      });
+
+      it("renames files", async () => {
+        await engine.vfs.writeFile("t1", "/old.txt", new TextEncoder().encode("data"));
+        await engine.vfs.rename("t1", "/old.txt", "/new.txt");
+        const old = await engine.vfs.stat("t1", "/old.txt");
+        const nw = await engine.vfs.stat("t1", "/new.txt");
+        expect(old).toBeUndefined();
+        expect(nw?.type).toBe("file");
+      });
+
+      it("appends to files", async () => {
+        await engine.vfs.writeFile("t1", "/append.txt", new TextEncoder().encode("hello"));
+        await engine.vfs.appendFile("t1", "/append.txt", new TextEncoder().encode(" world"));
+        const read = await engine.vfs.readFile("t1", "/append.txt");
+        expect(new TextDecoder().decode(read)).toBe("hello world");
+      });
+
+      it("supports symlinks", async () => {
+        await engine.vfs.writeFile("t1", "/target.txt", new TextEncoder().encode("linked"));
+        await engine.vfs.symlink("t1", "/target.txt", "/link.txt");
+        const target = await engine.vfs.readlink("t1", "/link.txt");
+        expect(target).toBe("/target.txt");
+      });
+
+      it("reports usage stats", async () => {
+        await engine.vfs.writeFile("t1", "/f1.txt", new TextEncoder().encode("abc"));
+        await engine.vfs.writeFile("t1", "/f2.txt", new TextEncoder().encode("defgh"));
+        const usage = await engine.vfs.getUsage("t1");
+        expect(usage.fileCount).toBe(2);
+        expect(usage.totalBytes).toBe(8);
+      });
+
+      it("listAllPaths returns all VFS paths", async () => {
+        await engine.vfs.writeFile("t1", "/a.txt", new Uint8Array());
+        await engine.vfs.mkdir("t1", "/dir");
+        const paths = engine.vfs.listAllPaths("t1");
+        expect(paths).toContain("/a.txt");
+        expect(paths).toContain("/dir");
+      });
+
+      it("isolates files by tenant", async () => {
+        await engine.vfs.writeFile("t1", "/secret.txt", new TextEncoder().encode("t1-data"));
+        await engine.vfs.writeFile("t2", "/secret.txt", new TextEncoder().encode("t2-data"));
+        const t1 = await engine.vfs.readFile("t1", "/secret.txt");
+        const t2 = await engine.vfs.readFile("t2", "/secret.txt");
+        expect(new TextDecoder().decode(t1)).toBe("t1-data");
+        expect(new TextDecoder().decode(t2)).toBe("t2-data");
+      });
+    });
+
+    // Cleanup at the end of each test
+    it("cleanup", async () => {
+      await engine.close();
+      await cleanup();
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Run against InMemoryEngine
+// ---------------------------------------------------------------------------
+
+runEngineTests("InMemory", async () => {
+  const engine = new InMemoryEngine("test-agent");
+  await engine.initialize();
+  return { engine, cleanup: async () => {} };
+});
+
+// ---------------------------------------------------------------------------
+// Run against SqliteEngine
+// ---------------------------------------------------------------------------
+
+runEngineTests("SQLite", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "poncho-sqlite-test-"));
+  const engine = new SqliteEngine({
+    workingDir: dir,
+    agentId: "test-agent",
+  });
+  await engine.initialize();
+  return {
+    engine,
+    cleanup: async () => {
+      await rm(dir, { recursive: true, force: true });
+    },
+  };
+});