dahrk-node 0.1.11 → 0.1.12

package/dist/main.js

@@ -470,18 +470,21 @@ function toElicitQuestion(q) {
 ${lines.join("\n")}` : q.question;
   return { prompt, options, ...q.multiSelect ? { multiSelect: true } : {} };
 }
+function buildElicitFromQuestions(questions) {
+  const first = questions[0];
+  const q = toElicitQuestion(first);
+  const prompt = questions.length > 1 ? `${q.prompt}
+
+(Note: ${questions.length} questions were asked at once; answer this one first, then ask the rest.)` : q.prompt;
+  return { ...q, prompt };
+}
 function createAskUserQuestionTool(deps) {
   const askTool = tool2(
     "ask_user_question",
     "Ask the human a structured multiple-choice question and wait for their selection. Use this when you need the human to choose between options before you can continue.",
     { questions: z2.array(questionSchema).min(1) },
     async (args) => {
-      const first = args.questions[0];
-      const question = toElicitQuestion(first);
-      const prompt = args.questions.length > 1 ? `${question.prompt}
-
-(Note: ${args.questions.length} questions were asked at once; answer this one first, then ask the rest.)` : question.prompt;
-      const text = await deps.ask({ ...question, prompt });
+      const text = await deps.ask(buildElicitFromQuestions(args.questions));
       return { content: [{ type: "text", text }] };
     }
   );
@@ -536,6 +539,10 @@ function sandboxOptions(ctx) {
     }
   };
 }
+function runtimeEnvOptions(ctx) {
+  if (!ctx.runtimeEnv) return {};
+  return { env: { ...process.env, ...ctx.runtimeEnv } };
+}
 function createClaudeRunner() {
   const abortController = new AbortController();
   let cancelled = false;
@@ -579,6 +586,8 @@ function createClaudeRunner() {
     // .claude/ + CLAUDE.md + .mcp.json, which is all section 9 actually requires. Claude auth is
     // keychain/OAuth and independent of settingSources, so dropping "user" does not affect it.
     settingSources: ["project", "local"],
+    // Brokered inference env (DHK-89), for a managed / Docker-isolated node with no ambient login.
+    ...runtimeEnvOptions(ctx),
     ...ctx.config.model ? { model: ctx.config.model } : {},
     ...ctx.sessionId ? { resume: ctx.sessionId } : {},
     ...ctx.config.skill ? { skills: [ctx.config.skill] } : {}
@@ -893,6 +902,12 @@ function mapUsage2(u) {
 
 // ../../packages/executor-worktree/src/codex-adapter.ts
 var COALESCE_MS2 = Number(process.env.DAHRK_COALESCE_MS ?? process.env.SKAKEL_COALESCE_MS ?? 40);
+function runtimeEnvOptions2(ctx) {
+  if (!ctx.runtimeEnv) return {};
+  const env = {};
+  for (const [k, v] of Object.entries(process.env)) if (v !== void 0) env[k] = v;
+  return { env: { ...env, ...ctx.runtimeEnv } };
+}
 function createCodexRunner() {
   const abortController = new AbortController();
   const signal = abortController.signal;
@@ -906,7 +921,7 @@ function createCodexRunner() {
     ...ctx.config.model ? { model: ctx.config.model } : {}
   });
   const openThread = (ctx) => {
-    const codex = new Codex();
+    const codex = new Codex(runtimeEnvOptions2(ctx));
     const t = ctx.sessionId ? codex.resumeThread(ctx.sessionId, threadOptions(ctx)) : codex.startThread(threadOptions(ctx));
     thread = t;
     return t;
@@ -3758,6 +3773,8 @@ async function startEdgeNode(opts) {
   const counters = new HealthCounters();
   const shipper = opts.shipper;
   const telemetryCeiling = ceilingFromEnv(process.env);
+  let currentRuntimes = opts.runtimes;
+  const runtimesKey = (r) => [...r].sort().join(",");
   const gitLog = log.child({ component: "git" });
   const gitLogger = {
     info: (msg) => gitLog.debug(msg),
@@ -3804,7 +3821,7 @@ async function startEdgeNode(opts) {
           health: collectHealth({
             counters,
             clientVersion: opts.clientVersion ?? "0.0.0",
-            runtimes: opts.runtimes,
+            runtimes: currentRuntimes,
             worktreesDir: gitService.worktreesDir
           })
         } : { type: "heartbeat" }
@@ -3863,6 +3880,41 @@ async function startEdgeNode(opts) {
     for (const e of r.errors) log.warn({ reapError: e }, `EDGE_REAP_ERROR:${e}`);
   }).catch((e) => log.warn({ err: e }, `EDGE_REAP_ERROR:${e.message}`));
   const nodeId = opts.nodeId ?? randomUUID();
+  const sendHello = () => {
+    send({
+      type: "hello",
+      enrolToken: opts.enrolToken ?? "",
+      detectedRuntimes: currentRuntimes,
+      servesRepoIds: opts.servesRepoIds ?? [],
+      ...opts.credentialModeExplicit && opts.credentialMode ? { credentialMode: opts.credentialMode } : {},
+      nodeId,
+      ...opts.name ? { name: opts.name } : {},
+      os: osPlatform(),
+      arch: osArch(),
+      clientVersion: opts.clientVersion ?? "0.0.0",
+      // Advertise the resolved worktree base so the hub records each run's real worktree location in
+      // the projection instead of an advisory placeholder. Single-sourced from the git service so it
+      // always matches where worktrees actually land.
+      worktreesDir: gitService.worktreesDir
+    });
+  };
+  let reprobeTimer;
+  if (opts.reprobeRuntimes) {
+    const reprobe = opts.reprobeRuntimes;
+    reprobeTimer = setInterval(() => {
+      void reprobe().then((detected) => {
+        if (runtimesKey(detected) === runtimesKey(currentRuntimes)) return;
+        const before = currentRuntimes;
+        currentRuntimes = detected;
+        log.warn(
+          { before, after: detected },
+          `EDGE_RUNTIMES_CHANGED:${before.join(",") || "none"} -> ${detected.join(",") || "none"}`
+        );
+        sendHello();
+      }).catch((e) => log.warn({ err: e }, `EDGE_REPROBE_ERROR:${e.message}`));
+    }, opts.runtimeRecheckMs ?? 6e4);
+    reprobeTimer.unref?.();
+  }
   const running = /* @__PURE__ */ new Set();
   const onMessage = async (raw) => {
     const msg = decode(raw);
@@ -4013,22 +4065,7 @@ async function startEdgeNode(opts) {
       connectCount++;
       counters.connectCount = connectCount;
       log.info({ hubUrl: opts.hubUrl, nodeId, connectCount }, "EDGE_CONNECTED");
-      send({
-        type: "hello",
-        enrolToken: opts.enrolToken ?? "",
-        detectedRuntimes: opts.runtimes,
-        servesRepoIds: opts.servesRepoIds ?? [],
-        ...opts.credentialModeExplicit && opts.credentialMode ? { credentialMode: opts.credentialMode } : {},
-        nodeId,
-        ...opts.name ? { name: opts.name } : {},
-        os: osPlatform(),
-        arch: osArch(),
-        clientVersion: opts.clientVersion ?? "0.0.0",
-        // Advertise the resolved worktree base so the hub records each run's real worktree location in
-        // the projection instead of an advisory placeholder. Single-sourced from the git service so it
-        // always matches where worktrees actually land.
-        worktreesDir: gitService.worktreesDir
-      });
+      sendHello();
       for (const frame of lastResults.values()) send(frame);
       startHeartbeat(sock, opts.heartbeatMs ?? 5e3);
     });
@@ -4062,6 +4099,8 @@ async function startEdgeNode(opts) {
       heartbeat = void 0;
       if (reconnectTimer) clearTimeout(reconnectTimer);
       reconnectTimer = void 0;
+      if (reprobeTimer) clearInterval(reprobeTimer);
+      reprobeTimer = void 0;
       ws?.close(1e3, "shutting down");
     },
     { once: true }
@@ -4088,24 +4127,37 @@ var PROBES = [
   { runtime: "codex", cmd: "codex" },
   { runtime: "pi", cmd: "pi" }
 ];
-function probe(cmd, timeoutMs) {
+var DEFAULT_TIMEOUT_MS = 5e3;
+var DEFAULT_ATTEMPTS = 2;
+function probeOnce(cmd, timeoutMs) {
   return new Promise((resolve3) => {
     execFile(cmd, ["--version"], { timeout: timeoutMs }, (err, stdout) => {
-      if (err) return resolve3(void 0);
+      if (err) {
+        const code = err.code;
+        return resolve3({ retryable: code !== "ENOENT" });
+      }
       const line = stdout.split("\n").map((s) => s.trim()).find(Boolean);
-      resolve3(line ?? "");
+      resolve3({ version: line ?? "" });
     });
   });
 }
-async function probeRuntimeStatuses(timeoutMs = 3e3) {
-  const versions = await Promise.all(PROBES.map((p) => probe(p.cmd, timeoutMs)));
+async function probe(cmd, timeoutMs, attempts) {
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    const result = await probeOnce(cmd, timeoutMs);
+    if ("version" in result) return result.version;
+    if (!result.retryable) return void 0;
+  }
+  return void 0;
+}
+async function probeRuntimeStatuses(timeoutMs = DEFAULT_TIMEOUT_MS, attempts = DEFAULT_ATTEMPTS) {
+  const versions = await Promise.all(PROBES.map((p) => probe(p.cmd, timeoutMs, attempts)));
   return PROBES.map((p, i) => {
     const version = versions[i];
     return version === void 0 ? { runtime: p.runtime, cmd: p.cmd, installed: false } : { runtime: p.runtime, cmd: p.cmd, installed: true, version };
   });
 }
-async function detectRuntimes(timeoutMs = 3e3) {
-  const statuses = await probeRuntimeStatuses(timeoutMs);
+async function detectRuntimes(timeoutMs = DEFAULT_TIMEOUT_MS, attempts = DEFAULT_ATTEMPTS) {
+  const statuses = await probeRuntimeStatuses(timeoutMs, attempts);
   return statuses.filter((s) => s.installed).map((s) => s.runtime);
 }
 
@@ -5289,6 +5341,8 @@ import { join as join15 } from "path";
 import { chmodSync, existsSync as existsSync11, mkdirSync as mkdirSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync9 } from "fs";
 import { homedir as homedir5 } from "os";
 import { join as join14 } from "path";
+var RUNTIMES = ["claude-code", "codex", "pi"];
+var isRuntime = (v) => RUNTIMES.includes(v);
 var STRING_FIELDS = ["nodeId", "enrolToken", "name", "tenantId", "updateCheckedAt", "updateLatest"];
 var isDesired = (v) => v === "running" || v === "stopped";
 var FILE_MODE = 384;
@@ -5331,6 +5385,10 @@ function readState(file) {
       if (typeof value === "string" && value) state[key] = value;
     }
     if (isDesired(parsed["desired"])) state.desired = parsed["desired"];
+    if (Array.isArray(parsed["runtimes"])) {
+      const runtimes = parsed["runtimes"].filter(isRuntime);
+      if (runtimes.length) state.runtimes = runtimes;
+    }
     return state;
   } catch {
     return {};
@@ -6045,11 +6103,11 @@ async function runStatus(inputs, deps) {
 }
 
 // src/main.ts
-var CLIENT_VERSION = "0.1.11";
+var CLIENT_VERSION = "0.1.12";
 var DEFAULT_HUB_URL = "wss://api.dahrk.ai";
 var list = (v) => (v ?? "").split(",").map((s) => s.trim()).filter(Boolean);
-var RUNTIMES = ["claude-code", "codex", "pi"];
-var isRuntime = (r) => RUNTIMES.includes(r);
+var RUNTIMES2 = ["claude-code", "codex", "pi"];
+var isRuntime2 = (r) => RUNTIMES2.includes(r);
 function resolveNodeId(env, opts = {}) {
   if (env.DAHRK_NODE_ID) return env.DAHRK_NODE_ID;
   if (opts.ephemeral) return randomUUID3();
@@ -6065,7 +6123,7 @@ function resolveNodeId(env, opts = {}) {
   return nodeId;
 }
 async function resolveRuntimes(env) {
-  const override = list(env.DAHRK_RUNTIMES).filter(isRuntime);
+  const override = list(env.DAHRK_RUNTIMES).filter(isRuntime2);
   if (override.length > 0) return override;
   if ((env.DAHRK_RUNNER ?? "real") === "mock") return ["claude-code"];
   return detectRuntimes();
@@ -6075,7 +6133,7 @@ function buildEdgeOptions(env, resolved) {
   const servesRepoIds = list(env.DAHRK_REPOS);
   const credentialModeExplicit = env.DAHRK_CREDENTIAL_MODE != null;
   const credentialMode = env.DAHRK_CREDENTIAL_MODE === "brokered" ? "brokered" : "ambient";
-  const envRuntimes = list(env.DAHRK_RUNTIMES).filter(isRuntime);
+  const envRuntimes = list(env.DAHRK_RUNTIMES).filter(isRuntime2);
   const runtimes = resolved ? resolved.runtimes : envRuntimes.length > 0 ? envRuntimes : ["claude-code"];
   const nodeId = resolved?.nodeId ?? env.DAHRK_NODE_ID;
   const maxRuns = env.DAHRK_RETENTION_MAX_RUNS;
@@ -6170,6 +6228,18 @@ async function startForeground(env, flags) {
   const token = resolveEnrolToken(env, { ephemeral: flags.ephemeral });
   if (token) env.DAHRK_ENROL_TOKEN = token;
   const runtimes = await resolveRuntimes(env);
+  if (!flags.ephemeral) {
+    const prior = readState(stateFile(env)).runtimes ?? [];
+    const missing = prior.filter((r) => !runtimes.includes(r));
+    if (missing.length > 0) {
+      logger.warn(
+        { prior, detected: runtimes, missing },
+        `RUNTIMES_DEGRADED:${missing.join(",")} advertised last run but not detected now - the node will serve no Jobs for it until it is re-probed or restarted. Run \`dahrk doctor\` to check.`
+      );
+    }
+    writeState(env, { runtimes });
+  }
+  logger.info({ runtimes }, `RUNTIMES_DETECTED:${runtimes.join(",") || "none"}`);
   if (runtimes.length === 0) {
     console.warn(
       "no agent runtimes detected on this host (claude/codex/pi not on PATH); the node will advertise none and serve no Jobs. Install a runtime or set DAHRK_RUNTIMES to override. Run `dahrk doctor` to check."
@@ -6183,6 +6253,11 @@ async function startForeground(env, flags) {
     ...buildEdgeOptions(env, resolved),
     logger,
     shipper,
+    // Self-heal a transiently-degraded boot without a manual restart: the edge re-probes on this seam
+    // and re-advertises when the set changes. Reuses `resolveRuntimes`, so `DAHRK_RUNTIMES` still wins
+    // (a pinned override never re-probes to something else) and the mock runner path stays stable.
+    reprobeRuntimes: () => resolveRuntimes(env),
+    ...env.DAHRK_RUNTIME_RECHECK_MS ? { runtimeRecheckMs: Number(env.DAHRK_RUNTIME_RECHECK_MS) } : {},
     ...persist ? {
       onEnrolled: (welcome) => persistEnrolment(env, { token, name: welcome.name, tenantId: welcome.tenantId })
     } : {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dahrk-node",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",