@rol1n/multi-harness 0.0.0-stage → 0.1.0

package/extensions/multi-harness/ipc.mjs

@@ -0,0 +1,37 @@
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+
+export function readJson(path) {
+  try { return JSON.parse(readFileSync(path, "utf8")); }
+  catch (error) {
+    if (error.code === "ENOENT") return undefined;
+    throw new Error(`Cannot read IPC file ${path}: ${error.message}`, { cause: error });
+  }
+}
+
+export function writeJson(path, value) {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  writeFileSync(temporary, JSON.stringify(value, null, 2), { encoding: "utf8", mode: 0o600 });
+  renameSync(temporary, path);
+}
+
+export function taskId(prompt) {
+  return typeof prompt === "string" ? prompt.match(/\[Harness task ([\w-]+)\]/)?.[1] : undefined;
+}
+
+/** Record a settled turn, not a model's early claim that it has finished. */
+export function complete(directory, result) {
+  const request = readJson(join(directory, "request.json"));
+  if (!request || !result.id || request.id !== result.id) return;
+  const previous = readJson(join(directory, "completion.json"));
+  if (previous?.id === result.id) return;
+  const proposal = readJson(join(directory, "proposal.json"));
+  const value = {
+    ...result,
+    summary: result.summary || (proposal?.id === result.id ? proposal.summary : undefined) || "No final text captured; inspect the session or log.",
+    at: Date.now(),
+  };
+  writeJson(join(directory, "state.json"), { status: "idle", id: result.id, at: value.at });
+  writeJson(join(directory, "completion.json"), value);
+}

package/extensions/multi-harness/opencode-plugin.mjs

@@ -0,0 +1,99 @@
+import { existsSync, realpathSync, renameSync, unlinkSync, watch } from "node:fs";
+import { join } from "node:path";
+import { complete, readJson, taskId, writeJson } from "./ipc.mjs";
+
+const text = (parts) => (parts ?? []).filter((part) => part.type === "text").map((part) => part.text).join("\n");
+const describe = (error) => error?.data?.message ?? error?.message ?? error?.name ?? String(error);
+
+/** OpenCode 1.x server plugin: native SDK input and idle events, no terminal key injection. */
+export default async function multiHarnessOpenCode({ client, directory }) {
+  const artifactDir = process.env.PI_MULTI_HARNESS_DIR;
+  if (process.env.PI_MULTI_HARNESS_WORKER !== "1" || !artifactDir) return {};
+  const assignedCwd = process.env.PI_MULTI_HARNESS_CWD;
+  if (assignedCwd && realpathSync(directory) !== realpathSync(assignedCwd)) return {};
+  let sessionId = readJson(join(artifactDir, "metadata.json"))?.sessionId;
+  let active;
+  let settling = false;
+  let receiving = false;
+  let disposed = false;
+  let model;
+  let agent;
+  const inbox = join(artifactDir, "inbox.json");
+  const state = (status, id) => writeJson(join(artifactDir, "state.json"), { status, id, at: Date.now() });
+
+  async function receive() {
+    if (disposed || receiving) return;
+    receiving = true;
+    let payload;
+    try {
+      const processing = `${inbox}.processing`;
+      renameSync(inbox, processing);
+      try { payload = readJson(processing); } finally { unlinkSync(processing); }
+      const request = readJson(join(artifactDir, "request.json"));
+      if (!sessionId || !payload?.id || payload.id !== request?.id || typeof payload.task !== "string" || taskId(payload.task) !== payload.id) {
+        throw new Error("OpenCode inbox requires a known session and the current task ID.");
+      }
+      const current = readJson(join(artifactDir, "state.json"));
+      if (current?.status !== "idle") throw new Error("OpenCode is not idle; do not dispatch during another turn or permission dialog.");
+      state("running", payload.id);
+      // The injected SDK is bound to this backend/directory, so the visible TUI observes this same session.
+      const result = await client.session.promptAsync({ path: { id: sessionId }, body: { parts: [{ type: "text", text: payload.task }], ...(model ? { model } : {}), ...(agent ? { agent } : {}) } });
+      if (result.error) throw new Error(`OpenCode rejected the prompt: ${describe(result.error)}`);
+      writeJson(join(artifactDir, "ack.json"), { id: payload.id, status: "ok" });
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        if (!active) state("idle");
+        writeJson(join(artifactDir, "ack.json"), { id: payload?.id ?? readJson(join(artifactDir, "request.json"))?.id, status: "error", error: describe(error) });
+      }
+    } finally { receiving = false; }
+  }
+
+  async function settled() {
+    if (settling || disposed) return;
+    if (!active) { state("idle"); return; }
+    settling = true;
+    const turn = active;
+    try {
+      const result = await client.session.messages({ path: { id: sessionId } });
+      if (result.error || !Array.isArray(result.data)) throw new Error(`Cannot read OpenCode messages: ${result.error ? describe(result.error) : "invalid SDK response"}`);
+      const messages = result.data;
+      const start = messages.findIndex((message) => message.info?.id === turn.messageId);
+      if (start === -1) throw new Error("Assigned user message was not found; refusing to report another turn's answer.");
+      // Compaction may add synthetic user continuations; use the last root-session answer after our message.
+      const last = messages.slice(start + 1).filter((message) => message.info?.role === "assistant" && (!message.info.sessionID || message.info.sessionID === sessionId)).at(-1);
+      const error = last?.info.error ?? (last?.info.finish === "stop" ? undefined : turn.error) ?? (!last ? new Error("No assistant response for the assigned task.") : undefined);
+      complete(artifactDir, { id: turn.id, sessionId, status: error ? "failed" : "completed", summary: text(last?.parts), ...(error ? { error: describe(error) } : {}) });
+    } catch (error) {
+      complete(artifactDir, { id: turn.id, sessionId, status: "failed", error: describe(error) });
+    } finally {
+      if (active === turn) active = undefined;
+      settling = false;
+    }
+  }
+
+  const watcher = watch(artifactDir, (_event, name) => { if (name?.toString() === "inbox.json" || existsSync(inbox)) void receive(); });
+  watcher.unref();
+  watcher.on("error", (error) => writeJson(join(artifactDir, "ack.json"), { id: readJson(join(artifactDir, "request.json"))?.id, status: "error", error: `OpenCode inbox watcher failed: ${error.message}` }));
+  void receive();
+  return {
+    "chat.message": async (input, output) => {
+      const id = taskId(text(output.parts));
+      const request = readJson(join(artifactDir, "request.json"));
+      if (sessionId && input.sessionID !== sessionId) return; // Ignore subagents and unrelated sessions.
+      if (id && id === request?.id) {
+        sessionId = input.sessionID;
+        active = { id, messageId: output.message.id ?? input.messageID };
+        writeJson(join(artifactDir, "metadata.json"), { harness: "opencode", sessionId });
+      } else if (!sessionId) return;
+      model = input.model;
+      agent = input.agent;
+      state("running", id);
+    },
+    event: async ({ event }) => {
+      if (!sessionId || event.properties?.sessionID !== sessionId) return;
+      if (event.type === "session.error" && active) active.error = event.properties.error;
+      if (event.type === "session.idle" || (event.type === "session.status" && event.properties.status?.type === "idle")) await settled();
+    },
+    dispose: async () => { disposed = true; watcher.close(); },
+  };
+}

