@aiaiai-pt/martha-cli 0.29.0 → 0.30.0

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to `@aiaiai-pt/martha-cli`. Format: [Keep a Changelog](https
 
 ## [Unreleased]
 
+## [0.30.0] — 2026-07-03
+
+### Added — #761 runner heartbeat + poll-based cancel
+- `martha runner` now runs each task's goal **asynchronously with a heartbeat loop** (every `min(lease_timeout_s/3, 60)`s). Heartbeats renew the lease, so a task longer than its lease is no longer reclaimed by the lease reaper while still executing on the host (the Slice-0 double-execution hazard).
+- Cancelling a claimed task (`martha tasks cancel <id>` or the admin route) now actually stops it: the heartbeat reply carries `signal: "cancel"`, the runner kills the goal's **entire process tree** (SIGTERM the group, SIGKILL after 5s), and reports the partial output with `status: "cancelled"` — accepted idempotently server-side. Worst-case kill latency is one heartbeat interval (≤60s).
+- Heartbeat failures (network blips, 409s) never affect the running job — only an explicit `signal: "cancel"` kills.
+
+### Changed
+- The runner no longer "backgrounds" goals after 20s (a Slice-0 artifact that reported long tasks as `completed` while they were still running) — it now waits for real completion, kept alive by the heartbeat loop.
+
+<!-- 0.29.0 shipped 2026-07-02 (#751 asks + trigger-tasking) without a CHANGELOG section — see git history. -->
+
 ## [0.28.0] — 2026-06-30
 
 ### Added — #714 Slice 1 external-agent `event.emit` binding surfaces

package/dist/index.js

@@ -11063,7 +11063,7 @@ init_config();
 init_errors();
 
 // src/version.ts
-var CLI_VERSION = "0.29.0";
+var CLI_VERSION = "0.30.0";
 
 // src/commands/sessions.ts
 function relativeTime(iso) {
@@ -11421,6 +11421,68 @@ async function runHostCommand(command, toolCallId, opts) {
 function safeName(s) {
   return s.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 120) || "task";
 }
+async function startHostCommand(command, toolCallId, opts) {
+  const dir = runnerDir(opts.cwd);
+  await fs5.mkdir(dir, { recursive: true });
+  const logPath = path4.join(dir, `${safeName(toolCallId)}.log`);
+  await fs5.writeFile(logPath, "");
+  const fd = openSync(logPath, "a");
+  const cap = opts.maxOutputBytes ?? MAX_OUTPUT;
+  const readLog = async () => {
+    try {
+      const buf = await fs5.readFile(logPath);
+      return buf.subarray(-cap).toString("utf8");
+    } catch {
+      return "";
+    }
+  };
+  const child = spawn(command, {
+    shell: true,
+    cwd: opts.cwd,
+    detached: true,
+    stdio: ["ignore", fd, fd]
+  });
+  closeSync(fd);
+  let exited = false;
+  const done = new Promise((resolve, reject) => {
+    let settled = false;
+    child.on("error", (e) => {
+      if (settled)
+        return;
+      settled = true;
+      exited = true;
+      reject(e);
+    });
+    child.on("close", async (code) => {
+      if (settled)
+        return;
+      settled = true;
+      exited = true;
+      resolve({
+        stdout: await readLog(),
+        stderr: "",
+        exit_code: code ?? -1,
+        log_path: logPath
+      });
+    });
+  });
+  const kill = (graceMs = 5000) => {
+    if (exited || !child.pid)
+      return;
+    try {
+      process.kill(-child.pid, "SIGTERM");
+    } catch {}
+    const escalate = setTimeout(() => {
+      if (exited || !child.pid)
+        return;
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch {}
+    }, graceMs);
+    escalate.unref?.();
+  };
+  return { pid: child.pid, done, kill };
+}
 function mintExecSecret() {
   return randomBytes2(32).toString("hex");
 }
@@ -17152,6 +17214,17 @@ init_errors();
 function sleep5(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
+function sleepUnref(ms) {
+  return new Promise((r) => {
+    const t = setTimeout(r, ms);
+    t.unref?.();
+  });
+}
+var DEFAULT_LEASE_S = 300;
+function heartbeatIntervalMs(leaseTimeoutS) {
+  const lease = typeof leaseTimeoutS === "number" && leaseTimeoutS > 0 ? leaseTimeoutS : DEFAULT_LEASE_S;
+  return Math.min(lease / 3, 60) * 1000;
+}
 async function runOnce(ctx, opts, handled) {
   const tasks = await ctx.api.get("/api/tasks/poll", {
     params: { agent_id: opts.agent, limit: String(opts.pollLimit ?? 5) }
@@ -17169,20 +17242,55 @@ async function runOnce(ctx, opts, handled) {
   handled?.add(task.id);
   const claimed = await ctx.api.post(`/api/tasks/${encodeURIComponent(task.id)}/claim`, {});
   const goal = claimed.goal ?? task.goal ?? "";
+  const intervalMs = heartbeatIntervalMs(claimed.lease_timeout_s ?? DEFAULT_LEASE_S);
   process.stderr.write(source_default.dim(`
-[runner] claimed ${task.id} — running: ${goal}
+[runner] claimed ${task.id} — running: ${goal} (heartbeat every ${Math.round(intervalMs / 1000)}s)
 `));
   let result;
+  let cancelled = false;
   try {
-    result = await runHostCommand(goal, `task-${task.id}`, { cwd: opts.cwd });
+    const handle = await startHostCommand(goal, `task-${task.id}`, {
+      cwd: opts.cwd
+    });
+    const done = handle.done.catch((e) => ({
+      stdout: "",
+      stderr: String(e),
+      exit_code: -1
+    }));
+    for (;; ) {
+      const raced = await Promise.race([
+        done,
+        sleepUnref(intervalMs).then(() => null)
+      ]);
+      if (raced !== null) {
+        result = raced;
+        break;
+      }
+      let reply;
+      try {
+        reply = await ctx.api.post(`/api/tasks/${encodeURIComponent(task.id)}/heartbeat`, {});
+      } catch (e) {
+        process.stderr.write(source_default.yellow(`[runner] heartbeat failed for ${task.id} (job unaffected): ${String(e)}
+`));
+        continue;
+      }
+      if (reply && reply.signal === "cancel") {
+        process.stderr.write(source_default.yellow(`[runner] cancel signal for ${task.id} — killing process tree
+`));
+        handle.kill();
+        result = await done;
+        cancelled = true;
+        break;
+      }
+    }
   } catch (e) {
     result = { stdout: "", stderr: String(e), exit_code: -1 };
   }
   const exit_code = result.exit_code;
   const stdout = result.stdout || result.stderr || "";
-  const status = exit_code === 0 ? "completed" : "failed";
+  const status = cancelled ? "cancelled" : exit_code === 0 ? "completed" : "failed";
   await ctx.api.post(`/api/tasks/${encodeURIComponent(task.id)}/complete`, {
-    outcome: { stdout, exit_code },
+    outcome: cancelled ? { stdout, exit_code, cancelled: true } : { stdout, exit_code },
     status
   });
   process.stderr.write(source_default.dim(`[runner] completed ${task.id} — ${status} (exit ${exit_code})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiaiai-pt/martha-cli",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "Terminal-first client for the Martha AI platform",
   "homepage": "https://docs.martha.nomadriver.co",
   "repository": {