@parall/daemon 1.28.0 → 1.28.1

package/dist/supervisor.js

@@ -4,6 +4,11 @@ import * as path from "node:path";
 import { ParallWs } from "@parall/sdk";
 import { agentClaudeCredentialsFileFor, agentClaudeHomeFor, agentStateDirFor, agentWorkspaceDirFor, sharedClaudeCredentialsFileFor, } from "./config.js";
 import { assertAgentKey, getRuntimeAdapter } from "./runtimes.js";
+const RUNTIME_PACKAGES = {
+    'claude-code': '@parall/claude-agent',
+    'codex': '@parall/codex-agent',
+    'openclaw': '@parall/openclaw-agent',
+};
 /**
  * Sleep that wakes early on abort. Returns true if the full delay elapsed,
  * false if aborted. Used by bootstrap retry and the outer keepalive in
@@ -71,6 +76,7 @@ export class DaemonSupervisor {
             this.running = false;
             throw err;
         }
+        this.migrateFlatLayout();
         await this.fullReconcile();
         this.ws = new ParallWs({
             getTicket: () => this.client.getMachineWsTicket(),
@@ -209,6 +215,54 @@ export class DaemonSupervisor {
             }
         }
     }
+    // ---- Flat layout migration (self-hosted → daemon) ----
+    /**
+     * Detects a legacy flat state layout (no agents/ subdir) and migrates it
+     * into the per-agent directory for the owning agent. Ownership is determined
+     * by parsing session state files which embed the agent ID in the runtimeKey.
+     */
+    migrateFlatLayout() {
+        const root = this.config.rootStateDir;
+        const agentsDir = path.join(root, "agents");
+        const flatWorkspace = path.join(root, "workspace");
+        if (!fs.existsSync(flatWorkspace) || fs.existsSync(agentsDir))
+            return;
+        let ownerAgentId;
+        const sessionsDir = path.join(root, "sessions");
+        if (fs.existsSync(sessionsDir)) {
+            try {
+                for (const file of fs.readdirSync(sessionsDir)) {
+                    if (!file.endsWith(".json"))
+                        continue;
+                    const decoded = Buffer.from(file.replace(".json", ""), "base64url").toString();
+                    // runtimeKey format: "agent:main:{runtime}:{agentId}:orchestrator"
+                    const parts = decoded.split(":");
+                    if (parts.length >= 4 && parts[3].startsWith("usr_")) {
+                        ownerAgentId = parts[3];
+                        break;
+                    }
+                }
+            }
+            catch {
+                // best-effort scan
+            }
+        }
+        const targetId = ownerAgentId ?? "_orphan";
+        const targetDir = path.join(agentsDir, targetId);
+        try {
+            fs.mkdirSync(targetDir, { recursive: true });
+            for (const sub of ["workspace", "sessions", "dispatch-context"]) {
+                const src = path.join(root, sub);
+                if (fs.existsSync(src)) {
+                    fs.renameSync(src, path.join(targetDir, sub));
+                }
+            }
+            this.log.info(`migrated legacy flat state → agents/${targetId}/`);
+        }
+        catch (err) {
+            this.log.warn(`flat layout migration failed: ${String(err)}`);
+        }
+    }
     // ---- WS event handlers (incremental) ----
     async handleAgentAttached(agentId) {
         if (this.children.has(agentId))
@@ -275,13 +329,23 @@ export class DaemonSupervisor {
             return;
         }
         const stateDir = agentStateDirFor(this.config.rootStateDir, agentId);
-        const workspaceDir = agentWorkspaceDirFor(this.config.rootStateDir, agentId);
-        const claudeHome = agentClaudeHomeFor(this.config.rootClaudeHome, agentId);
+        const workspaceDir = attached.daemon_config?.workspace_path
+            || agentWorkspaceDirFor(this.config.rootStateDir, agentId);
+        const isK8s = !!process.env.KUBERNETES_SERVICE_HOST;
+        const claudeHome = isK8s
+            ? agentClaudeHomeFor(this.config.rootClaudeHome, agentId)
+            : this.config.rootClaudeHome;
         try {
             fs.mkdirSync(stateDir, { recursive: true });
-            fs.mkdirSync(workspaceDir, { recursive: true });
-            fs.mkdirSync(claudeHome, { recursive: true });
-            this.ensureSharedCredentialLink(claudeHome, agentId);
+            // Only create workspace dir when using the default isolated path —
+            // user-specified workspace_path should already exist.
+            if (!attached.daemon_config?.workspace_path) {
+                fs.mkdirSync(workspaceDir, { recursive: true });
+            }
+            if (isK8s) {
+                fs.mkdirSync(claudeHome, { recursive: true });
+                this.ensureSharedCredentialLink(claudeHome, agentId);
+            }
         }
         catch (err) {
             this.log.warn(`mkdir agent dirs (${agentId}) failed: ${String(err)}`);
@@ -291,6 +355,8 @@ export class DaemonSupervisor {
             agentId,
             orgId,
             runtimeType,
+            workspacePath: workspaceDir,
+            claudeHome,
             child: null,
             credential,
             restartAttempts: 0,
@@ -311,8 +377,8 @@ export class DaemonSupervisor {
         const adapter = getRuntimeAdapter(state.runtimeType);
         const dirs = {
             stateDir: agentStateDirFor(this.config.rootStateDir, state.agentId),
-            workspaceDir: agentWorkspaceDirFor(this.config.rootStateDir, state.agentId),
-            claudeHome: agentClaudeHomeFor(this.config.rootClaudeHome, state.agentId),
+            workspaceDir: state.workspacePath,
+            claudeHome: state.claudeHome,
         };
         const env = adapter.buildEnv({ ...process.env, PRLL_API_URL: this.config.apiUrl }, state.agentId, state.orgId, state.credential.api_key, dirs);
         this.log.info(`spawning agent ${state.agentId} runtime=${state.runtimeType} bin=${adapter.bin} (attempt ${state.restartAttempts + 1})`);
@@ -347,7 +413,13 @@ export class DaemonSupervisor {
                 this.startChild(state);
             }, delay);
         };
-        child.once("error", (err) => settleChild("error", null, null, err));
+        child.once("error", (err) => {
+            if (err.code === 'ENOENT') {
+                const pkg = RUNTIME_PACKAGES[state.runtimeType] ?? `@parall/${state.runtimeType}-agent`;
+                this.log.error(`Runtime binary "${adapter.bin}" not found in PATH. Install: npm install -g ${pkg}`);
+            }
+            settleChild("error", null, null, err);
+        });
         child.once("close", (code, signal) => settleChild("close", code, signal));
         setTimeout(() => {
             if (state.child === child) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@parall/daemon",
-  "version": "1.28.0",
-  "description": "Per-host supervisor for daemon-mode Parall Machines — fans one mck_ bearer out into N agent-runtime subprocesses, one per attached agent",
+  "version": "1.28.1",
+  "description": "Parall local agent runtime — daemon supervisor + bridge runtimes, bundled as standalone JS files",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -9,10 +9,13 @@
     "directory": "ts/daemon"
   },
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./bundle/parall-daemon.js",
   "types": "./dist/index.d.ts",
   "bin": {
-    "parall-daemon": "./dist/index.js"
+    "parall-daemon": "./bundle/parall-daemon.js",
+    "parall-claude-agent": "./bundle/parall-claude-agent.js",
+    "parall-codex-agent": "./bundle/parall-codex-agent.js",
+    "parall-openclaw-agent": "./bundle/parall-openclaw-agent.js"
   },
   "exports": {
     ".": {
@@ -21,18 +24,23 @@
     }
   },
   "files": [
-    "dist",
-    "src"
+    "bundle",
+    "dist"
   ],
   "dependencies": {
-    "@parall/sdk": "1.28.0"
+    "@parall/sdk": "1.28.1",
+    "@parall/claude-agent": "1.28.1",
+    "@parall/codex-agent": "1.28.1",
+    "@parall/openclaw-agent": "1.28.1"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "esbuild": "^0.25.0",
     "typescript": "^5.7.0"
   },
   "scripts": {
     "build": "tsc -b",
-    "start": "node dist/index.js"
+    "bundle": "node ../../scripts/bundle-daemon.mjs",
+    "start": "node bundle/parall-daemon.js"
   }
 }

package/src/config.ts

@@ -1,146 +0,0 @@
-import * as os from "node:os";
-import * as path from "node:path";
-
-/**
- * Daemon-mode env. The daemon authenticates to the Parall API with an
- * `mck_*` bearer token (PRLL_API_KEY) and supervises N per-agent
- * `parall-claude-agent` subprocesses on this host.
- *
- * Compared to claude-agent's config:
- *   - `apiKey` is an mck_ bearer (Machine-scoped), not an agk_
- *   - there is no PRLL_ORG_ID — the Machine row's org_id is implicit;
- *     each spawned per-agent subprocess is given its own PRLL_ORG_ID
- *     resolved from the AttachedAgent's profile / org context
- *   - per-agent state lives at `<rootStateDir>/agents/<agent_id>/`
- */
-export type ClaudeDaemonConfig = {
-  apiUrl: string;
-  /** mck_*-prefixed Machine bearer. */
-  apiKey: string;
-  /** @deprecated Superseded by RuntimeAdapter pattern (runtimes.ts). Kept for backward compat / fallback. */
-  agentBin: string;
-  /** Root for per-agent state dirs. Each agent gets `<rootStateDir>/agents/<agent_id>`. */
-  rootStateDir: string;
-  /** Shared host home root. Per-agent HOME dirs live under `<rootClaudeHome>/agents/<agent_id>`. */
-  rootClaudeHome: string;
-  /** Optional WS URL override for the machine control-plane WebSocket. */
-  wsUrl?: string;
-  /** @deprecated Superseded by WS event-driven model; kept for backward compat. */
-  pollIntervalMs: number;
-  /** @deprecated Superseded by WS event-driven model; kept for backward compat. */
-  heartbeatIntervalMs: number;
-  /** Backoff base after a subprocess crash, in ms. */
-  restartBackoffMs: number;
-  /** Hard cap on parallel restart attempts per agent before giving up for a cycle. */
-  restartBackoffMaxMs: number;
-  /**
-   * Bootstrap retry: when `getMachineSelf` fails on startup (network blip,
-   * mck_ key not yet propagated, server warming up), wait this long and
-   * retry instead of crashing the daemon. Exponential backoff up to
-   * `bootstrapBackoffMaxMs`. Set 0 to disable (fail-fast on first error).
-   */
-  bootstrapBackoffMs: number;
-  bootstrapBackoffMaxMs: number;
-  /**
-   * Outer supervisor keepalive: if `supervisor.run()` rejects with an
-   * unexpected error, wait this long and reinstantiate. Same exp-backoff
-   * shape as bootstrap. Set 0 to disable (let main() exit, rely on K8s/PID-1).
-   */
-  supervisorRestartBackoffMs: number;
-  supervisorRestartBackoffMaxMs: number;
-};
-
-function requireEnv(env: NodeJS.ProcessEnv, name: string): string {
-  const value = env[name]?.trim();
-  if (!value) {
-    throw new Error(`Missing required env var: ${name}`);
-  }
-  return value;
-}
-
-function resolvePath(value: string): string {
-  return path.isAbsolute(value) ? value : path.resolve(process.cwd(), value);
-}
-
-function parseMs(value: string | undefined, fallback: number): number {
-  if (!value) return fallback;
-  const n = Number(value);
-  return Number.isFinite(n) && n > 0 ? n : fallback;
-}
-
-/** Like parseMs but allows 0 (operator opt-out). */
-function parseMsAllowZero(value: string | undefined, fallback: number): number {
-  if (value === undefined) return fallback;
-  const n = Number(value);
-  return Number.isFinite(n) && n >= 0 ? n : fallback;
-}
-
-export function resolveClaudeDaemonConfig(env: NodeJS.ProcessEnv = process.env): ClaudeDaemonConfig {
-  const apiUrl = requireEnv(env, "PRLL_API_URL");
-  const apiKey = requireEnv(env, "PRLL_API_KEY");
-  if (!apiKey.startsWith("mck_")) {
-    // Fatal startup validation: the daemon must never run with an agent or
-    // human key because child launch credentials are minted from this bearer.
-    throw new Error(
-      `PRLL_API_KEY does not look like a Machine bearer (expected prefix "mck_"). ` +
-        `Daemon mode requires a machine-scoped key issued via POST /machines/{id}/keys.`,
-    );
-  }
-  const rootClaudeHome = resolvePath(env.PRLL_CLAUDE_HOME?.trim() || env.HOME || os.homedir());
-  const rootStateDir = resolvePath(env.PRLL_CLAUDE_STATE_DIR?.trim() || path.join(rootClaudeHome, ".parall-agent"));
-
-  return {
-    apiUrl,
-    apiKey,
-    agentBin: env.PRLL_CLAUDE_AGENT_BIN?.trim() || "parall-claude-agent",
-    rootStateDir,
-    rootClaudeHome,
-    wsUrl: env.PRLL_WS_URL?.trim() || undefined,
-    pollIntervalMs: parseMs(env.PRLL_DAEMON_POLL_INTERVAL_MS, 30_000),
-    heartbeatIntervalMs: parseMs(env.PRLL_DAEMON_HEARTBEAT_INTERVAL_MS, 30_000),
-    restartBackoffMs: parseMs(env.PRLL_DAEMON_RESTART_BACKOFF_MS, 5_000),
-    restartBackoffMaxMs: parseMs(env.PRLL_DAEMON_RESTART_BACKOFF_MAX_MS, 5 * 60_000),
-    bootstrapBackoffMs: parseMsAllowZero(env.PRLL_DAEMON_BOOTSTRAP_BACKOFF_MS, 2_000),
-    bootstrapBackoffMaxMs: parseMs(env.PRLL_DAEMON_BOOTSTRAP_BACKOFF_MAX_MS, 60_000),
-    supervisorRestartBackoffMs: parseMsAllowZero(env.PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MS, 5_000),
-    supervisorRestartBackoffMaxMs: parseMs(env.PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MAX_MS, 5 * 60_000),
-  };
-}
-
-function assertSafeAgentId(agentId: string): string {
-  if (!/^[A-Za-z0-9_-]+$/.test(agentId)) {
-    throw new Error(`Invalid agentId for filesystem path: ${agentId}`);
-  }
-  return agentId;
-}
-
-/** Per-agent state dir under the shared host volume. */
-export function agentStateDirFor(rootStateDir: string, agentId: string): string {
-  return path.join(rootStateDir, "agents", assertSafeAgentId(agentId));
-}
-
-/** Per-agent HOME dir. Claude Code stores project/session state under
- * `${HOME}/.claude`, so each agent gets its own HOME root while the daemon
- * links shared OAuth credentials into that `.claude` directory. */
-export function agentClaudeHomeFor(rootClaudeHome: string, agentId: string): string {
-  return path.join(rootClaudeHome, "agents", assertSafeAgentId(agentId));
-}
-
-/** Shared Claude Code OAuth credential written by server-side runtime auth. */
-export function sharedClaudeCredentialsFileFor(rootClaudeHome: string): string {
-  return path.join(rootClaudeHome, ".claude", ".credentials.json");
-}
-
-/** Per-agent credential location inside that agent's isolated HOME. */
-export function agentClaudeCredentialsFileFor(agentClaudeHome: string): string {
-  return path.join(agentClaudeHome, ".claude", ".credentials.json");
-}
-
-/** Per-agent workspace dir where the agent runs git commands. */
-export function agentWorkspaceDirFor(rootStateDir: string, agentId: string): string {
-  return path.join(rootStateDir, "agents", assertSafeAgentId(agentId), "workspace");
-}
-
-export function resolveWsUrl(apiUrl: string, explicitWsUrl?: string): string {
-  return explicitWsUrl || `${apiUrl.replace(/\/$/, "").replace(/^http/, "ws")}/ws`;
-}

package/src/index.ts

@@ -1,132 +0,0 @@
-#!/usr/bin/env node
-
-import { ParallClient } from "@parall/sdk";
-import { resolveClaudeDaemonConfig, resolveWsUrl, type ClaudeDaemonConfig } from "./config.js";
-import { DaemonSupervisor, sleepCancellable, type DaemonLogger } from "./supervisor.js";
-
-function createLogger(prefix: string): DaemonLogger {
-  return {
-    info: (msg: string) => console.log(`[${prefix}] ${msg}`),
-    warn: (msg: string) => console.warn(`[${prefix}] ${msg}`),
-    error: (msg: string) => console.error(`[${prefix}] ${msg}`),
-  };
-}
-
-function formatError(reason: unknown): string {
-  if (reason instanceof Error) {
-    return reason.stack ?? reason.message;
-  }
-  return String(reason);
-}
-
-/**
- * Outer keepalive: runs `supervisor.run()` in a loop, restarting it with
- * exponential backoff if it rejects. The daemon process only exits when
- * the abort signal fires (SIGINT/SIGTERM) — anything else is treated as
- * a transient failure that we recover from in-process.
- *
- * Why this exists in addition to entrypoint.sh's `while :; do parall-daemon; done`:
- *   - In-process restart preserves the `client` (= same TCP/TLS pool) and
- *     skips the ~hundreds-of-ms cost of Node startup + module loading per
- *     cycle, which matters when the API is flapping.
- *   - The shell wrapper is the "process really crashed" backstop —
- *     segfault, OOM, uncaughtException, etc. The two layers are
- *     complementary: in-process for soft failures, shell for hard failures.
- *
- * Operators can disable the in-process loop by setting
- * PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MS=0 — main() will then exit on
- * any supervisor.run() rejection and rely entirely on the shell wrapper +
- * K8s for restart.
- */
-async function runForever(
-  config: ClaudeDaemonConfig,
-  client: ParallClient,
-  log: DaemonLogger,
-  signal: AbortSignal,
-): Promise<void> {
-  let attempt = 0;
-  while (!signal.aborted) {
-    const supervisor = new DaemonSupervisor(config, client, log);
-    try {
-      await supervisor.run(signal);
-      // Clean exit (signal aborted) — done.
-      await supervisor.stop();
-      return;
-    } catch (err) {
-      // supervisor.run() rejected. The supervisor's per-tick handlers
-      // already swallow individual failures, so the only paths that reach
-      // here are (a) bootstrap fail-fast mode and (b) genuine programmer
-      // bugs. Restart anyway — operators rely on this daemon as the only
-      // thing keeping per-agent children alive on this host.
-      log.error(`supervisor crashed: ${String(err)}`);
-      try {
-        await supervisor.stop();
-      } catch (stopErr) {
-        log.warn(`supervisor.stop() after crash threw: ${String(stopErr)}`);
-      }
-      if (config.supervisorRestartBackoffMs === 0) {
-        log.error(
-          "supervisor keepalive disabled (PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MS=0) — exiting",
-        );
-        throw err;
-      }
-      const delay = Math.min(
-        config.supervisorRestartBackoffMs * Math.pow(2, attempt),
-        config.supervisorRestartBackoffMaxMs,
-      );
-      attempt += 1;
-      log.warn(`restarting supervisor in ${delay}ms (attempt ${attempt})`);
-      const slept = await sleepCancellable(delay, signal);
-      if (!slept) return;
-    }
-  }
-}
-
-async function main(): Promise<void> {
-  const config = resolveClaudeDaemonConfig(process.env);
-  const log = createLogger("daemon");
-
-  log.info(
-    `boot: api=${config.apiUrl} pollMs=${config.pollIntervalMs} heartbeatMs=${config.heartbeatIntervalMs} agentBin=${config.agentBin}`,
-  );
-  log.info(
-    `keepalive: bootstrapBackoffMs=${config.bootstrapBackoffMs} supervisorRestartBackoffMs=${config.supervisorRestartBackoffMs}`,
-  );
-
-  // The daemon talks to the API as a Machine — the bearer is mck_*.
-  // No orgId is configured here; per-agent subprocesses get their
-  // own org_id via the spawn env.
-  const client = new ParallClient({
-    baseUrl: config.apiUrl,
-    token: config.apiKey,
-  });
-
-  const abortController = new AbortController();
-  const onSignal = (sig: NodeJS.Signals) => {
-    log.info(`received ${sig} — initiating shutdown`);
-    abortController.abort();
-  };
-  process.on("SIGINT", () => onSignal("SIGINT"));
-  process.on("SIGTERM", () => onSignal("SIGTERM"));
-
-  // Defensive: unexpected async failures are logged explicitly. Rejections
-  // stay in-process so the supervisor loop can recover; uncaught exceptions
-  // exit so entrypoint.sh's shell-level keepalive restarts from a clean VM.
-  process.on("unhandledRejection", (reason) => {
-    log.error(`unhandledRejection: ${formatError(reason)}`);
-  });
-  process.on("uncaughtException", (err) => {
-    log.error(`uncaughtException: ${formatError(err)}`);
-    process.exitCode = 1;
-    process.exit(1);
-  });
-
-  config.wsUrl = resolveWsUrl(config.apiUrl, config.wsUrl);
-
-  await runForever(config, client, log, abortController.signal);
-}
-
-main().catch((err) => {
-  console.error(`[daemon] fatal: ${formatError(err)}`);
-  process.exitCode = 1;
-});

package/src/runtimes.ts

@@ -1,91 +0,0 @@
-export interface RuntimeAdapter {
-  bin: string;
-  buildEnv(baseEnv: NodeJS.ProcessEnv, agentId: string, orgId: string, apiKey: string, dirs: AgentDirs): NodeJS.ProcessEnv;
-}
-
-export interface AgentDirs {
-  stateDir: string;
-  workspaceDir: string;
-  claudeHome: string;
-}
-
-const claudeCodeAdapter: RuntimeAdapter = {
-  bin: "parall-claude-agent",
-  buildEnv(baseEnv, agentId, orgId, apiKey, dirs) {
-    const env = { ...baseEnv };
-    env.PRLL_API_KEY = apiKey;
-    env.PRLL_ORG_ID = orgId;
-    env.AGENT_ID = agentId;
-    env.PRLL_AGENT_ID = agentId;
-    env.PRLL_CLAUDE_HOME = dirs.claudeHome;
-    env.PRLL_CLAUDE_STATE_DIR = dirs.stateDir;
-    env.PRLL_CLAUDE_WORKSPACE_DIR = dirs.workspaceDir;
-    if ("ANTHROPIC_AUTH_TOKEN" in env) {
-      env.ANTHROPIC_AUTH_TOKEN = apiKey;
-    }
-    delete env.PRLL_DAEMON_MODE;
-    return env;
-  },
-};
-
-const codexAdapter: RuntimeAdapter = {
-  bin: "parall-codex-agent",
-  buildEnv(baseEnv, agentId, orgId, apiKey, dirs) {
-    const env = { ...baseEnv };
-    env.PRLL_API_KEY = apiKey;
-    env.PRLL_ORG_ID = orgId;
-    env.AGENT_ID = agentId;
-    env.PRLL_AGENT_ID = agentId;
-    env.PRLL_CODEX_STATE_DIR = dirs.stateDir;
-    env.PRLL_CODEX_WORKSPACE_DIR = dirs.workspaceDir;
-    delete env.PRLL_DAEMON_MODE;
-    return env;
-  },
-};
-
-const defaultAdapter: RuntimeAdapter = {
-  bin: "parall-agent",
-  buildEnv(baseEnv, agentId, orgId, apiKey, dirs) {
-    const env = { ...baseEnv };
-    env.PRLL_API_KEY = apiKey;
-    env.PRLL_ORG_ID = orgId;
-    env.AGENT_ID = agentId;
-    env.PRLL_AGENT_ID = agentId;
-    env.PRLL_STATE_DIR = dirs.stateDir;
-    env.PRLL_WORKSPACE_DIR = dirs.workspaceDir;
-    delete env.PRLL_DAEMON_MODE;
-    return env;
-  },
-};
-
-const openclawAdapter: RuntimeAdapter = {
-  bin: "parall-openclaw-agent",
-  buildEnv(baseEnv, agentId, orgId, apiKey, dirs) {
-    const env = { ...baseEnv };
-    env.PRLL_API_KEY = apiKey;
-    env.PRLL_ORG_ID = orgId;
-    env.AGENT_ID = agentId;
-    env.PRLL_AGENT_ID = agentId;
-    env.PRLL_OPENCLAW_STATE_DIR = dirs.stateDir;
-    env.PRLL_OPENCLAW_WORKSPACE_DIR = dirs.workspaceDir;
-    env.OPENCLAW_GATEWAY_PORT = env.OPENCLAW_GATEWAY_PORT || "0";
-    delete env.PRLL_DAEMON_MODE;
-    return env;
-  },
-};
-
-const RUNTIME_ADAPTERS: Record<string, RuntimeAdapter> = {
-  "claude-code": claudeCodeAdapter,
-  "codex": codexAdapter,
-  "openclaw": openclawAdapter,
-};
-
-export function getRuntimeAdapter(runtimeType: string): RuntimeAdapter {
-  return RUNTIME_ADAPTERS[runtimeType] ?? defaultAdapter;
-}
-
-export function assertAgentKey(apiKey: string): void {
-  if (apiKey.startsWith("mck_")) {
-    throw new Error("BUG: machine key leaked to child process — expected agk_, got mck_");
-  }
-}