@hasna/loops 0.4.5 → 0.4.6

package/dist/runner/index.d.ts

@@ -25,7 +25,9 @@ export interface RunRunnerOnceOptions {
     now?: Date;
     heartbeatIntervalMs?: number;
     fetchImpl?: typeof fetch;
-    execute?: (loop: Loop, run: LoopRun) => Promise<ExecutorResult>;
+    execute?: (loop: Loop, run: LoopRun, opts?: {
+        signal?: AbortSignal;
+    }) => Promise<ExecutorResult>;
     env?: NodeJS.ProcessEnv;
 }
 export declare function runRunnerOnce(opts?: RunRunnerOnceOptions): Promise<RunnerOnceResult>;

package/dist/runner/index.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.5",
+  version: "0.4.6",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -272,7 +272,7 @@ function deploymentStatusLine(status) {
 import { Command } from "commander";
 
 // src/lib/executor.ts
-import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
+import { spawn as spawn2, spawnSync as spawnSync3 } from "child_process";
 import { randomBytes as randomBytes2 } from "crypto";
 import { once } from "events";
 import { lstatSync, mkdirSync, realpathSync } from "fs";
@@ -919,6 +919,86 @@ function refreshLoopMachine(machine) {
   return resolveLoopMachine(machine.id);
 }
 
+// src/lib/process-identity.ts
+import { readFileSync } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+var START_TIME_TOLERANCE_MS = 5000;
+var clockTicksCache;
+function clockTicksPerSecond() {
+  if (clockTicksCache !== undefined)
+    return clockTicksCache;
+  try {
+    const run = spawnSync2("getconf", ["CLK_TCK"], { encoding: "utf8" });
+    const value = Number(run.stdout.trim());
+    clockTicksCache = run.status === 0 && Number.isFinite(value) && value > 0 ? value : 100;
+  } catch {
+    clockTicksCache = 100;
+  }
+  return clockTicksCache;
+}
+var bootTimeCache;
+var bootTimeResolved = false;
+function bootTimeMs() {
+  if (bootTimeResolved)
+    return bootTimeCache;
+  bootTimeResolved = true;
+  try {
+    const match = readFileSync("/proc/stat", "utf8").match(/^btime (\d+)$/m);
+    bootTimeCache = match ? Number(match[1]) * 1000 : undefined;
+  } catch {
+    bootTimeCache = undefined;
+  }
+  return bootTimeCache;
+}
+function procStatFields(path) {
+  try {
+    const stat = readFileSync(path, "utf8");
+    const closeParen = stat.lastIndexOf(")");
+    if (closeParen < 0)
+      return;
+    return stat.slice(closeParen + 2).split(" ");
+  } catch {
+    return;
+  }
+}
+function processStartTimeMs(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return;
+  if (process.platform === "linux") {
+    const fields = procStatFields(`/proc/${pid}/stat`);
+    const startTicks = fields ? Number(fields[19]) : Number.NaN;
+    const boot = bootTimeMs();
+    if (Number.isFinite(startTicks) && boot !== undefined) {
+      return boot + Math.round(startTicks / clockTicksPerSecond() * 1000);
+    }
+  }
+  try {
+    const run = spawnSync2("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8" });
+    if (run.status === 0) {
+      const parsed = Date.parse(run.stdout.trim());
+      if (Number.isFinite(parsed))
+        return parsed;
+    }
+  } catch {}
+  return;
+}
+function sameProcessStart(recorded, actualMs, toleranceMs = START_TIME_TOLERANCE_MS) {
+  if (recorded === undefined || actualMs === undefined)
+    return true;
+  const recordedMs = typeof recorded === "number" ? recorded : Date.parse(recorded);
+  if (!Number.isFinite(recordedMs))
+    return true;
+  return Math.abs(recordedMs - actualMs) <= toleranceMs;
+}
+function verifiedProcessStart(recorded, actualMs, toleranceMs = START_TIME_TOLERANCE_MS) {
+  if (recorded === undefined || actualMs === undefined)
+    return false;
+  const recordedMs = typeof recorded === "number" ? recorded : Date.parse(recorded);
+  if (!Number.isFinite(recordedMs))
+    return false;
+  return Math.abs(recordedMs - actualMs) <= toleranceMs;
+}
+
 // src/lib/executor.ts
 var DEFAULT_TIMEOUT_MS = 30 * 60000;
 var DEFAULT_MAX_OUTPUT_BYTES = 256 * 1024;