package/extensions/multi-harness/process-runner.mjs

@@ -0,0 +1,115 @@
+import { spawn } from "node:child_process";
+import { appendFileSync } from "node:fs";
+import { join } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { buildArgs, buildEnv, commandSpec } from "./adapters.mjs";
+import { complete, readJson, writeJson } from "./ipc.mjs";
+
+const config = readJson(process.argv[2]);
+if (!config) throw new Error("Missing multi-harness runner configuration.");
+const { artifactDir, interactive, harness } = config;
+const request = readJson(join(artifactDir, "request.json"));
+writeJson(join(artifactDir, "process.json"), { pid: process.pid, at: Date.now() });
+let child;
+try {
+  const spec = commandSpec(buildArgs(config));
+  child = spawn(spec.command, spec.args, {
+    cwd: config.cwd, env: buildEnv(config), windowsHide: !interactive,
+    stdio: interactive ? "inherit" : ["pipe", "pipe", "pipe"],
+  });
+} catch (error) {
+  complete(artifactDir, { id: request.id, status: "failed", error: `Cannot launch ${harness}: ${error.message}` });
+  writeJson(join(artifactDir, "state.json"), { status: "exited", code: 1, at: Date.now() });
+  throw error;
+}
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+  process.on(signal, () => child.kill(signal === "SIGHUP" && process.platform === "win32" ? "SIGTERM" : signal));
+}
+let summary = "";
+let failure;
+let stderr = "";
+let pending = "";
+const decoder = new StringDecoder("utf8");
+let metadata = readJson(join(artifactDir, "metadata.json")) ?? {};
+const seenSteps = new Set();
+const openCodeText = new Map();
+let openCodeMessageId;
+let openCodeSessionSeen = false;
+if (harness === "opencode") { delete metadata.usage; delete metadata.costUSD; }
+function textBlocks(content) {
+  return Array.isArray(content) ? content.filter((part) => part.type === "text").map((part) => part.text).join("\n") : "";
+}
+function onLine(line) {
+  if (harness === "pi") { summary = `${summary}${line}\n`.slice(-16000); return; }
+  let event;
+  try { event = JSON.parse(line); }
+  catch (error) {
+    if (error instanceof SyntaxError) return; // CLI diagnostics are preserved in console.log.
+    throw error;
+  }
+  if (harness === "codex") {
+    if (event.type === "thread.started") metadata.sessionId = event.thread_id ?? event["thread-id"];
+    if (event.item?.type === "agent_message") summary = event.item.text ?? summary;
+    if (event.type === "turn.completed") metadata.usage = event.usage;
+    if (["turn.failed", "error"].includes(event.type)) failure = event.message ?? event.error?.message ?? "Codex turn failed";
+  } else if (harness === "opencode") {
+    if (typeof event.sessionID === "string" && event.sessionID) {
+      openCodeSessionSeen = true;
+      if (config.resume && event.sessionID !== config.sessionId) failure = "OpenCode resumed a different session; refusing to treat it as the requested conversation.";
+      else metadata.sessionId = event.sessionID;
+    }
+    if (event.type === "text" && typeof event.part?.text === "string") {
+      if (event.part.messageID !== openCodeMessageId) { openCodeText.clear(); openCodeMessageId = event.part.messageID; }
+      openCodeText.set(event.part.id ?? "last", event.part.text);
+      summary = [...openCodeText.values()].join("\n");
+    }
+    if (event.type === "error") failure = event.error?.data?.message ?? event.error?.message ?? event.error?.name ?? "OpenCode turn failed";
+    if (event.type === "step_finish" && event.part && (!event.part.id || !seenSteps.has(event.part.id))) {
+      if (event.part.id) seenSteps.add(event.part.id);
+      if (event.part.tokens) {
+        metadata.usage ??= {};
+        for (const [key, value] of Object.entries({ input: event.part.tokens.input, output: event.part.tokens.output, reasoning: event.part.tokens.reasoning, cacheRead: event.part.tokens.cache?.read, cacheWrite: event.part.tokens.cache?.write })) {
+          if (typeof value === "number") metadata.usage[key] = (metadata.usage[key] ?? 0) + value;
+        }
+      }
+      if (typeof event.part.cost === "number") metadata.costUSD = (metadata.costUSD ?? 0) + event.part.cost;
+    }
+  } else {
+    if (event.type === "assistant") summary = textBlocks(event.message?.content) || summary;
+    if (event.session_id) metadata.sessionId = event.session_id;
+    if (event.type === "result") {
+      summary = event.result ?? summary;
+      metadata = { ...metadata, usage: event.usage, costUSD: event.total_cost_usd, model: Object.keys(event.modelUsage ?? {}).join(", ") };
+      if (event.is_error) failure = summary || "Claude turn failed";
+    }
+  }
+}
+if (!interactive) {
+  child.stdout.on("data", (chunk) => {
+    appendFileSync(join(artifactDir, "events.log"), chunk);
+    process.stdout.write(chunk);
+    pending += decoder.write(chunk);
+    let end;
+    while ((end = pending.indexOf("\n")) !== -1) { onLine(pending.slice(0, end)); pending = pending.slice(end + 1); }
+  });
+  child.stderr.on("data", (chunk) => { stderr = `${stderr}${chunk.toString("utf8")}`.slice(-4000); process.stderr.write(chunk); });
+  child.stdin.on("error", (cause) => { failure = `Prompt delivery failed: ${cause.message}`; });
+  // Pi receives its prompt as a CLI argument; the other CLIs receive exact UTF-8 stdin.
+  child.stdin.end(harness === "pi" ? undefined : config.prompt);
+}
+child.once("error", (cause) => { failure = `Cannot start ${harness}: ${cause.message}`; });
+child.once("close", (code, signal) => {
+  if (!interactive) {
+    pending += decoder.end();
+    if (pending) onLine(pending);
+    if (harness === "opencode" && !openCodeSessionSeen) failure ??= "OpenCode exited without a JSON session ID; inspect events.log for CLI compatibility errors.";
+    writeJson(join(artifactDir, "metadata.json"), metadata);
+    complete(artifactDir, { id: request.id, status: code === 0 && !failure ? "completed" : "failed", summary: summary.trim(), error: failure ?? (code !== 0 ? stderr || `Process exit ${code ?? signal}` : undefined), sessionId: metadata.sessionId });
+  } else {
+    const current = readJson(join(artifactDir, "request.json"));
+    const previous = readJson(join(artifactDir, "completion.json"));
+    if (current && previous?.id !== current.id) complete(artifactDir, { id: current.id, status: "failed", error: failure ?? `TUI exited before settlement (${code ?? signal}).` });
+  }
+  writeJson(join(artifactDir, "state.json"), { status: "exited", code, signal, at: Date.now() });
+  process.exitCode = code ?? 1;
+});

