dahrk-node 0.1.9 → 0.1.10

package/dist/main.js

@@ -2004,6 +2004,160 @@ function makeRunner(runtime) {
   return runtime === "codex" ? createCodexRunner() : createClaudeRunner();
 }
 
+// ../../packages/edge/src/health.ts
+import { statfsSync } from "fs";
+var HealthCounters = class {
+  startedAt = Date.now();
+  errors = /* @__PURE__ */ new Map();
+  crashes = 0;
+  /** Connections made this process lifetime. The flapping signal: this climbing while uptime ALSO climbs
+   *  means the socket keeps dropping under a process that is otherwise fine. */
+  connectCount = 0;
+  /** Jobs in flight. A node stuck at 1 for an hour is wedged, and nothing else reveals it. */
+  activeJobs = 0;
+  /** Worktrees on disk. Climbing without bound was the shape of the leak DHK-371 fixed. */
+  worktreeCount = 0;
+  /** Bucket a stage failure. The CLASS only - the message would carry their paths. */
+  recordError(kind) {
+    this.errors.set(kind, (this.errors.get(kind) ?? 0) + 1);
+  }
+  recordCrash() {
+    this.crashes++;
+  }
+  uptimeSec() {
+    return Math.round((Date.now() - this.startedAt) / 1e3);
+  }
+  errorCounts() {
+    return Object.fromEntries(this.errors);
+  }
+  crashCount() {
+    return this.crashes;
+  }
+};
+function diskFreeBytes(path) {
+  try {
+    const st = statfsSync(path);
+    return Number(st.bfree) * Number(st.bsize);
+  } catch {
+    return void 0;
+  }
+}
+function collectHealth(inputs) {
+  const { counters } = inputs;
+  const free = diskFreeBytes(inputs.worktreesDir);
+  const errors = counters.errorCounts();
+  return {
+    uptimeSec: counters.uptimeSec(),
+    clientVersion: inputs.clientVersion,
+    activeJobs: counters.activeJobs,
+    connectCount: counters.connectCount,
+    worktreeCount: counters.worktreeCount,
+    ...free !== void 0 ? { diskFreeBytes: free } : {},
+    runtimes: inputs.runtimes,
+    ...Object.keys(errors).length > 0 ? { errors } : {},
+    ...counters.crashCount() > 0 ? { crashes: counters.crashCount() } : {}
+  };
+}
+
+// ../../packages/edge/src/log-shipper.ts
+import { shouldShip } from "@dahrk/contracts";
+var SHIP_BUFFER_MAX = 500;
+var SHIP_BATCH_MAX = 200;
+var SHIP_FLUSH_MS = 2e3;
+var LogShipper = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+    this.ceiling = opts.ceiling ?? { health: true, logs: "debug" };
+    this.policy = this.clampToCeiling(opts.initial ?? { health: true, logs: "off" });
+  }
+  opts;
+  buffer = [];
+  policy;
+  ceiling;
+  timer;
+  /** Attached once the socket exists. The shipper is constructed FIRST, because it has to be a pino
+   *  stream before the logger is built, which is before the client is started. Until `attach`, records
+   *  simply accumulate in the (bounded) ring. */
+  send;
+  /** Records we threw away because the buffer was full. Reported, never hidden. */
+  dropped = 0;
+  /** Give the shipper its transport. Called by the client once the socket exists. */
+  attach(send) {
+    this.send = send;
+  }
+  /** The hub may only ever ask for LESS than the local ceiling allows. */
+  clampToCeiling(p) {
+    const rank = { off: 0, error: 1, warn: 2, info: 3, debug: 4 };
+    const logs = rank[p.logs] > rank[this.ceiling.logs] ? this.ceiling.logs : p.logs;
+    return { health: p.health && this.ceiling.health, logs };
+  }
+  /** Apply a policy from the hub (`welcome`, or a live `policy` frame). */
+  setPolicy(p) {
+    this.policy = this.clampToCeiling(p);
+    if (this.policy.logs === "off") this.buffer = [];
+  }
+  current() {
+    return this.policy;
+  }
+  /** Offer a record. Cheap and synchronous - this sits on the logging hot path. */
+  offer(record) {
+    if (this.policy.logs === "off") return;
+    if (!shouldShip(record.level, this.policy.logs)) return;
+    this.buffer.push(record);
+    if (this.buffer.length > (this.opts.bufferMax ?? SHIP_BUFFER_MAX)) {
+      this.buffer.shift();
+      this.dropped++;
+    }
+  }
+  /** Send one batch if there is anything to send and the socket will take it. */
+  flush() {
+    if (this.buffer.length === 0 || !this.send) return;
+    const batch = this.buffer.slice(0, SHIP_BATCH_MAX);
+    if (!this.send(batch)) return;
+    this.buffer = this.buffer.slice(batch.length);
+  }
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => this.flush(), this.opts.flushMs ?? SHIP_FLUSH_MS);
+    this.timer.unref?.();
+  }
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+  }
+  /** For the health report and for tests. */
+  pending() {
+    return this.buffer.length;
+  }
+};
+function shipperStream(shipper) {
+  return {
+    write(chunk) {
+      try {
+        const r = JSON.parse(chunk);
+        if (!r.msg) return;
+        shipper.offer({
+          level: r.level,
+          time: r.time,
+          msg: r.msg,
+          ...r.runId ? { runId: r.runId } : {},
+          ...r.stageId ? { stageId: r.stageId } : {},
+          ...r.jobId ? { jobId: r.jobId } : {},
+          ...r.component ? { component: r.component } : {},
+          ...r.err ? { err: r.err } : {}
+        });
+      } catch {
+      }
+    }
+  };
+}
+function ceilingFromEnv(env) {
+  const v = env.DAHRK_TELEMETRY?.toLowerCase();
+  if (v === "off" || v === "0" || v === "false") return { health: false, logs: "off" };
+  if (v === "health") return { health: true, logs: "off" };
+  return { health: true, logs: "debug" };
+}
+
 // ../../packages/edge/src/logger.ts
 import { closeSync, existsSync as existsSync5, mkdirSync as mkdirSync5, openSync, renameSync, rmSync as rmSync4, statSync as statSync2, writeSync } from "fs";
 import { join as join7 } from "path";