@@ -993,7 +1073,12 @@ function notifySpawn(pid, opts) {
   if (!pid)
     return;
   opts.onSpawn?.(pid);
-  opts.onSpawnProcess?.({ pid, pgid: pid, processStartedAt: nowIso() });
+  const startedMs = processStartTimeMs(pid);
+  opts.onSpawnProcess?.({
+    pid,
+    pgid: pid,
+    processStartedAt: startedMs !== undefined ? new Date(startedMs).toISOString() : nowIso()
+  });
 }
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -1285,7 +1370,7 @@ function assertCodewithProfileListed(profile, result) {
 function preflightNativeAuthProfileSync(spec, env) {
   if (spec.nativeAuthProfile?.provider !== "codewith")
     return;
-  const result = spawnSync2(spec.command, ["profile", "list"], {
+  const result = spawnSync3(spec.command, ["profile", "list"], {
     encoding: "utf8",
     env,
     stdio: ["ignore", "pipe", "pipe"],
@@ -1348,6 +1433,13 @@ function numberField(value, key) {
 function codewithAgentStatus(readJson) {
   return stringField(recordField(readJson, "agent"), "status") ?? stringField(recordField(readJson, "statusSnapshot"), "status");
 }
+function codewithAgentLastEventSeq(readJson) {
+  const agentSeq = numberField(recordField(readJson, "agent"), "lastEventSeq");
+  const snapshotSeq = numberField(recordField(readJson, "statusSnapshot"), "lastEventSeq");
+  if (agentSeq !== undefined && snapshotSeq !== undefined)
+    return Math.max(agentSeq, snapshotSeq);
+  return agentSeq ?? snapshotSeq;
+}
 function codewithAgentEvidence(startJson, readJson, logsJson) {
   const agent = recordField(readJson, "agent") ?? recordField(startJson, "agent");
   const statusSnapshot = recordField(readJson, "statusSnapshot");
@@ -1378,6 +1470,21 @@ function codewithAgentEvidence(startJson, readJson, logsJson) {
     events
   }, null, 2);
 }
+function codewithAgentProgress(readJson) {
+  const agent = recordField(readJson, "agent");
+  const statusSnapshot = recordField(readJson, "statusSnapshot");
+  return {
+    provider: "codewith",
+    agentId: stringField(agent, "agentId"),
+    status: stringField(agent, "status") ?? stringField(statusSnapshot, "status"),
+    summary: stringField(statusSnapshot, "summary"),
+    statusReason: stringField(agent, "statusReason"),
+    threadId: stringField(agent, "threadId"),
+    rolloutPath: stringField(agent, "rolloutPath"),
+    pid: numberField(agent, "pid"),
+    lastEventSeq: codewithAgentLastEventSeq(readJson)
+  };
+}
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
@@ -1412,6 +1519,7 @@ async function executeCodewithDurableAgent(spec, metadata, opts, env, startedAt)
   if (!agentId) {
     return failureResult(startedAt, "codewith agent start did not return agent.agentId", { stdout: start.stdout, stderr: stderr.value() });
   }
+  opts.onAgentProgress?.(codewithAgentProgress(startJson));
   const stopAgent = async () => {
     await spawnCapture(spec.command, codewithAgentControlArgs(target, "stop", agentId), {
       cwd: spec.cwd,
@@ -1454,10 +1562,15 @@ async function executeCodewithDurableAgent(spec, metadata, opts, env, startedAt)
       });
     }
     const status = codewithAgentStatus(lastReadJson);
-    const fingerprint = JSON.stringify({ status, snapshot: recordField(lastReadJson, "statusSnapshot") ?? null });
+    const fingerprint = JSON.stringify({
+      status,
+      agentLastEventSeq: numberField(recordField(lastReadJson, "agent"), "lastEventSeq"),
+      snapshot: recordField(lastReadJson, "statusSnapshot") ?? null
+    });
     if (fingerprint !== lastFingerprint) {
       lastFingerprint = fingerprint;
       lastProgressAt = Date.now();
+      opts.onAgentProgress?.(codewithAgentProgress(lastReadJson));
     }
     if (status === "completed" || status === "failed" || status === "cancelled") {
       const logs = await spawnCapture(spec.command, codewithAgentControlArgs(target, "logs", agentId), {
@@ -1595,7 +1708,7 @@ function worktreeFallbackSpec(target, opts, fallbackCwd) {
 }
 function preflightRemoteSpec(spec, machine, metadata, opts) {
   const plan = (opts.machineCommandResolver ?? resolveMachineCommand)(machine.id, "bash -s");
-  const result = spawnSync2(plan.command, plan.args, {
+  const result = spawnSync3(plan.command, plan.args, {
     encoding: "utf8",
     env: transportEnv(opts),
     input: remotePreflightScript(spec, metadata),
@@ -1869,6 +1982,7 @@ async function executeLoop(loop, run, opts = {}) {
 var program = new Command;
 var DEFAULT_RUNNER_ID = `runner:${process.pid}`;
 var MIN_RUNNER_LEASE_MS = 1000;
+var MAX_CONSECUTIVE_HEARTBEAT_FAILURES = 3;
 program.name("loops-runner").description("OpenLoops control-plane runner foundation").version(packageVersion()).option("-j, --json", "print JSON");
 function configuredApiUrl(env = process.env) {
   return env.LOOPS_API_URL?.trim() || env.HASNA_LOOPS_API_URL?.trim() || env.LOOPS_CLOUD_API_URL?.trim() || env.HASNA_LOOPS_CLOUD_API_URL?.trim();
@@ -1972,15 +2086,20 @@ async function executeClaimWithHeartbeat(fetchImpl, config, claim, opts) {
     });
   };
   await heartbeat();
-  let lastHeartbeatError;
+  const controller = new AbortController;
+  let consecutiveFailures = 0;
   const timer = setInterval(() => {
-    heartbeat().catch((error) => {
-      lastHeartbeatError = error;
+    heartbeat().then(() => {
+      consecutiveFailures = 0;
+    }, () => {
+      consecutiveFailures += 1;
+      if (consecutiveFailures >= MAX_CONSECUTIVE_HEARTBEAT_FAILURES && !controller.signal.aborted) {
+        controller.abort();
+      }
     });
   }, heartbeatIntervalMs);
   try {
-    const result = await execute(claim.loop, claim.run);
-    return result;
+    return await execute(claim.loop, claim.run, { signal: controller.signal });
   } finally {
     clearInterval(timer);
   }