package/extensions/multi-harness/turn-hook.mjs

@@ -0,0 +1,29 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { complete, readJson, taskId, writeJson } from "./ipc.mjs";
+
+const [directory, harness, raw] = process.argv.slice(2);
+if (!directory || !["codex", "claude", "claude-start"].includes(harness)) throw new Error("Invalid multi-harness hook arguments.");
+const event = JSON.parse(harness === "codex" ? raw : readFileSync(0, "utf8"));
+const request = readJson(join(directory, "request.json"));
+if (!request) process.exit(0);
+if (harness === "claude-start") {
+  if (event.hook_event_name !== "UserPromptSubmit") process.exit(0);
+  writeJson(join(directory, "state.json"), { status: "running", id: taskId(event.prompt), at: Date.now() });
+  process.exit(0);
+}
+if (harness === "codex" && event.type !== "agent-turn-complete") process.exit(0);
+if (harness === "claude" && event.hook_event_name !== "Stop") process.exit(0);
+const sessionId = event["thread-id"] ?? event.thread_id ?? event.session_id;
+const inputs = event["input-messages"] ?? event.input_messages;
+const state = readJson(join(directory, "state.json"));
+const id = harness === "codex"
+  ? (Array.isArray(inputs) ? inputs.map(taskId).filter(Boolean).at(-1) : request.id)
+  : state?.id;
+if (sessionId) writeJson(join(directory, "metadata.json"), { sessionId, harness });
+if (id !== request.id) {
+  // Manual turns must return to idle too, without completing a coordinator dispatch.
+  writeJson(join(directory, "state.json"), { status: "idle", at: Date.now() });
+  process.exit(0);
+}
+complete(directory, { id, status: "completed", sessionId, summary: event["last-assistant-message"] ?? event.last_assistant_message });

