@h-rig/runtime 0.0.6-alpha.22 → 0.0.6-alpha.24

package/dist/bin/rig-agent-dispatch.js

@@ -568,8 +568,8 @@ var init_backend_bwrap = __esm(() => {
 
 // packages/runtime/src/control-plane/agent-wrapper.ts
 import { createRequire } from "module";
-import { resolve as resolve35 } from "path";
-import { existsSync as existsSync33, mkdirSync as mkdirSync19, writeFileSync as writeFileSync13 } from "fs";
+import { resolve as resolve36 } from "path";
+import { existsSync as existsSync34, mkdirSync as mkdirSync20, writeFileSync as writeFileSync13 } from "fs";
 
 // packages/runtime/src/control-plane/runtime/context.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -5518,6 +5518,21 @@ var GITHUB_KNOWN_HOSTS = [
   "github.com ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCj7ndNxQowgcQnjshcLrqPEiiphnt+VTTvDP6mHBL9j1aNUkY4Ue1gvwnGLVlOhGeYrnZaMgRK6+PKCUXaDbC7qtbW8gIkhL7aGCsOr/C56SJMy/BCZfxd1nWzAOxSDPgVsmerOBYfNqltV9/hWCqBywINIR+5dIg6JTJ72pcEpEjcYgXkE2YEFXV1JHnsKgbLWNlhScqb2UmyRkQyytRLtL+38TGxkxCflmO+5Z8CSSNY7GidjMIZ7Q4zMjA2n1nGrlTDkzwDCsw+wqFPGQA179cnfGWOWRVruj16z6XyvxvjJwbz0wQZ75XK5tKSb7FNyeIEs4TT4jk+S4dhPeAUC5y+bDYirYgM4GC7uEnztnZyaVWQ7B381AK4Qdrwt51ZqExKbQpTUNn+EjqoTwvqNj4kqx5QUCI0ThS/YkOxJCXmPUWZbhjpCg56i+2aB6CmK2JGhn57K5mj0MNdBXA4/WnwH6XoPWJzK5Nyu2zB3nAZp+S5hpQs+p1vN1/wsjk="
 ].join(`
 `);
+function resolveControlPlaneSourceRoot(projectRoot) {
+  const candidates = [
+    process.env.RIG_CONTROL_PLANE_SOURCE_ROOT?.trim(),
+    process.env.RIG_HOST_PROJECT_ROOT?.trim(),
+    resolve25(import.meta.dir, "../../../../.."),
+    projectRoot
+  ].filter((value) => Boolean(value));
+  for (const candidate of candidates) {
+    const root = resolve25(candidate);
+    if (existsSync24(resolve25(root, "packages/runtime/src/control-plane/pi-sessiond/bin.ts"))) {
+      return root;
+    }
+  }
+  return "";
+}
 async function runtimeEnv(projectRoot, runtime) {
   const bunBinaryPath = resolveBunBinaryPath();
   const bunDir = resolveBunInstallDir(bunBinaryPath);
@@ -5563,9 +5578,11 @@ async function runtimeEnv(projectRoot, runtime) {
   const runtimeRigGit = resolve25(runtime.binDir, runtimeRigGitFileName());
   const preferredShell = existsSync24(runtimeBash) ? runtimeBash : "/bin/bash";
   const nativeRuntimeLibraryPath = await materializeNativeRuntimeLibrary(runtime.binDir);
+  const controlPlaneSourceRoot = resolveControlPlaneSourceRoot(projectRoot);
   const env = {
     PROJECT_RIG_ROOT: projectRoot,
     RIG_HOST_PROJECT_ROOT: projectRoot,
+    ...controlPlaneSourceRoot ? { RIG_CONTROL_PLANE_SOURCE_ROOT: controlPlaneSourceRoot } : {},
     HOME: runtime.homeDir,
     TMPDIR: runtime.tmpDir,
     XDG_CACHE_HOME: runtime.cacheDir,
@@ -8884,6 +8901,163 @@ function formatJsonRpcError(error) {
   return parts.join(" ");
 }
 
+// packages/runtime/src/control-plane/pi-sessiond/launcher.ts
+import { randomBytes } from "crypto";
+import { existsSync as existsSync33, mkdirSync as mkdirSync19, readFileSync as readFileSync16, rmSync as rmSync13 } from "fs";
+import { dirname as dirname14, resolve as resolve35 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// packages/runtime/src/control-plane/pi-sessiond/client.ts
+class RigPiSessionDaemonClient {
+  baseUrl;
+  token;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.token = options.token;
+  }
+  static fromConnection(connection, token) {
+    if (connection.mode === "http")
+      return new RigPiSessionDaemonClient({ baseUrl: connection.baseUrl, token });
+    throw new Error("Unix-socket Rig Pi daemon connections are not implemented in this build; use loopback HTTP.");
+  }
+  async request(method, path, body) {
+    const response = await fetch(`${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`, {
+      method,
+      headers: {
+        authorization: `Bearer ${this.token}`,
+        ...body === undefined ? {} : { "content-type": "application/json" }
+      },
+      body: body === undefined ? undefined : JSON.stringify(body)
+    });
+    const text = await response.text();
+    const payload = text.trim() ? JSON.parse(text) : undefined;
+    if (!response.ok) {
+      const message = payload && typeof payload === "object" && !Array.isArray(payload) && typeof payload.error === "string" ? payload.error : text || response.statusText;
+      throw new Error(`Rig Pi session daemon request failed (${response.status}): ${message}`);
+    }
+    return payload;
+  }
+  webSocketUrl(path) {
+    const url = new URL(`${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    url.searchParams.set("token", this.token);
+    return url.toString();
+  }
+}
+
+// packages/runtime/src/control-plane/pi-sessiond/launcher.ts
+var BUILD_CONFIG2 = {};
+var BAKED_RIG_SOURCE_ROOT = BUILD_CONFIG2.RIG_SOURCE_ROOT ?? "";
+async function ensureRigPiSessionDaemon(input) {
+  const rootDir = resolve35(input.rootDir);
+  mkdirSync19(rootDir, { recursive: true });
+  const readyFile = resolve35(rootDir, "ready.json");
+  const existing = readDaemonReadyFile(readyFile);
+  const existingHandle = existing ? await tryReady(existing) : null;
+  if (existingHandle)
+    return existingHandle;
+  try {
+    rmSync13(readyFile, { force: true });
+  } catch {}
+  const token = randomBytes(32).toString("hex");
+  const binPath = resolveRigPiSessionDaemonBinPath(input.env);
+  const bunPath = input.env.RIG_BUN_PATH || process.execPath;
+  const proc = Bun.spawn([bunPath, binPath], {
+    cwd: rootDir,
+    env: {
+      ...input.env,
+      RIG_PI_SESSIOND_ROOT: rootDir,
+      RIG_PI_SESSIOND_TOKEN: token,
+      RIG_PI_SESSIOND_READY_FILE: readyFile,
+      RIG_PI_SESSIOND_HOST: "127.0.0.1",
+      RIG_PI_SESSIOND_PORT: "0",
+      ...input.version ? { RIG_VERSION: input.version } : {},
+      ...input.commit ? { RIG_GIT_COMMIT: input.commit } : {}
+    },
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: "inherit"
+  });
+  proc.unref();
+  const deadline = Date.now() + (input.timeoutMs ?? 15000);
+  while (Date.now() < deadline) {
+    const ready = readDaemonReadyFile(readyFile);
+    const handle = ready ? await tryReady(ready) : null;
+    if (handle)
+      return handle;
+    await sleep(100);
+  }
+  throw new Error(`Rig Pi session daemon did not become ready at ${readyFile}`);
+}
+function privateMetadataForDaemon(input) {
+  return { public: input.publicMetadata, daemonConnection: input.connection };
+}
+async function tryReady(ready) {
+  const host = typeof ready.host === "string" ? ready.host : "127.0.0.1";
+  const port = typeof ready.port === "number" ? ready.port : Number(ready.port);
+  const token = typeof ready.token === "string" ? ready.token : "";
+  if (!Number.isFinite(port) || port <= 0 || !token)
+    return null;
+  const baseUrl = `http://${host}:${port}`;
+  const client = new RigPiSessionDaemonClient({ baseUrl, token });
+  try {
+    await client.request("GET", "/health");
+  } catch {
+    return null;
+  }
+  return {
+    client,
+    connection: { mode: "http", baseUrl, tokenRef: tokenRefFromReady(ready) },
+    token,
+    ready
+  };
+}
+function tokenRefFromReady(ready) {
+  const token = typeof ready.token === "string" ? ready.token : "";
+  return token ? `inline:${token}` : "missing";
+}
+function resolveRigPiSessionDaemonBinPath(env) {
+  const explicit = env.RIG_PI_SESSIOND_BIN?.trim();
+  if (explicit)
+    return explicit;
+  const roots = [
+    env.RIG_CONTROL_PLANE_SOURCE_ROOT?.trim(),
+    BAKED_RIG_SOURCE_ROOT.trim(),
+    process.env.RIG_CONTROL_PLANE_SOURCE_ROOT?.trim(),
+    process.env.RIG_HOST_PROJECT_ROOT?.trim(),
+    process.env.PROJECT_RIG_ROOT?.trim()
+  ].filter((value) => Boolean(value));
+  for (const root of roots) {
+    const candidate = resolve35(root, "packages/runtime/src/control-plane/pi-sessiond/bin.ts");
+    if (existsSync33(candidate))
+      return candidate;
+  }
+  const moduleCandidate = fileURLToPath2(new URL("./bin.ts", import.meta.url));
+  if (existsSync33(moduleCandidate))
+    return moduleCandidate;
+  throw new Error("Unable to locate rig-pi-sessiond entrypoint. Set RIG_PI_SESSIOND_BIN or RIG_CONTROL_PLANE_SOURCE_ROOT to the Rig source checkout.");
+}
+function readDaemonReadyFile(path) {
+  if (!existsSync33(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync16(path, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+function resolveRigPiSessionDaemonRoot(stateDir) {
+  const root = resolve35(stateDir, "pi-sessiond");
+  mkdirSync19(dirname14(root), { recursive: true });
+  if (!existsSync33(root))
+    mkdirSync19(root, { recursive: true });
+  return root;
+}
+
 // packages/runtime/src/control-plane/agent-wrapper.ts
 var requireFromRuntime = createRequire(import.meta.url);
 async function finalizeRuntimeSnapshot(snapshotSidecar, providerCommand, exitCode, context) {
@@ -8918,7 +9092,7 @@ async function startOptionalRuntimeSnapshotSidecar(runtime, startSidecar = start
   }
 }
 async function runAgentWrapper(options = {}) {
-  const projectRoot = resolve35(options.projectRoot || process.env.PROJECT_RIG_ROOT || process.cwd());
+  const projectRoot = resolve36(options.projectRoot || process.env.PROJECT_RIG_ROOT || process.cwd());
   const monorepoRoot = resolveMonorepoRoot2(projectRoot);
   const argv = options.argv || process.argv.slice(2);
   if (argv.length === 0 || argv[0] === "--version" || argv[0] === "--help" || argv[0] === "help") {
@@ -8981,7 +9155,8 @@ async function runAgentWrapper(options = {}) {
     return 1;
   }
   const providerArgs = buildProviderArgs(provider, runtime, argv);
-  const providerCommand = [providerBinary(provider), ...providerArgs];
+  const normalPiDaemonPath = provider === "pi" && process.env.RIG_PI_RPC_FALLBACK !== "1";
+  const providerCommand = normalPiDaemonPath ? ["rig-pi-sessiond", ...providerArgs] : [providerBinary(provider), ...providerArgs];
   emitWrapperEvent("provider.launch", {
     provider,
     runtimeId: runtime.id,
@@ -8993,11 +9168,11 @@ async function runAgentWrapper(options = {}) {
   const bypassOuterRuntimeSandbox = shouldBypassProviderSandboxOnPlatform(provider, process.platform);
   const runClaudeCompatUnsandboxed = provider === "claude-code" && bypassOuterRuntimeSandbox;
   if (runClaudeCompatUnsandboxed && process.env.HOME?.trim()) {
-    env.CLAUDE_HOME = resolve35(process.env.HOME.trim(), ".claude");
+    env.CLAUDE_HOME = resolve36(process.env.HOME.trim(), ".claude");
     env.RIG_CLAUDE_RUNTIME_HOME = runtime.claudeHomeDir;
   }
   if (provider === "pi") {
-    env.PI_CODING_AGENT_DIR = resolve35(runtime.homeDir, ".pi", "agent");
+    env.PI_CODING_AGENT_DIR = resolve36(runtime.homeDir, ".pi", "agent");
     env.PI_CODING_AGENT_SESSION_DIR = runtime.sessionDir;
   }
   env.RIG_RUNTIME_SANDBOX = "enforce";
@@ -9031,9 +9206,19 @@ async function runAgentWrapper(options = {}) {
         },
         command: providerCommand
       })).command;
-      if (provider === "pi" && isPiRpcArgs(providerArgs)) {
+      if (provider === "pi" && process.env.RIG_PI_RPC_FALLBACK !== "1") {
         const prompt = await readProcessStdin();
-        exitCode = await runPiRpcProvider({
+        exitCode = await runPiSessionDaemonProvider({
+          projectRoot,
+          runtime,
+          env,
+          prompt,
+          runId: process.env.RIG_SERVER_RUN_ID?.trim() || process.env.RIG_RUN_ID?.trim() || undefined,
+          sessionName: process.env.RIG_SERVER_RUN_ID?.trim() ? `Rig ${process.env.RIG_SERVER_RUN_ID.trim()}` : `Rig ${runtime.taskId}`
+        });
+      } else if (provider === "pi" && isPiRpcArgs(providerArgs)) {
+        const prompt = await readProcessStdin();
+        exitCode = await runPiRpcProviderFallback({
           command,
           cwd: runtime.workspaceDir,
           env,
@@ -9164,7 +9349,129 @@ function steeringMessageText(entry) {
 function isPiRpcArgs(args) {
   return cliOptionValue(args, "--mode") === "rpc";
 }
-async function runPiRpcProvider(input) {
+async function runPiSessionDaemonProvider(input) {
+  const stdout = input.stdout ?? process.stdout;
+  const stderr = input.stderr ?? process.stderr;
+  const runId = input.runId ?? input.runtime.taskId;
+  emitWrapperEvent("pi.sessiond.starting", {
+    runId,
+    runtimeId: input.runtime.id,
+    workspaceDir: input.runtime.workspaceDir
+  });
+  const daemon = await ensureRigPiSessionDaemon({
+    rootDir: resolveRigPiSessionDaemonRoot(input.runtime.stateDir),
+    env: input.env,
+    version: process.env.RIG_VERSION?.trim() || "dev",
+    commit: process.env.RIG_GIT_COMMIT?.trim() || undefined
+  });
+  emitWrapperEvent("pi.sessiond.ready", {
+    runId,
+    runtimeId: input.runtime.id,
+    connection: daemon.connection,
+    ready: daemon.ready
+  });
+  const start = await daemon.client.request("POST", "/sessions", {
+    runId,
+    cwd: input.runtime.workspaceDir,
+    agentDir: input.env.PI_CODING_AGENT_DIR || resolve36(input.runtime.homeDir, ".pi", "agent"),
+    sessionDir: input.runtime.sessionDir,
+    sessionName: input.sessionName
+  });
+  const privateMetadata = privateMetadataForDaemon({ publicMetadata: start.metadata, connection: daemon.connection });
+  emitWrapperEvent("pi.session.ready", {
+    runId,
+    runtimeId: input.runtime.id,
+    metadata: start.metadata,
+    privateMetadata
+  });
+  const eventStream = waitForPiSessionEvents({
+    url: daemon.client.webSocketUrl(`/sessions/${encodeURIComponent(start.metadata.sessionId)}/events`),
+    stdout,
+    stderr,
+    runId
+  });
+  emitWrapperEvent("pi.session.event_stream.connected", { runId, sessionId: start.metadata.sessionId });
+  const forwardSigterm = () => {
+    daemon.client.request("POST", `/sessions/${encodeURIComponent(start.metadata.sessionId)}/abort`).catch(() => {
+      return;
+    });
+    eventStream.close();
+  };
+  process.once("SIGTERM", forwardSigterm);
+  try {
+    if (input.prompt.trim()) {
+      await daemon.client.request("POST", `/sessions/${encodeURIComponent(start.metadata.sessionId)}/prompt`, { text: input.prompt });
+      emitWrapperEvent("pi.prompt.sent", { runId, sessionId: start.metadata.sessionId, bytes: Buffer.byteLength(input.prompt) });
+    } else {
+      emitWrapperEvent("pi.prompt.waiting", { runId, sessionId: start.metadata.sessionId, reason: "empty-initial-prompt" });
+    }
+    const result = await eventStream.done;
+    if (result.error) {
+      stderr.write(`[rig-agent] Pi session daemon stream failed: ${result.error}
+`);
+      return 1;
+    }
+    return 0;
+  } finally {
+    process.off("SIGTERM", forwardSigterm);
+    eventStream.close();
+  }
+}
+function waitForPiSessionEvents(input) {
+  let closed = false;
+  let resolved = false;
+  let socket = null;
+  let resolveDone = () => {
+    return;
+  };
+  const done = new Promise((resolveDoneInner) => {
+    resolveDone = resolveDoneInner;
+  });
+  const finish = (value) => {
+    if (resolved)
+      return;
+    resolved = true;
+    resolveDone(value);
+  };
+  socket = new WebSocket(input.url);
+  socket.addEventListener("message", (message) => {
+    const text = typeof message.data === "string" ? message.data : Buffer.from(message.data).toString("utf8");
+    input.stdout.write(`${text}
+`);
+    const envelope = parseJsonRecord(text);
+    if (!envelope)
+      return;
+    if (envelope.type === "pi.event") {
+      const event = envelope.event && typeof envelope.event === "object" && !Array.isArray(envelope.event) ? envelope.event : null;
+      if (event?.type === "agent_end") {
+        emitWrapperEvent("pi.session.agent_end", { runId: input.runId, sessionId: envelope.sessionId });
+        finish({});
+      }
+    }
+    if (envelope.type === "error") {
+      emitWrapperEvent("pi.session.error", { runId: input.runId, message: envelope.message, detail: envelope.detail ?? null });
+      finish({ error: envelope.message });
+    }
+  });
+  socket.addEventListener("error", () => {
+    if (!closed)
+      finish({ error: "WebSocket error" });
+  });
+  socket.addEventListener("close", () => {
+    if (!closed && !resolved)
+      finish({ error: "WebSocket closed before agent_end" });
+  });
+  return {
+    done,
+    close: () => {
+      closed = true;
+      try {
+        socket?.close();
+      } catch {}
+    }
+  };
+}
+async function runPiRpcProviderFallback(input) {
   const stdout = input.stdout ?? process.stdout;
   const stderr = input.stderr ?? process.stderr;
   const proc = Bun.spawn(input.command, {
@@ -9231,7 +9538,7 @@ async function runPiRpcProvider(input) {
           error: error instanceof Error ? error.message : String(error)
         });
       }
-      await sleep(1000);
+      await sleep2(1000);
     }
   };
   const stdoutPump = pumpReadableLines(proc.stdout, (line) => {
@@ -9327,6 +9634,9 @@ function buildProviderArgs(provider, runtime, argv) {
   }
   if (provider === "pi") {
     const piArgs = [...argv];
+    if (piArgs.includes("__rig_pi_session_daemon__")) {
+      return piArgs.filter((arg) => arg !== "__rig_pi_session_daemon__");
+    }
     const piProvider = cliOptionValue(piArgs, "--provider") || process.env.RIG_PI_PROVIDER?.trim() || "openai-codex";
     if (!hasCliOption(piArgs, "--provider")) {
       piArgs.unshift(piProvider);
@@ -9457,8 +9767,8 @@ function resolveFromShellPath(binary) {
 function resolveBundledPiBinary() {
   try {
     const packageJson = requireFromRuntime.resolve("@earendil-works/pi-coding-agent/package.json");
-    const binaryPath = resolve35(packageJson, "..", "dist", "cli.js");
-    return existsSync33(binaryPath) ? binaryPath : null;
+    const binaryPath = resolve36(packageJson, "..", "dist", "cli.js");
+    return existsSync34(binaryPath) ? binaryPath : null;
   } catch {
     return null;
   }
@@ -9479,7 +9789,7 @@ function providerBinary(provider) {
 function emitWrapperEvent(type, payload) {
   console.log(`__RIG_WRAPPER_EVENT__${JSON.stringify({ type, payload, at: new Date().toISOString() })}`);
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
 }
 async function waitForDirtyBaselineReady(runtime, taskId) {
@@ -9494,11 +9804,11 @@ async function waitForDirtyBaselineReady(runtime, taskId) {
     workspaceDir: runtime.workspaceDir,
     readyFile
   });
-  while (!existsSync33(readyFile)) {
+  while (!existsSync34(readyFile)) {
     if (Date.now() >= deadline) {
       throw new Error(`Timed out waiting for dirty baseline ready file: ${readyFile}`);
     }
-    await sleep(50);
+    await sleep2(50);
   }
   emitWrapperEvent("runtime.baseline.completed", {
     runtimeId: runtime.id,
@@ -9562,9 +9872,9 @@ async function readPluginTaskStatus(projectRoot, taskId) {
   }
 }
 function recordRuntimeHandoff(hostProjectRoot, runtime, taskId, exitCode) {
-  const handoffDir = resolve35(hostProjectRoot, ".rig/runtime/handoffs");
-  mkdirSync19(handoffDir, { recursive: true });
-  const handoffPath = resolve35(handoffDir, `${taskId}-${Date.now()}.json`);
+  const handoffDir = resolve36(hostProjectRoot, ".rig/runtime/handoffs");
+  mkdirSync20(handoffDir, { recursive: true });
+  const handoffPath = resolve36(handoffDir, `${taskId}-${Date.now()}.json`);
   const handoff = {
     taskId,
     runtimeId: runtime.id,
@@ -9630,13 +9940,13 @@ async function readTaskMetadata2(taskRoot, taskId) {
 async function readTaskConfigHints(taskRoot, taskId) {
   const runtimeContext = loadRuntimeContextFromEnv();
   const candidates = [
-    runtimeContext?.monorepoMainRoot ? resolve35(runtimeContext.monorepoMainRoot, ".rig", "task-config.json") : "",
-    process.env.MONOREPO_MAIN_ROOT?.trim() ? resolve35(process.env.MONOREPO_MAIN_ROOT.trim(), ".rig", "task-config.json") : "",
-    resolve35(taskRoot, ".rig", "task-config.json"),
-    resolve35(taskRoot, "rig", "task-config.json")
+    runtimeContext?.monorepoMainRoot ? resolve36(runtimeContext.monorepoMainRoot, ".rig", "task-config.json") : "",
+    process.env.MONOREPO_MAIN_ROOT?.trim() ? resolve36(process.env.MONOREPO_MAIN_ROOT.trim(), ".rig", "task-config.json") : "",
+    resolve36(taskRoot, ".rig", "task-config.json"),
+    resolve36(taskRoot, "rig", "task-config.json")
   ].filter(Boolean);
   for (const configPath of candidates) {
-    if (!existsSync33(configPath)) {
+    if (!existsSync34(configPath)) {
       continue;
     }
     try {