tryharness 0.7.23 → 0.7.26

package/lib/runner.mjs

@@ -19,7 +19,9 @@ export function stopAgentTask(runId) {
 export function trackRun(runId, stop) {
   const entry = { pid: null, kill: stop };
   children.set(runId, entry);
-  return () => { if (children.get(runId) === entry) children.delete(runId); };
+  return () => {
+    if (children.get(runId) === entry) children.delete(runId);
+  };
 }
 
 /** A short command the daemon runs itself (an agent listing its models): while it runs, not the person's session either. */
@@ -35,11 +37,18 @@ export function runningPids() {
 }
 
 export function resolveWorkingDirectory(requested) {
-  if (!requested || !path.isAbsolute(requested)) throw new Error("Delegated tasks require an absolute working directory.");
+  if (!requested || !path.isAbsolute(requested))
+    throw new Error("Delegated tasks require an absolute working directory.");
   let stat;
-  try { stat = fs.statSync(requested); }
-  catch { throw new Error(`Delegated task directory does not exist: ${requested}`); }
-  if (!stat.isDirectory()) throw new Error(`Delegated task working directory is not a directory: ${requested}`);
+  try {
+    stat = fs.statSync(requested);
+  } catch {
+    throw new Error(`Delegated task directory does not exist: ${requested}`);
+  }
+  if (!stat.isDirectory())
+    throw new Error(
+      `Delegated task working directory is not a directory: ${requested}`
+    );
   return requested;
 }
 
@@ -49,44 +58,141 @@ export function resolveWorkingDirectory(requested) {
 export const RESTRICTED_CLAUDE_SETTINGS = {
   disableAllHooks: true,
   permissions: { deny: ["WebFetch", "WebSearch"] },
-  sandbox: { enabled: true, autoAllowBashIfSandboxed: true, allowUnsandboxedCommands: false, failIfUnavailable: true, excludedCommands: [], network: { allowedDomains: [], strictAllowlist: true } },
+  sandbox: {
+    enabled: true,
+    autoAllowBashIfSandboxed: true,
+    allowUnsandboxedCommands: false,
+    failIfUnavailable: true,
+    excludedCommands: [],
+    network: { allowedDomains: [], strictAllowlist: true },
+  },
 };
 // Only the Harness board MCP, as Claude Code: none of the person's other MCP servers or claude.ai connectors load.
-export const restrictedMcpConfig = () => ({ mcpServers: { harness: { command: process.execPath, args: [fileURLToPath(new URL("./mcp-stdio.mjs", import.meta.url)), "--agent", "claude-code"] } } });
-const restrictedClaude = (task) => ["--permission-mode", "dontAsk", "--allowedTools", task.readOnly ? "mcp__harness" : "Edit Write mcp__harness",
-  "--setting-sources", "user", "--settings", JSON.stringify(RESTRICTED_CLAUDE_SETTINGS), "--strict-mcp-config", "--mcp-config", JSON.stringify(restrictedMcpConfig())];
+export const restrictedMcpConfig = () => ({
+  mcpServers: {
+    harness: {
+      command: process.execPath,
+      args: [
+        fileURLToPath(new URL("./mcp-stdio.mjs", import.meta.url)),
+        "--agent",
+        "claude-code",
+      ],
+    },
+  },
+});
+const restrictedClaude = (task) => [
+  "--permission-mode",
+  "dontAsk",
+  "--allowedTools",
+  task.readOnly ? "mcp__harness" : "Edit Write mcp__harness",
+  "--setting-sources",
+  "user",
+  "--settings",
+  JSON.stringify(RESTRICTED_CLAUDE_SETTINGS),
+  "--strict-mcp-config",
+  "--mcp-config",
+  JSON.stringify(restrictedMcpConfig()),
+];
 
 // The model and effort the relay chose for the run (models.mjs), in each agent's own flags; none leaves its settings as they are.
 const MODEL_FLAGS = {
-  "claude-code": { model: (id) => ["--model", id], effort: (level) => ["--effort", level] },
-  codex: { model: (id) => ["-m", id], effort: (level) => ["-c", `model_reasoning_effort="${level}"`] },
-  pi: { model: (id) => ["--model", id], effort: (level) => ["--thinking", level] },
-  opencode: { model: (id) => ["-m", id], effort: (level) => ["--variant", level] },
+  "claude-code": {
+    model: (id) => ["--model", id],
+    effort: (level) => ["--effort", level],
+  },
+  codex: {
+    model: (id) => ["-m", id],
+    effort: (level) => ["-c", `model_reasoning_effort="${level}"`],
+  },
+  pi: {
+    model: (id) => ["--model", id],
+    effort: (level) => ["--thinking", level],
+  },
+  opencode: {
+    model: (id) => ["-m", id],
+    effort: (level) => ["--variant", level],
+  },
 };
-const modelFlags = ({ agent, model, effort }) => [...(model ? MODEL_FLAGS[agent]?.model(model) ?? [] : []), ...(effort ? MODEL_FLAGS[agent]?.effort(effort) ?? [] : [])];
+const modelFlags = ({ agent, model, effort }) => [
+  ...(model ? (MODEL_FLAGS[agent]?.model(model) ?? []) : []),
+  ...(effort ? (MODEL_FLAGS[agent]?.effort(effort) ?? []) : []),
+];
 
 export function agentInvocation(task) {
   if (task.agent === "claude-code") {
     return {
       command: "claude",
       // A review reads and reports: plan mode lets Claude Code read and run read-only tools but never edit.
-      args: ["-p", task.brief, "--output-format", "stream-json", "--verbose", ...(task.restricted ? restrictedClaude(task) : task.readOnly ? ["--permission-mode", "plan"] : ["--dangerously-skip-permissions"]), "--name", `Harness: ${task.title}`, ...modelFlags(task), ...(task.resumeSession ? ["--resume", task.resumeSession] : [])],
+      args: [
+        "-p",
+        task.brief,
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        ...(task.restricted
+          ? restrictedClaude(task)
+          : task.readOnly
+            ? ["--permission-mode", "plan"]
+            : ["--dangerously-skip-permissions"]),
+        "--name",
+        `Harness: ${task.title}`,
+        ...modelFlags(task),
+        ...(task.resumeSession ? ["--resume", task.resumeSession] : []),
+      ],
     };
   }
   // Only Claude Code has a restricted mode; any other agent's restricted run is refused here, whatever let it start.
-  if (task.restricted) throw new Error(`${task.agent} has no restricted mode; it runs only after the person's Start`);
+  if (task.restricted)
+    throw new Error(
+      `${task.agent} has no restricted mode; it runs only after the person's Start`
+    );
   if (task.agent === "codex") {
     return {
       command: "codex",
-      args: ["exec", ...(task.resumeSession ? ["resume", task.resumeSession] : []), "--json", ...modelFlags(task), ...(task.readOnly ? ["-c", 'sandbox_mode="read-only"', "-c", 'approval_policy="never"'] : ["--dangerously-bypass-approvals-and-sandbox"]), "--skip-git-repo-check", "-"],
+      args: [
+        "exec",
+        ...(task.resumeSession ? ["resume", task.resumeSession] : []),
+        "--json",
+        ...modelFlags(task),
+        ...(task.readOnly
+          ? ["-c", 'sandbox_mode="read-only"', "-c", 'approval_policy="never"']
+          : ["--dangerously-bypass-approvals-and-sandbox"]),
+        "--skip-git-repo-check",
+        "-",
+      ],
       stdin: task.brief,
     };
   }
   // Pi has no permission prompts. --approve trusts project-local configuration for
   // this non-interactive run; its complete built-in tool set remains enabled.
-  if (task.agent === "pi") return { command: "pi", args: ["--mode", "json", "--approve", ...modelFlags(task), "-p", task.brief] };
+  if (task.agent === "pi")
+    return {
+      command: "pi",
+      args: [
+        "--mode",
+        "json",
+        "--approve",
+        ...modelFlags(task),
+        "-p",
+        task.brief,
+      ],
+    };
   if (task.agent === "opencode") {
-    return { command: "opencode", args: ["run", "--format", "json", "--auto", ...modelFlags(task), ...(task.resumeSession ? ["--session", task.resumeSession] : ["--title", task.title]), "--", task.brief] };
+    return {
+      command: "opencode",
+      args: [
+        "run",
+        "--format",
+        "json",
+        "--auto",
+        ...modelFlags(task),
+        ...(task.resumeSession
+          ? ["--session", task.resumeSession]
+          : ["--title", task.title]),
+        "--",
+        task.brief,
+      ],
+    };
   }
   throw new Error(`Unsupported agent: ${task.agent}`);
 }
@@ -95,7 +201,14 @@ export function agentInvocation(task) {
 // only when the agent prices its own work (Claude Code, Pi, OpenCode). Codex reports tokens only.
 // Nothing is priced here; a missing figure stays missing.
 export function usageCollector() {
-  const usage = { input_tokens: 0, output_tokens: 0, cache_read_tokens: 0, cache_write_tokens: 0, cost_usd: null, reported: false };
+  const usage = {
+    input_tokens: 0,
+    output_tokens: 0,
+    cache_read_tokens: 0,
+    cache_write_tokens: 0,
+    cost_usd: null,
+    reported: false,
+  };
   const add = (tokens, cost) => {
     usage.reported = true;
     usage.input_tokens += Number(tokens.input) || 0;
@@ -107,62 +220,182 @@ export function usageCollector() {
   return {
     read(event) {
       // Claude Code: one result event carries the run's totals.
-      if (event.type === "result" && event.usage) { const u = event.usage; add({ input: u.input_tokens, output: u.output_tokens, cacheRead: u.cache_read_input_tokens, cacheWrite: u.cache_creation_input_tokens }, Number(event.total_cost_usd)); return; }
+      if (event.type === "result" && event.usage) {
+        const u = event.usage;
+        add(
+          {
+            input: u.input_tokens,
+            output: u.output_tokens,
+            cacheRead: u.cache_read_input_tokens,
+            cacheWrite: u.cache_creation_input_tokens,
+          },
+          Number(event.total_cost_usd)
+        );
+        return;
+      }
       // Codex: each completed turn carries its usage.
-      if (event.type === "turn.completed" && event.usage) { const u = event.usage; add({ input: u.input_tokens, output: u.output_tokens, cacheRead: u.cached_input_tokens, cacheWrite: u.cache_write_input_tokens }, NaN); return; }
+      if (event.type === "turn.completed" && event.usage) {
+        const u = event.usage;
+        add(
+          {
+            input: u.input_tokens,
+            output: u.output_tokens,
+            cacheRead: u.cached_input_tokens,
+            cacheWrite: u.cache_write_input_tokens,
+          },
+          NaN
+        );
+        return;
+      }
       // Pi: each finished assistant message carries its usage and price.
-      if (event.type === "message_end" && event.message?.role === "assistant" && event.message.usage) { const u = event.message.usage; add({ input: u.input, output: u.output, cacheRead: u.cacheRead, cacheWrite: u.cacheWrite }, Number(u.cost?.total)); return; }
+      if (
+        event.type === "message_end" &&
+        event.message?.role === "assistant" &&
+        event.message.usage
+      ) {
+        const u = event.message.usage;
+        add(
+          {
+            input: u.input,
+            output: u.output,
+            cacheRead: u.cacheRead,
+            cacheWrite: u.cacheWrite,
+          },
+          Number(u.cost?.total)
+        );
+        return;
+      }
       // OpenCode: each finished step carries its tokens and price.
       const part = event.part;
-      if (part?.type === "step-finish" && part.tokens) add({ input: part.tokens.input, output: part.tokens.output, cacheRead: part.tokens.cache?.read, cacheWrite: part.tokens.cache?.write }, Number(part.cost));
+      if (part?.type === "step-finish" && part.tokens)
+        add(
+          {
+            input: part.tokens.input,
+            output: part.tokens.output,
+            cacheRead: part.tokens.cache?.read,
+            cacheWrite: part.tokens.cache?.write,
+          },
+          Number(part.cost)
+        );
+    },
+    result: () => {
+      const { reported, ...totals } = usage;
+      return reported ? totals : null;
     },
-    result: () => { const { reported, ...totals } = usage; return reported ? totals : null; },
   };
 }
 
 // What an agent did, as the steps of one event in its JSON stream: "say" for its words to the person, "do" for a tool
 // it used. Claude Code, Codex, Pi and OpenCode each say this their own way; anything else is not a step.
 const brief = (input) => {
-  if (!input || typeof input !== "object") return String(input ?? "").slice(0, 200);
-  const named = input.command ?? input.cmd ?? input.file_path ?? input.path ?? input.filePath ?? input.pattern ?? input.url ?? input.query ?? input.description;
+  if (!input || typeof input !== "object")
+    return String(input ?? "").slice(0, 200);
+  const named =
+    input.command ??
+    input.cmd ??
+    input.file_path ??
+    input.path ??
+    input.filePath ??
+    input.pattern ??
+    input.url ??
+    input.query ??
+    input.description;
   return String(named ?? JSON.stringify(input)).slice(0, 200);
 };
 export function stepsOf(event) {
   if (!event || typeof event !== "object") return [];
   // A step as Harness writes it for a run another app carries out (t3.mjs).
-  if (event.type === "harness.step" && (event.kind === "say" || event.kind === "do") && typeof event.text === "string") return [{ kind: event.kind, text: event.text }];
+  if (
+    event.type === "harness.step" &&
+    (event.kind === "say" || event.kind === "do") &&
+    typeof event.text === "string"
+  )
+    return [{ kind: event.kind, text: event.text }];
   if (event.type === "assistant" && Array.isArray(event.message?.content)) {
-    return event.message.content.flatMap((block) => block.type === "text" && block.text?.trim() ? [{ kind: "say", text: block.text.trim() }]
-      : block.type === "tool_use" ? [{ kind: "do", text: `${block.name}: ${brief(block.input)}` }] : []);
+    return event.message.content.flatMap((block) =>
+      block.type === "text" && block.text?.trim()
+        ? [{ kind: "say", text: block.text.trim() }]
+        : block.type === "tool_use"
+          ? [{ kind: "do", text: `${block.name}: ${brief(block.input)}` }]
+          : []
+    );
   }
   if (event.type === "item.completed" && event.item) {
     const item = event.item;
-    if (item.type === "agent_message" && item.text?.trim()) return [{ kind: "say", text: item.text.trim() }];
-    if (item.type === "command_execution") return [{ kind: "do", text: `ran: ${String(item.command ?? "").slice(0, 200)}` }];
-    if (item.type === "file_change") return [{ kind: "do", text: `edited: ${(item.changes ?? []).map((change) => change.path).join(", ").slice(0, 200)}` }];
-    if (item.type === "mcp_tool_call") return [{ kind: "do", text: `${item.server ?? "tool"}: ${item.tool ?? ""}` }];
-    if (item.type === "web_search") return [{ kind: "do", text: `searched: ${String(item.query ?? "").slice(0, 200)}` }];
+    if (item.type === "agent_message" && item.text?.trim())
+      return [{ kind: "say", text: item.text.trim() }];
+    if (item.type === "command_execution")
+      return [
+        {
+          kind: "do",
+          text: `ran: ${String(item.command ?? "").slice(0, 200)}`,
+        },
+      ];
+    if (item.type === "file_change")
+      return [
+        {
+          kind: "do",
+          text: `edited: ${(item.changes ?? [])
+            .map((change) => change.path)
+            .join(", ")
+            .slice(0, 200)}`,
+        },
+      ];
+    if (item.type === "mcp_tool_call")
+      return [
+        { kind: "do", text: `${item.server ?? "tool"}: ${item.tool ?? ""}` },
+      ];
+    if (item.type === "web_search")
+      return [
+        {
+          kind: "do",
+          text: `searched: ${String(item.query ?? "").slice(0, 200)}`,
+        },
+      ];
     return [];
   }
-  if (event.type === "message_end" && event.message?.role === "assistant" && Array.isArray(event.message.content)) {
-    return event.message.content.flatMap((block) => block.type === "text" && block.text?.trim() ? [{ kind: "say", text: block.text.trim() }]
-      : block.type === "toolCall" ? [{ kind: "do", text: `${block.name}: ${brief(block.arguments)}` }] : []);
+  if (
+    event.type === "message_end" &&
+    event.message?.role === "assistant" &&
+    Array.isArray(event.message.content)
+  ) {
+    return event.message.content.flatMap((block) =>
+      block.type === "text" && block.text?.trim()
+        ? [{ kind: "say", text: block.text.trim() }]
+        : block.type === "toolCall"
+          ? [{ kind: "do", text: `${block.name}: ${brief(block.arguments)}` }]
+          : []
+    );
   }
   const part = event.part;
-  if (part?.type === "text" && part.text?.trim() && (part.time?.end || event.type === "text")) return [{ kind: "say", text: part.text.trim() }];
-  if (part?.type === "tool" && part.state?.status === "completed") return [{ kind: "do", text: `${part.tool}: ${brief(part.state.input)}` }];
+  if (
+    part?.type === "text" &&
+    part.text?.trim() &&
+    (part.time?.end || event.type === "text")
+  )
+    return [{ kind: "say", text: part.text.trim() }];
+  if (part?.type === "tool" && part.state?.status === "completed")
+    return [{ kind: "do", text: `${part.tool}: ${brief(part.state.input)}` }];
   return [];
 }
 
 /** The steps of a run from its log, oldest first; at most `limit`, the latest kept. */
 export function readRunSteps(file, limit = 200) {
   let raw = "";
-  try { raw = fs.readFileSync(file, "utf8"); } catch { return []; }
+  try {
+    raw = fs.readFileSync(file, "utf8");
+  } catch {
+    return [];
+  }
   const steps = [];
   for (const line of raw.split("\n")) {
     if (!line.startsWith("{")) continue;
     let event;
-    try { event = JSON.parse(line); } catch { continue; }
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
     steps.push(...stepsOf(event));
   }
   return steps.slice(-limit);
@@ -172,7 +405,10 @@ export function runAgentTask(task, emit, observe = () => {}) {
   // One run per folder: two agents in one checkout would trip over each other; a thread's worktree is its own folder.
   const slot = task.cwd ? path.resolve(task.cwd) : task.agent;
   if (running.has(slot)) {
-    emit("failed", `Another run is already working in ${task.cwd || "that folder"}.`);
+    emit(
+      "failed",
+      `Another run is already working in ${task.cwd || "that folder"}.`
+    );
     return;
   }
   let cwd;
@@ -191,7 +427,10 @@ export function runAgentTask(task, emit, observe = () => {}) {
   emit("accepted");
   let child;
   try {
-    child = spawn(invocation.command, invocation.args, { cwd, env: environment.env });
+    child = spawn(invocation.command, invocation.args, {
+      cwd,
+      env: environment.env,
+    });
     // An agent that exits before reading its brief breaks the pipe; its exit says how the run went.
     child.stdin.on("error", () => {});
     child.stdin.end(invocation.stdin);
@@ -219,23 +458,53 @@ export function runAgentTask(task, emit, observe = () => {}) {
       if (!line.trim()) continue;
       tail = (tail + "\n" + line).slice(-4_000);
       let event;
-      try { event = JSON.parse(line); } catch { continue; }
-      const sessionId = event.session_id || event.sessionId || event.sessionID || event.thread_id || event.thread?.id || event.properties?.sessionID;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const sessionId =
+        event.session_id ||
+        event.sessionId ||
+        event.sessionID ||
+        event.thread_id ||
+        event.thread?.id ||
+        event.properties?.sessionID;
       if (!sessionReported && typeof sessionId === "string" && sessionId) {
         sessionReported = true;
         emit("session", sessionId, { cwd });
       }
       usage.read(event);
-      if (event.type === "result" && typeof event.result === "string") resultText = event.result;
-      if (event.type === "item.completed" && event.item?.type === "agent_message" && typeof event.item.text === "string") resultText = event.item.text;
-      if (["text", "message.part.updated"].includes(event.type) && typeof event.part?.text === "string") resultText = event.part.text;
+      if (event.type === "result" && typeof event.result === "string")
+        resultText = event.result;
+      if (
+        event.type === "item.completed" &&
+        event.item?.type === "agent_message" &&
+        typeof event.item.text === "string"
+      )
+        resultText = event.item.text;
+      if (
+        ["text", "message.part.updated"].includes(event.type) &&
+        typeof event.part?.text === "string"
+      )
+        resultText = event.part.text;
       // Pi: its last words are its answer; when its model call fails, Pi still exits 0 with the error on the message.
       if (event.type === "message_end" && event.message?.role === "assistant") {
-        const said = (Array.isArray(event.message.content) ? event.message.content : []).filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
+        const said = (
+          Array.isArray(event.message.content) ? event.message.content : []
+        )
+          .filter((block) => block.type === "text")
+          .map((block) => block.text)
+          .join("\n")
+          .trim();
         if (said) resultText = said;
-        modelError = event.message.stopReason === "error" ? String(event.message.errorMessage || "no error message") : "";
+        modelError =
+          event.message.stopReason === "error"
+            ? String(event.message.errorMessage || "no error message")
+            : "";
       }
-      for (const step of stepsOf(event)) emit("progress", step.text.slice(0, 200), { step });
+      for (const step of stepsOf(event))
+        emit("progress", step.text.slice(0, 200), { step });
     }
   });
   child.stderr?.on("data", (chunk) => {
@@ -246,9 +515,30 @@ export function runAgentTask(task, emit, observe = () => {}) {
   child.on("close", (code) => {
     running.delete(slot);
     children.delete(task.runId);
-    if (code === 0 && modelError) emit("failed", `${task.agent} stopped on an error from its model: ${modelError}`.slice(0, 4_000), { usage: usage.result() });
-    else if (code === 0) emit("done", (resultText || "The run finished; check the repository for its changes.").slice(0, 20_000), { usage: usage.result() });
-    else emit("failed", (`${task.agent} exited with code ${code}.\n${tail}`).slice(0, 4_000), { usage: usage.result() });
+    if (code === 0 && modelError)
+      emit(
+        "failed",
+        `${task.agent} stopped on an error from its model: ${modelError}`.slice(
+          0,
+          4_000
+        ),
+        { usage: usage.result() }
+      );
+    else if (code === 0)
+      emit(
+        "done",
+        (
+          resultText ||
+          "The run finished; check the repository for its changes."
+        ).slice(0, 20_000),
+        { usage: usage.result() }
+      );
+    else
+      emit(
+        "failed",
+        `${task.agent} exited with code ${code}.\n${tail}`.slice(0, 4_000),
+        { usage: usage.result() }
+      );
   });
   child.on("error", (error) => {
     running.delete(slot);

package/lib/runtime-install.mjs

@@ -15,12 +15,20 @@ function dependencyTarget(root, name) {
 // What the runtime keeps of a large package. onnxruntime-node ships native binaries for every OS (about 200 MB); the
 // daemon needs its JavaScript and this machine's own binary.
 const KEEP = {
-  "onnxruntime-node": ["package.json", "dist", "lib", `bin/napi-v6/${process.platform}/${process.arch}`],
+  "onnxruntime-node": [
+    "package.json",
+    "dist",
+    "lib",
+    `bin/napi-v6/${process.platform}/${process.arch}`,
+  ],
 };
 
 function copyPackage(source, target, name) {
   const keep = KEEP[name];
-  if (!keep) { fs.cpSync(source, target, { recursive: true, force: true }); return; }
+  if (!keep) {
+    fs.cpSync(source, target, { recursive: true, force: true });
+    return;
+  }
   for (const file of keep) {
     const from = path.join(source, file);
     if (!fs.existsSync(from)) continue;
@@ -30,24 +38,32 @@ function copyPackage(source, target, name) {
 }
 
 function copyDependencyClosure(sourceRoot, releaseRoot, roots) {
-  const queue = roots.map((name) => ({ name, require: createRequire(path.join(sourceRoot, "package.json")) }));
+  const queue = roots.map((name) => ({
+    name,
+    require: createRequire(path.join(sourceRoot, "package.json")),
+  }));
   const copied = new Set();
   while (queue.length) {
     const item = queue.shift();
     if (copied.has(item.name)) continue;
     let packageJson;
-    try { packageJson = item.require.resolve(`${item.name}/package.json`); }
-    catch {
+    try {
+      packageJson = item.require.resolve(`${item.name}/package.json`);
+    } catch {
       // Packages with restrictive exports still resolve their main file. Walk upward to
       // the package.json whose name matches the requested dependency.
       let current = path.dirname(item.require.resolve(item.name));
       while (current !== path.dirname(current)) {
         const candidate = path.join(current, "package.json");
-        if (readJson(candidate, {}).name === item.name) { packageJson = candidate; break; }
+        if (readJson(candidate, {}).name === item.name) {
+          packageJson = candidate;
+          break;
+        }
         current = path.dirname(current);
       }
     }
-    if (!packageJson) throw new Error(`could not package runtime dependency ${item.name}`);
+    if (!packageJson)
+      throw new Error(`could not package runtime dependency ${item.name}`);
     const source = packageDirectory(packageJson);
     const target = dependencyTarget(releaseRoot, item.name);
     ensureDir(path.dirname(target));
@@ -55,7 +71,10 @@ function copyDependencyClosure(sourceRoot, releaseRoot, roots) {
     copied.add(item.name);
     const metadata = readJson(packageJson, {});
     const nestedRequire = createRequire(packageJson);
-    for (const name of Object.keys({ ...(metadata.dependencies || {}), ...(metadata.optionalDependencies || {}) })) {
+    for (const name of Object.keys({
+      ...(metadata.dependencies || {}),
+      ...(metadata.optionalDependencies || {}),
+    })) {
       try {
         nestedRequire.resolve(name);
         queue.push({ name, require: nestedRequire });
@@ -71,23 +90,45 @@ export function installRuntime({ sourceRoot, version }) {
     const staging = `${release}.staging-${process.pid}`;
     fs.rmSync(staging, { recursive: true, force: true });
     ensureDir(staging);
-    for (const entry of ["cli.mjs", "package.json", "README.md", "lib", "assets"]) {
+    for (const entry of [
+      "cli.mjs",
+      "package.json",
+      "README.md",
+      "lib",
+      "assets",
+    ]) {
       const source = path.join(sourceRoot, entry);
       if (!fs.existsSync(source)) continue;
-      fs.cpSync(source, path.join(staging, entry), { recursive: true, force: true });
+      fs.cpSync(source, path.join(staging, entry), {
+        recursive: true,
+        force: true,
+      });
     }
     // Everything the package depends on, so a dependency added there cannot be left out here.
-    copyDependencyClosure(sourceRoot, staging, Object.keys(readJson(path.join(sourceRoot, "package.json"), {}).dependencies || {}));
-    fs.writeFileSync(path.join(staging, ".ready"), version + "\n", { mode: 0o600 });
+    copyDependencyClosure(
+      sourceRoot,
+      staging,
+      Object.keys(
+        readJson(path.join(sourceRoot, "package.json"), {}).dependencies || {}
+      )
+    );
+    fs.writeFileSync(path.join(staging, ".ready"), version + "\n", {
+      mode: 0o600,
+    });
     ensureDir(path.dirname(release));
     fs.rmSync(release, { recursive: true, force: true });
     fs.renameSync(staging, release);
   }
-  writeJsonAtomic(path.join(paths.runtime, "current.json"), { version, path: release });
+  writeJsonAtomic(path.join(paths.runtime, "current.json"), {
+    version,
+    path: release,
+  });
   return release;
 }
 
 export function currentRuntime() {
   const current = readJson(path.join(paths.runtime, "current.json"), {});
-  return typeof current.path === "string" && fs.existsSync(current.path) ? current.path : null;
+  return typeof current.path === "string" && fs.existsSync(current.path)
+    ? current.path
+    : null;
 }