package/extensions/multi-harness/worker-bridge.ts

@@ -0,0 +1,52 @@
+import { watch, renameSync, unlinkSync, type FSWatcher } from "node:fs";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { complete, readJson, taskId, writeJson } from "./ipc.mjs";
+
+/** Native Pi inbox and settlement events; never shuts down an idle TUI. */
+export default function workerBridge(pi: ExtensionAPI) {
+  const directory = process.env.PI_MULTI_HARNESS_DIR;
+  if (process.env.PI_MULTI_HARNESS_WORKER !== "1" || !directory) return;
+  let watcher: FSWatcher | undefined;
+  let id: string | undefined;
+  let summary = "";
+  let error: string | undefined;
+  const inbox = join(directory, "inbox.json");
+
+  function receive() {
+    let payload: { id?: string; task?: string } | undefined;
+    const processing = `${inbox}.processing`;
+    try {
+      renameSync(inbox, processing);
+      payload = readJson(processing);
+      unlinkSync(processing);
+      if (!payload?.id || !payload.task) throw new Error("Inbox requires id and task.");
+      pi.sendUserMessage(payload.task, { deliverAs: "followUp", expandPromptTemplates: false });
+      writeJson(join(directory, "ack.json"), { id: payload.id, status: "ok" });
+    } catch (cause) {
+      if ((cause as NodeJS.ErrnoException).code === "ENOENT") return;
+      writeJson(join(directory, "ack.json"), { id: payload?.id, status: "error", error: String(cause) });
+    }
+  }
+  pi.on("session_start", () => {
+    watcher = watch(directory, (_event, name) => { if (name?.toString() === "inbox.json") receive(); });
+    watcher.on("error", (cause) => console.error(`Multi-harness inbox watcher failed: ${cause.message}`));
+    receive();
+  });
+  pi.on("before_agent_start", (event) => {
+    id = event.messageType === "user" ? taskId(event.prompt) : undefined;
+    summary = "";
+    error = undefined;
+    writeJson(join(directory, "state.json"), { status: "running", id, at: Date.now() });
+  });
+  pi.on("agent_end", (event) => {
+    const last = event.messages.filter((message) => message.role === "assistant").at(-1);
+    summary = last?.content?.filter((part) => part.type === "text").map((part) => part.text).join("\n") ?? "";
+    error = last?.stopReason === "error" ? last.errorMessage || "Model error" : undefined;
+  });
+  pi.on("agent_settled", (event) => {
+    if (id) complete(directory, { id, status: error || event.aborted ? "failed" : "completed", summary, error: error ?? (event.aborted ? "Turn aborted" : undefined) });
+    else writeJson(join(directory, "state.json"), { status: "idle", at: Date.now() });
+  });
+  pi.on("session_shutdown", () => { watcher?.close(); });
+}