@@ -2203,7 +2357,8 @@ function createNodeLogger(opts = {}) {
 `);
     }
   }
-  const base = streams.length === 0 ? "silent" : opts.dir ? lowest(level, fileLevel) : level;
+  if (opts.ship) streams.push({ level: "trace", stream: opts.ship });
+  const base = streams.length === 0 ? "silent" : opts.ship ? "trace" : opts.dir ? lowest(level, fileLevel) : level;
   return pino(
     {
       level: base,
@@ -2219,12 +2374,13 @@ function createNodeLogger(opts = {}) {
     pino.multistream(streams)
   );
 }
-function createNodeLoggerFromEnv(env, dir, base) {
+function createNodeLoggerFromEnv(env, dir, base, ship) {
   const fileLevel = fileLevelFromEnv(env);
   return createNodeLogger({
     level: levelFromEnv(env),
     ...fileLevel === "off" ? {} : { dir, fileLevel },
-    ...base ? { base } : {}
+    ...base ? { base } : {},
+    ...ship ? { ship } : {}
   });
 }
 
@@ -2447,11 +2603,12 @@ async function startMcpGateway(opts) {
 // ../../packages/edge/src/stage-runner.ts
 var nowIso2 = () => (/* @__PURE__ */ new Date()).toISOString();
 var PREVIEW = 500;
+var RESULT = 16e3;
 var putBytes = async (url, body, contentType) => {
   await fetch(url, { method: "PUT", headers: { "content-type": contentType }, body: new Uint8Array(body) });
 };
 function previewOf(event) {
-  const clip = (v) => (typeof v === "string" ? v : JSON.stringify(v) ?? "").slice(0, PREVIEW);
+  const clip = (v, max = PREVIEW) => (typeof v === "string" ? v : JSON.stringify(v) ?? "").slice(0, max);
   switch (event.type) {
     case "response":
       return event.text !== void 0 ? { text: event.text } : {};
@@ -2460,9 +2617,16 @@ function previewOf(event) {
     case "thought":
       return event.text !== void 0 ? { text: clip(event.text) } : {};
     case "action":
-      return { tool: event.tool, ...event.input !== void 0 ? { text: clip(event.input) } : {} };
+      return {
+        tool: event.tool,
+        toolUseId: event.toolUseId,
+        ...event.input !== void 0 ? { text: clip(event.input) } : {}
+      };
     case "observation":
-      return event.output !== void 0 ? { text: clip(event.output) } : {};
+      return {
+        toolUseId: event.toolUseId,
+        ...event.output !== void 0 ? { text: clip(event.output, RESULT) } : {}
+      };
     case "error":
       return { text: clip(event.message) };
     default:
@@ -3125,9 +3289,20 @@ function createStageRunner(deps) {
 
 // ../../packages/edge/src/ws-client.ts
 var ENROLMENT_REJECTED_EXIT_CODE = 78;
+function classifyError(e) {
+  const msg = e instanceof Error ? e.message : String(e);
+  if (/\bgit\b|worktree|clone|fetch|branch|checkout|remote/i.test(msg)) return "git";
+  if (/policy|denied|not permitted|forbidden/i.test(msg)) return "policy";
+  if (/hub|websocket|socket|awakeable/i.test(msg)) return "hub";
+  if (/runtime|claude|codex|\bpi\b|model|sdk|api key/i.test(msg)) return "runtime";
+  return "internal";
+}
 async function startEdgeNode(opts) {
   const log = opts.logger ?? createNodeLogger({ level: levelFromEnv(process.env) });
   const rules = opts.denyTool ? [denyToolRule(opts.denyTool)] : [];
+  const counters = new HealthCounters();
+  const shipper = opts.shipper;
+  const telemetryCeiling = ceilingFromEnv(process.env);
   const gitLog = log.child({ component: "git" });
   const gitLogger = {
     info: (msg) => gitLog.debug(msg),
@@ -3150,6 +3325,12 @@ async function startEdgeNode(opts) {
   const send = (msg) => {
     if (ws && ws.readyState === WebSocket.OPEN) ws.send(encode(msg));
   };
+  shipper?.attach((records) => {
+    if (!ws || ws.readyState !== WebSocket.OPEN) return false;
+    ws.send(encode({ type: "node-log", records }));
+    return true;
+  });
+  shipper?.start();
   const MISSED_PONGS_BEFORE_DEAD = 3;
   const startHeartbeat = (sock, intervalMs) => {
     if (heartbeat) clearInterval(heartbeat);
@@ -3161,7 +3342,18 @@ async function startEdgeNode(opts) {
         sock.terminate();
         return;
       }
-      send({ type: "heartbeat" });
+      const health = shipper?.current().health ?? telemetryCeiling.health;
+      send(
+        health ? {
+          type: "heartbeat",
+          health: collectHealth({
+            counters,
+            clientVersion: opts.clientVersion ?? "0.0.0",
+            runtimes: opts.runtimes,
+            worktreesDir: gitService.worktreesDir
+          })
+        } : { type: "heartbeat" }
+      );
       if (sock.readyState === WebSocket.OPEN) sock.ping();
     }, intervalMs);
   };
@@ -3206,6 +3398,7 @@ async function startEdgeNode(opts) {
   const stageRunner = createStageRunner(stageDeps);
   stageRunnerRef = stageRunner;
   void stageRunner.reapWorktrees().then((r) => {
+    counters.worktreeCount = Math.max(r.scanned - r.reaped.length, 0);
     if (r.reaped.length) {
       log.info(
         { reaped: r.reaped, scanned: r.scanned, skipped: r.skipped },
@@ -3224,8 +3417,15 @@ async function startEdgeNode(opts) {
       if (opts.heartbeatMs === void 0 && msg.heartbeatMs > 0 && ws) {
         startHeartbeat(ws, msg.heartbeatMs);
       }
+      if (msg.telemetry && shipper) shipper.setPolicy(msg.telemetry);
       log.info(
-        { name: msg.name, tenantId: msg.tenantId, credentialMode: msg.credentialMode, heartbeatMs: msg.heartbeatMs },
+        {
+          name: msg.name,
+          tenantId: msg.tenantId,
+          credentialMode: msg.credentialMode,
+          heartbeatMs: msg.heartbeatMs,
+          ...shipper ? { telemetry: shipper.current() } : {}
+        },
         `EDGE_WELCOMED:${msg.name} tenant=${msg.tenantId} credentialMode=${msg.credentialMode}`
       );
       try {
@@ -3247,6 +3447,11 @@ async function startEdgeNode(opts) {
       }
       return;
     }
+    if (msg.type === "policy") {
+      shipper?.setPolicy(msg.telemetry);
+      log.info({ telemetry: shipper?.current() ?? msg.telemetry }, `EDGE_POLICY:logs=${shipper?.current().logs ?? msg.telemetry.logs}`);
+      return;
+    }
     if (msg.type === "cancel") {
       log.info({ jobId: msg.jobId }, `JOB_CANCEL:${msg.jobId}`);
       stageRunner.cancel(msg.jobId);
@@ -3319,6 +3524,7 @@ async function startEdgeNode(opts) {
       return;
     }
     running.add(job.jobId);
+    counters.activeJobs = running.size;
     const startedAt = Date.now();
     jobLog.info({}, `JOB_STARTED:${job.stageId} ${job.jobId}`);
     try {
@@ -3338,9 +3544,11 @@ async function startEdgeNode(opts) {
       };
       rememberResult(job.jobId, frame);
       send(frame);
+      counters.recordError(classifyError(e));
       jobLog.error({ err: e, durationMs: Date.now() - startedAt }, `JOB_ERROR:${job.stageId} ${e.message}`);
     } finally {
       running.delete(job.jobId);
+      counters.activeJobs = running.size;
     }
   };
   const connect = () => {
@@ -3348,6 +3556,7 @@ async function startEdgeNode(opts) {
     ws = sock;
     sock.on("open", () => {
       connectCount++;
+      counters.connectCount = connectCount;
       log.info({ hubUrl: opts.hubUrl, nodeId, connectCount }, "EDGE_CONNECTED");
       send({
         type: "hello",
@@ -4204,7 +4413,11 @@ function acquireLock(deps) {
   }
   deps.writeFile(deps.file, `${deps.pid}
 `);
-  return { ok: true, release: () => deps.removeFile(deps.file) };
+  return { ok: true, release: () => releaseLock(deps) };
+}
+function releaseLock(deps) {
+  if (parseLock(deps.readFile(deps.file)) !== deps.pid) return;
+  deps.removeFile(deps.file);
 }
 function isAlive(pid) {
   try {
@@ -4398,7 +4611,7 @@ function installProcessSafetyNet(opts) {
 // src/preflight.ts
 import { execFileSync as execFileSync5 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
-import { accessSync, constants as fsConstants, existsSync as existsSync9, readdirSync as readdirSync5, statfsSync } from "fs";
+import { accessSync, constants as fsConstants, existsSync as existsSync9, readdirSync as readdirSync5, statfsSync as statfsSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join11 } from "path";
 var REPORT_BASE_URL = "https://app.dahrk.ai/r";
@@ -4570,7 +4783,7 @@ function nearestExisting(dir) {
 }
 function freeDiskBytes(dir) {
   try {
-    const s = statfsSync(nearestExisting(dir));
+    const s = statfsSync2(nearestExisting(dir));
     return s.bavail * s.bsize;
   } catch {
     return void 0;
@@ -4975,6 +5188,12 @@ async function runNodeStart(inputs, deps = {}) {
   d.out("  stop:   dahrk stop");
   return { kind: "running", code: 0 };
 }
+var STOP_FOREIGN_NODE = 3;
+function foreignNodePid(lock, servicePid, isAlive2) {
+  const held = parseLock(lock);
+  if (held === void 0 || held === servicePid) return void 0;
+  return isAlive2(held) ? held : void 0;
+}
 async function runNodeStop(deps = {}) {
   const d = { ...defaultDeps3(), ...deps };
   const manager = detectManager(d.platform);
@@ -4990,11 +5209,22 @@ async function runNodeStop(deps = {}) {
   if (!d.fileExists(plan.filePath)) {
     d.out("No service installed, so there is nothing to stop.");
     d.out("If you are running a node in a terminal (`dahrk start --foreground`), stop it with Ctrl-C.");
-    return 0;
+    return reportForeignNode(d, void 0) ?? 0;
   }
+  const servicePid = parseServiceStatus(manager, true, d.capture(statusCommand(manager))).pid;
   runCommands(plan.stopCommands, d);
   d.out("Node stopped. It will stay stopped across reboots until you run `dahrk start`.");
-  return 0;
+  return reportForeignNode(d, servicePid) ?? 0;
+}
+function reportForeignNode(d, servicePid) {
+  const pid = foreignNodePid(d.readFile(d.lockFile), servicePid, d.isAlive);
+  if (pid === void 0) return void 0;
+  d.out("");
+  d.out(`WARNING: a node is STILL RUNNING on this host (pid ${pid}). \`dahrk stop\` cannot stop it.`);
+  d.out("Something else is supervising it: pm2, a container, or `dahrk start --foreground` in a terminal.");
+  d.out("It is not a stray copy - it holds this node's identity, so it is still connected to the hub and");
+  d.out("still taking Jobs. Stop it where it was started (e.g. `pm2 delete dahrk-node`), or kill the pid.");
+  return STOP_FOREIGN_NODE;
 }
 async function runServiceUninstall(deps = {}) {
   const d = { ...defaultDeps3(), ...deps };
@@ -5058,6 +5288,8 @@ var defaultDeps3 = () => ({
   nodeBin: stableNodeBin(process.execPath, realpathOrUndefined),
   scriptPath: resolveScriptPath(),
   logDir: logDir(process.env),
+  lockFile: lockFile(process.env),
+  isAlive,
   // Snapshot the operator's PATH at install time so the daemon finds git + the runtime CLIs (Homebrew /
   // npm-global bins) that a supervisor's minimal PATH would otherwise hide.
   pathEnv: process.env.PATH,
@@ -5358,7 +5590,7 @@ async function runStatus(inputs, deps) {
 }
 
 // src/main.ts
-var CLIENT_VERSION = "0.1.9";
+var CLIENT_VERSION = "0.1.10";
 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"];
@@ -5472,7 +5704,8 @@ async function startForeground(env, flags) {
   rotateIfLarge(files.out);
   rotateIfLarge(files.err);
   const nodeId = resolveNodeId(env, { ephemeral: flags.ephemeral });
-  const logger = createNodeLoggerFromEnv(env, logDir(env), { nodeId, clientVersion: CLIENT_VERSION });
+  const shipper = new LogShipper({ ceiling: ceilingFromEnv(env) });
+  const logger = createNodeLoggerFromEnv(env, logDir(env), { nodeId, clientVersion: CLIENT_VERSION }, shipperStream(shipper));
   installProcessSafetyNet({
     logger,
     crashDir: crashDir(env),
@@ -5494,6 +5727,7 @@ async function startForeground(env, flags) {
   await startEdgeNode({
     ...buildEdgeOptions(env, resolved),
     logger,
+    shipper,
     ...persist ? {
       onEnrolled: (welcome) => persistEnrolment(env, { token, name: welcome.name, tenantId: welcome.tenantId })
     } : {}
@@ -5502,7 +5736,7 @@ async function startForeground(env, flags) {
 }
 async function stop(env) {
   const code = await runNodeStop();
-  if (code === 0) setDesired(env, "stopped");
+  if (code === 0 || code === STOP_FOREIGN_NODE) setDesired(env, "stopped");
   return code;
 }
 function updateCheckDeps(env) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dahrk-node",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",
@@ -34,7 +34,7 @@
   "exports": "./dist/main.js",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.183",
-    "@dahrk/contracts": "^0.1.2",
+    "@dahrk/contracts": "^0.2.0",
     "@openai/codex-sdk": "0.141.0",
     "pino": "^10.3.1",
     "ws": "^8.18.0",