Add test runner script, module loader bootstrap, and E2E suite

Author: ofriw

register-loader.mjs

@@ -0,0 +1,10 @@
+// Bootstrap module for `--import` that registers the custom module loader.
+// Replaces the deprecated `--experimental-loader` flag.
+// Phase 1: uses module.register() — safe on Node <25.
+// Phase 2: migrate to module.registerHooks() when targeting Node >=25.
+import { register } from "node:module";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+register(pathToFileURL(resolve(HERE, "test-loader.mjs")), pathToFileURL(HERE + "/"));

scripts/run-node-test.mjs

@@ -0,0 +1,30 @@
+import { spawnSync } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const root = resolve(here, "..");
+const args = process.argv.slice(2);
+const updateSnapshots = args.includes("--update-snapshots");
+const patterns = args.filter((arg) => arg !== "--update-snapshots");
+
+if (patterns.length === 0) {
+  throw new Error("Pass at least one test file or glob pattern.");
+}
+
+const loader = pathToFileURL(resolve(root, "register-loader.mjs")).href;
+const result = spawnSync(
+  process.execPath,
+  ["--import", loader, "--test", ...patterns],
+  {
+    cwd: root,
+    stdio: "inherit",
+    env: updateSnapshots
+      ? { ...process.env, UPDATE_SNAPSHOTS: "1" }
+      : process.env,
+  },
+);
+
+if (result.error) throw result.error;
+if (result.signal) process.kill(process.pid, result.signal);
+process.exit(result.status ?? 1);

test-loader.mjs

@@ -1,8 +1,28 @@
 import { access } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import path from "node:path";
+import { existsSync } from "node:fs";
 
