ThothII/backend/test/pi-process-manager.test.ts

import { test, expect } from "vitest";
import { spawn } from "node:child_process";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { EventEmitter } from "node:events";
import { PiProcessManager } from "../src/pi/pi-process-manager.js";
import { loadConfig } from "../src/config.js";

const __dirname = path.dirname(fileURLToPath(import.meta.url));
const FAKE = path.resolve(__dirname, "../../harness/tests/fake_pi/fake_pi_rpc.mjs");
const SCRIPT = path.resolve(__dirname, "../../harness/tests/fake_pi/scripts/f1_disambiguation.json");

test("spawnFor avvia un runtime e il bridge emette il widget F1", async () => {
  const cfg = loadConfig({ THT_HARNESS_DIR: "../harness" });
  const mgr = new PiProcessManager(cfg, { spawnFn: () => spawn("node", [FAKE, SCRIPT]) as any });
  const rt = await mgr.spawnFor("2026-06-27-100000-x", {});
  const widget = await new Promise<any>((res) => rt.bridge.onClientEvent((e) => e.type === "ui_request" && res(e)));
  expect(widget.ui_request.widget).toBe("select");
  mgr.teardown("2026-06-27-100000-x");
  expect(mgr.count()).toBe(0);
});

test("l'exit del child rimuove il runtime dalla mappa (exit handler)", async () => {
  const cfg = loadConfig({ THT_HARNESS_DIR: "../harness" });
  const mgr = new PiProcessManager(cfg, { spawnFn: () => spawn("node", [FAKE, SCRIPT]) as any });
  const rt = await mgr.spawnFor("exit-test", {});
  expect(mgr.count()).toBe(1);
  // Cause the child to exit on its own and await the 'exit' event (no teardown call).
  const exited = new Promise<void>((res) => rt.child.on("exit", () => res()));
  rt.child.kill();
  await exited;
  // Let the manager's registered exit handler run.
  await new Promise((res) => setImmediate(res));
  expect(mgr.count()).toBe(0);
  expect(mgr.get("exit-test")).toBeUndefined();
});

test("spawnFor sullo STESSO id uccide il vecchio child e sostituisce il runtime (count resta 1)", async () => {
  const cfg = loadConfig({ THT_HARNESS_DIR: "../harness" });
  const mgr = new PiProcessManager(cfg, { spawnFn: () => spawn("node", [FAKE, SCRIPT]) as any });
  const first = await mgr.spawnFor("dup-id", {});
  expect(mgr.count()).toBe(1);
  const firstExited = new Promise<void>((res) => first.child.on("exit", () => res()));
  const second = await mgr.spawnFor("dup-id", {});
  await firstExited; // the old child was killed by the idempotent respawn
  expect(mgr.count()).toBe(1);
  expect(mgr.get("dup-id")).toBe(second);
  expect(second).not.toBe(first);
  mgr.teardown("dup-id");
});

test("l'exit del VECCHIO child non elimina il nuovo runtime (exit identity-checked)", async () => {
  const cfg = loadConfig({ THT_HARNESS_DIR: "../harness" });
  const mgr = new PiProcessManager(cfg, { spawnFn: () => spawn("node", [FAKE, SCRIPT]) as any });
  const first = await mgr.spawnFor("respawn-id", {});
  const second = await mgr.spawnFor("respawn-id", {});
  // The old child's exit handler fires after the respawn; it must NOT evict `second`.
  await new Promise((res) => setImmediate(res));
  expect(mgr.get("respawn-id")).toBe(second);
  expect(mgr.count()).toBe(1);
  void first;
  mgr.teardown("respawn-id");
});

test("oltre maxPiProcesses solleva errore", async () => {
  const cfg = { ...loadConfig({}), maxPiProcesses: 1 };
  const mgr = new PiProcessManager(cfg, { spawnFn: () => spawn("node", [FAKE, SCRIPT]) as any });
  await mgr.spawnFor("a", {});
  await expect(mgr.spawnFor("b", {})).rejects.toThrow(/max/i);
  mgr.teardown("a");
});

function recordingChild() {
  const ch: any = new EventEmitter();
  ch.stdout = new EventEmitter();
  ch.stderr = new EventEmitter();
  ch._writes = [] as string[];
  ch.stdin = { write: (d: any) => { ch._writes.push(String(d)); return true; } };
  ch.kill = () => {};
  return ch;
}

test("un exit INATTESO del child notifica il client (info error + agent_end)", async () => {
  const cfg = loadConfig({});
  const child = recordingChild();
  const mgr = new PiProcessManager(cfg, { spawnFn: () => child as any });
  const rt = await mgr.spawnFor("crash-id", {});
  const seen: any[] = [];
  rt.bridge.onClientEvent((e) => seen.push(e));
  child.emit("exit", 137);
  expect(seen).toEqual([
    { type: "info", level: "error", text: expect.stringContaining("137") },
    { type: "system_event", event: "agent_end" },
  ]);
  expect(mgr.count()).toBe(0);
});

test("l'exit dopo teardown NON emette eventi al client (uscita attesa)", async () => {
  const cfg = loadConfig({});
  const child = recordingChild();
  const mgr = new PiProcessManager(cfg, { spawnFn: () => child as any });
  const rt = await mgr.spawnFor("stop-id", {});
  const seen: any[] = [];
  rt.bridge.onClientEvent((e) => seen.push(e));
  mgr.teardown("stop-id");
  child.emit("exit", 0);
  expect(seen).toEqual([]);
});

test("spawnFor resume mode sends /riprendi-sessione <id>", async () => {
  const cfg = loadConfig({}); // no provider/model/thinking -> no rpc.request handshakes
  const child = recordingChild();
  const mgr = new PiProcessManager(cfg, { spawnFn: () => child as any });
  await mgr.spawnFor("sid-9", { mode: "resume" });
  expect(child._writes.join("")).toContain("/riprendi-sessione sid-9");
  expect(child._writes.join("")).not.toContain("/nuova-domanda");
  mgr.teardown("sid-9");
});

test("spawnFor default (new) mode sends /nuova-domanda", async () => {
  const cfg = loadConfig({});
  const child = recordingChild();
  const mgr = new PiProcessManager(cfg, { spawnFn: () => child as any });
  await mgr.spawnFor("sid-10", {});
  expect(child._writes.join("")).toContain("/nuova-domanda");
  mgr.teardown("sid-10");
});