-const PACKAGE_ROOT = "/Users/ofri/.nvm/versions/node/v24.14.1/lib/node_modules/@earendil-works/pi-coding-agent";
+/**
+ * Walk up from a start directory to find node_modules/<name>.
+ * Works regardless of how the package was installed (local vs global).
+ */
+function findPackageRoot(name, startDir) {
+	let dir = startDir;
+	while (true) {
+		const candidate = path.join(dir, "node_modules", name);
+		if (existsSync(candidate)) return candidate;
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+
+const PACKAGE_ROOT = findPackageRoot(
+	"@earendil-works/pi-coding-agent",
+	path.dirname(fileURLToPath(import.meta.url)),
+);
+if (!PACKAGE_ROOT) throw new Error("Cannot find @earendil-works/pi-coding-agent package root");
 const PACKAGE_ALIASES = {
 	"@earendil-works/pi-coding-agent": `${PACKAGE_ROOT}/dist/index.js`,
 	"@earendil-works/pi-ai": `${PACKAGE_ROOT}/node_modules/@earendil-works/pi-ai/dist/index.js`,

tests/e2e/basic.test.ts

@@ -0,0 +1,156 @@
+/**
+ * Process-isolated E2E tests for the agenticoding extension.
+ *
+ * These tests spawn a fresh Node.js process per test case. Process isolation
+ * means no shared singletons and no console races between test cases.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { PytestHarness } from "./pty-harness.js";
+
+/**
+ * Create a fresh host, wait for READY, and return the harness.
+ */
+async function start(): Promise<PytestHarness> {
+  const h = new PytestHarness();
+  await h.waitForText("READY");
+  return h;
+}
+
+async function withHarness(run: (h: PytestHarness) => Promise<void>): Promise<void> {
+  const h = await start();
+  try {
+    await run(h);
+  } finally {
+    try {
+      h.write("exit");
+    } catch {
+      // already dead
+    }
+    h.close();
+  }
+}
+
+describe("agenticoding E2E", () => {
+  it("host starts and extension registers", async () => withHarness(async (h) => {
+    h.write("tools");
+    await h.waitForText("OK:");
+
+    const snap = h.snapshot();
+    assert.ok(snap.includes("notebook_write"), "notebook_write tool registered");
+    assert.ok(snap.includes("notebook_read"), "notebook_read tool registered");
+    assert.ok(snap.includes("notebook_index"), "notebook_index tool registered");
+    assert.ok(snap.includes("notebook_topic_set"), "notebook_topic_set tool registered");
+    assert.ok(snap.includes("handoff"), "handoff tool registered");
+    assert.ok(snap.includes("spawn"), "spawn tool registered");
+  }));
+
+  it("notebook write/read round-trip", async () => withHarness(async (h) => {
+    h.write('tool notebook_write {"name":"my-page","content":"Hello World"}');
+    await h.waitForText("OK:Saved notebook page");
+
+    h.write('tool notebook_read {"name":"my-page"}');
+    await h.waitForText("OK:--- my-page ---");
+
+    const snap = h.snapshot();
+    assert.ok(snap.includes("Hello World"), "content persisted");
+  }));
+
+  it("notebook index reflects written pages", async () => withHarness(async (h) => {
+    h.write('tool notebook_write {"name":"page-a","content":"Page A"}');
+    await h.waitForText("OK:");
+
+    h.write("tool notebook_index {}");
+    await h.waitForText("page-a");
+
+    // Second write should appear in index
+    h.write('tool notebook_write {"name":"page-b","content":"Page B"}');
+    await h.waitForText("OK:");
+
+    h.write("tool notebook_index {}");
+    await h.waitForText("page-b");
+
+    const snap = h.snapshot();
+    assert.ok(snap.includes("page-a"), "page-a in index");
+    assert.ok(snap.includes("page-b"), "page-b in index");
+  }));
+
+  it("notebook_write overwrites existing page", async () => withHarness(async (h) => {
+    h.write('tool notebook_write {"name":"page","content":"v1"}');
+    await h.waitForText("OK:");
+
+    // Clear accumulated output so we only check the second write/read
+    h.clear();
+    h.write('tool notebook_write {"name":"page","content":"v2"}');
+    await h.waitForText("OK:");
+
+    h.clear();
+    h.write('tool notebook_read {"name":"page"}');
+    await h.waitForText("OK:--- page ---");
+
+    const snap = h.snapshot();
+    assert.ok(snap.includes("v2"), "overwritten content present");
+    assert.ok(!snap.includes("v1"), "old content absent from fresh output");
+  }));
+
+  it("notebook topic lifecycle: set via command, agent-set blocked", async () => withHarness(async (h) => {
+    // Set topic via /notebook command (human-set)
+    h.write("cmd notebook my-e2e-topic");
+    await h.waitForText("OK");
+
+    // Agent-set should be blocked (human is authoritative)
+    h.write('tool notebook_topic_set {"topic":"agent-topic"}');
+    await h.waitForText("ERR:");
+    const snap = h.snapshot();
+    assert.ok(
+      snap.includes("authoritative") || snap.includes("already exists"),
+      "human-set topic blocks agent override",
+    );
+  }));
+
+  it("agent-set topic works when unset", async () => withHarness(async (h) => {
+    // No topic set yet -- agent can set
+    h.write('tool notebook_topic_set {"topic":"fresh-agent-topic"}');
+    await h.waitForText("OK:Active notebook topic:");
+    const snap = h.snapshot();
+    assert.ok(snap.includes("fresh-agent-topic"));
+  }));
+
+  it("handoff tool queues handoff state", async () => withHarness(async (h) => {
+    h.write('tool handoff {"task":"test handoff task","direction":"next-phase"}');
+    await h.waitForText("OK:Handoff started");
+  }));
+
+  it("commands are registered", async () => withHarness(async (h) => {
+    h.write("cmds");
+    await h.waitForText("OK:");
+
+    const snap = h.snapshot();
+    assert.ok(snap.includes("notebook"), "/notebook command registered");
+    assert.ok(snap.includes("handoff"), "/handoff command registered");
+  }));
+
+  it("spawn tool errors gracefully without model infrastructure", async () => withHarness(async (h) => {
+    // Without a real model/session manager, spawn should throw immediately.
+    h.write('tool spawn {"prompt":"any task"}');
+    await h.waitForText("ERR:");
+
+    const snap = h.snapshot();
+    assert.ok(snap.includes("No model") || snap.includes("ERR"), "spawn errors gracefully");
+  }));
+
+  it("handles errors gracefully", async () => withHarness(async (h) => {
+    // Unknown tool
+    h.write("tool nonexistent {}");
+    await h.waitForText("ERR:unknown tool");
+
+    // Invalid JSON
+    h.write("tool notebook_write {bad json}");
+    await h.waitForText("ERR:invalid json");
+
+    // Unknown command
+    h.write("cmd nonexistent");
+    await h.waitForText("ERR:unknown command");
+  }));
+});

tests/e2e/pty-harness.ts

@@ -0,0 +1,105 @@
+/**
+ * pty-harness.ts — Process-isolated child-process harness for E2E tests.
+ *
+ * Spawns a fresh Node.js process and communicates over stdin/stdout. Process
+ * isolation keeps runtime singletons and console output private per test case
+ * without depending on PTY availability in CI.
+ */
+
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { isAbsolute, dirname, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(HERE, "..", "..");
+const LOADER = pathToFileURL(resolve(ROOT, "register-loader.mjs")).href;
+
+export const DEFAULT_SCRIPT = resolve(HERE, "test-host.ts");
+
+export class PytestHarness {
+  private child: ChildProcessWithoutNullStreams;
+  private output = "";
+  private readOffset = 0;
+  private timeoutMs: number;
+  private waiters = new Set<() => void>();
+
+  constructor(
+    scriptPath = DEFAULT_SCRIPT,
+    options?: { timeoutMs?: number },
+  ) {
+    this.timeoutMs = options?.timeoutMs ?? 5000;
+
+    const entry = isAbsolute(scriptPath) ? scriptPath : resolve(ROOT, scriptPath);
+
+    this.child = spawn(process.execPath, ["--import", LOADER, entry], {
+      cwd: ROOT,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        FORCE_COLOR: "0",
+        NODE_OPTIONS: "",
+      },
+    });
+
+    const append = (chunk: string | Buffer) => {
+      this.output += chunk.toString();
+      for (const wake of this.waiters) wake();
+      this.waiters.clear();
+    };
+
+    this.child.stdout.on("data", append);
+    this.child.stderr.on("data", append);
+  }
+
+  private async waitForOutput(ms: number): Promise<void> {
+    if (ms <= 0) return;
+    await new Promise<void>((resolve) => {
+      const wake = () => {
+        clearTimeout(timer);
+        this.waiters.delete(wake);
+        resolve();
+      };
+      const timer = setTimeout(wake, ms);
+      this.waiters.add(wake);
+    });
+  }
+
+  /** Wait for a fresh substring to appear after the prior match. */
+  async waitForText(text: string): Promise<void> {
+    const deadline = Date.now() + this.timeoutMs;
+    while (Date.now() < deadline) {
+      const index = this.output.indexOf(text, this.readOffset);
+      if (index !== -1) {
+        this.readOffset = index + text.length;
+        return;
+      }
+      await this.waitForOutput(deadline - Date.now());
+    }
+    throw new Error(
+      `waitForText timeout after ${this.timeoutMs}ms looking for fresh \"${text}\".\n` +
+        `Output so far:\n${this.output}`,
+    );
+  }
+
+  /** Write a line of input to the child process. */
+  write(input: string): void {
+    this.child.stdin.write(input + "\n");
+  }
+
+  /** Return all accumulated output since creation or last clear(). */
+  snapshot(): string {
+    return this.output;
+  }
+
+  /** Clear accumulated output and match cursor, keeping the child running. */
+  clear(): void {
+    this.output = "";
+    this.readOffset = 0;
+  }
+
+  /** Kill the child process. */
+  close(): void {
+    this.child.stdin.end();
+    if (!this.child.killed) this.child.kill();
+  }
+}