hilos-agent 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hilos-agent",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Run your own coding agent (Claude Code / Codex / Cursor) as an autonomous teammate in a hilos channel. Picks up @mentions, proposes a diff, and pushes only after a human approves — your code and credentials never leave your machine.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -0,0 +1,106 @@
+// Async CLI runner with a heartbeat. The coding CLI (`claude -p`, `codex`, …)
+// runs for minutes and — with the default output format — buffers everything
+// until it exits. The old blocking `spawnSync` froze the event loop, so the
+// terminal sat dead-silent the whole time and people assumed it had hung and
+// hit Ctrl+C (losing the run). This spawns asynchronously, captures output, and
+// logs a periodic "still working…" heartbeat so the run visibly stays alive.
+
+import { spawn } from "node:child_process";
+
+/** Human-readable elapsed time: "45s", "2m 3s". */
+export function fmtElapsed(ms) {
+  const total = Math.max(0, Math.round(ms / 1000));
+  const m = Math.floor(total / 60);
+  const s = total % 60;
+  return m > 0 ? `${m}m ${s}s` : `${s}s`;
+}
+
+// Guard against a pathological run flooding memory; the CLI's result is small.
+const MAX_CAPTURE_BYTES = 50 * 1024 * 1024;
+
+/**
+ * @typedef {Object} RunCliOptions
+ * @property {string} cmd - command to run
+ * @property {string[]} [args] - arguments
+ * @property {string} [cwd] - working directory
+ * @property {number} [timeoutMs] - kill the child after this long (0 = no timeout)
+ * @property {string} [label] - verb shown in the heartbeat ("coding"/"thinking")
+ * @property {number} [heartbeatMs] - heartbeat interval (0 = no heartbeat)
+ * @property {() => number} [now] - clock, injectable for tests
+ * @property {{ log: (m: string) => void }} [log] - logger, injectable for tests
+ */
+
+/**
+ * Run `cmd args` to completion without blocking the event loop.
+ *
+ * Returns a spawnSync-shaped result so callers can swap it in directly:
+ *   { status: number|null, stdout: string, stderr: string, error: Error|null }
+ * `status` is the exit code, or null if the process failed to start or was
+ * killed (timeout). On timeout the child is SIGKILLed and `error` is set.
+ *
+ * @param {RunCliOptions} opts
+ */
+export function runCli(opts) {
+  const {
+    cmd,
+    args = [],
+    cwd,
+    timeoutMs = 0,
+    label = "working",
+    heartbeatMs = 15000,
+    now = Date.now,
+    log = console,
+  } = opts || {};
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(cmd, args, { cwd });
+    } catch (error) {
+      resolve({ status: null, stdout: "", stderr: "", error });
+      return;
+    }
+
+    let stdout = "";
+    let stderr = "";
+    // Decode at the stream level so a multibyte char split across chunks isn't
+    // corrupted (the chat path posts stdout verbatim). Matches spawnSync's utf8.
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    const append = (buf, chunk) =>
+      buf.length >= MAX_CAPTURE_BYTES ? buf : buf + chunk;
+    child.stdout?.on("data", (c) => (stdout = append(stdout, c)));
+    child.stderr?.on("data", (c) => (stderr = append(stderr, c)));
+
+    const start = now();
+    const beat =
+      heartbeatMs > 0
+        ? setInterval(() => {
+            log.log(`  … still ${label} (${fmtElapsed(now() - start)}) — Ctrl+C to cancel`);
+          }, heartbeatMs)
+        : null;
+    if (beat?.unref) beat.unref();
+
+    let timedOut = false;
+    const timer =
+      timeoutMs > 0
+        ? setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGKILL");
+          }, timeoutMs)
+        : null;
+    if (timer?.unref) timer.unref();
+
+    const finish = (status, error) => {
+      if (beat) clearInterval(beat);
+      if (timer) clearTimeout(timer);
+      resolve({
+        status,
+        stdout,
+        stderr,
+        error: error || (timedOut ? new Error(`timed out after ${fmtElapsed(timeoutMs)}`) : null),
+      });
+    };
+    child.on("error", (error) => finish(null, error));
+    child.on("close", (code) => finish(code, null));
+  });
+}

package/src/daemon.mjs

@@ -72,7 +72,11 @@ export function buildProposalReport(o) {
     o.diffText +
     (o.truncated ? `\n… (+${o.omittedLines} more lines)` : "") +
     "\n```";
-  const summary = `Proposed changes for: ${firstLine}\n\n${statLine}\n\n${diffBlock}`;
+  // Tag whoever asked so the proposal lands in their notifications, not just
+  // the channel. Handle matches the server's @-mention format (kebab of name).
+  const handle = mentionHandle(o.requester);
+  const lead = handle ? `@${handle} — proposed changes for: ${firstLine}` : `Proposed changes for: ${firstLine}`;
+  const summary = `${lead}\n\n${statLine}\n\n${diffBlock}`;
   const caveats = ["Not pushed yet — approve to push + open a PR, or reject to discard."];
   if (o.runFailed) caveats.push("The coding agent exited non-zero; review the diff carefully.");
   return { title: `Proposal: ${firstLine}`, summary, caveats, todos: [] };

package/src/handler.mjs

@@ -13,7 +13,15 @@ import {
   decisionKind,
   commitMessage,
   prTitleBody,
+  mentionHandle,
 } from "./daemon.mjs";
+import { runCli } from "./cli.mjs";
+
+/** `@handle` for the person who asked, so the report tags them. */
+function requesterTag(author) {
+  const handle = mentionHandle(author);
+  return handle ? `@${handle}` : "";
+}
 
 function defaultDeps() {
   return {
@@ -54,7 +62,9 @@ async function awaitDecision({ tool, channelId, reportMessageId, cfg, deps }) {
   return { kind: "timeout" };
 }
 
-async function applyDecision({ decision, repoPath, branch, task, cfg, tool, channelId, deps }) {
+async function applyDecision({ decision, repoPath, branch, task, requester, cfg, tool, channelId, deps }) {
+  const tag = requesterTag(requester);
+  const lead = tag ? `${tag} — ` : "";
   if (decision.kind === "approved") {
     // Guard: nothing staged → don't push an empty branch and falsely report "shipped".
     if (deps.git(repoPath, ["diff", "--cached", "--quiet"]).status === 0) {
@@ -87,8 +97,8 @@ async function applyDecision({ decision, repoPath, branch, task, cfg, tool, chan
       title: `Shipped: ${title}`,
       summary:
         pr.ok && pr.url
-          ? `Pushed \`${branch}\` and opened a pull request.`
-          : `Pushed \`${branch}\`. Open a PR manually — \`gh\` failed.`,
+          ? `${lead}pushed \`${branch}\` and opened a pull request.`
+          : `${lead}pushed \`${branch}\`. Open a PR manually — \`gh\` failed.`,
       prUrl: pr.ok && pr.url ? pr.url : undefined,
       caveats: pr.ok ? [] : [`gh pr create failed: ${(pr.stderr || "").trim().slice(0, 200)}`],
     });
@@ -170,12 +180,16 @@ async function respondConversationally({ message, channelId, tool, me, cfg }) {
     `Conversation so far:\n${transcript}`;
 
   const parts = cfg.codingCmd.split(" ").filter(Boolean);
-  const run = spawnSync(parts[0], [...parts.slice(1), prompt], {
-    encoding: "utf8",
-    timeout: cfg.runTimeoutMs,
-    maxBuffer: 50 * 1024 * 1024,
+  console.log(`  chat → running \`${cfg.codingCmd}\` (output appears when it finishes)…`);
+  const run = await runCli({
+    cmd: parts[0],
+    args: [...parts.slice(1), prompt],
+    timeoutMs: cfg.runTimeoutMs,
+    label: "thinking",
   });
   const reply = (run.stdout || "").trim();
+  if (run.error) console.log(`  ! ${parts[0]} failed to start: ${run.error.message}`);
+  console.log(`  chat → ${reply ? `replied (${reply.length} chars)` : "no output"}; posting`);
   await tool("post_message", {
     channelId,
     body: reply || `(my CLI returned nothing — is \`${cfg.codingCmd}\` installed and on PATH?)`,
@@ -248,19 +262,29 @@ export async function handleTask({ message, channelId, tool, me }, cfg, depsOver
 
   const parts = cfg.codingCmd.split(" ").filter(Boolean);
   const proposeRound = async (promptText) => {
-    const run = spawnSync(parts[0], [...parts.slice(1), promptText], {
+    console.log(
+      `  code → running \`${cfg.codingCmd}\` in ${repoPath} (this can take a few minutes; output appears when it finishes)…`,
+    );
+    const run = await runCli({
+      cmd: parts[0],
+      args: [...parts.slice(1), promptText],
       cwd: repoPath,
-      encoding: "utf8",
-      timeout: cfg.runTimeoutMs,
-      maxBuffer: 50 * 1024 * 1024,
+      timeoutMs: cfg.runTimeoutMs,
+      label: "coding",
     });
+    if (run.error) console.log(`  ! ${parts[0]} failed to start: ${run.error.message}`);
     git(repoPath, ["add", "-A"]);
     const diff = git(repoPath, ["diff", "--cached"]).stdout || "";
-    if (!diff.trim()) return { empty: true };
+    if (!diff.trim()) {
+      console.log("  code → no changes produced");
+      return { empty: true };
+    }
+    console.log("  code → diff captured; posting proposal");
     const stat = parseShortstat(git(repoPath, ["diff", "--cached", "--shortstat"]).stdout);
     const { text: diffText, truncated, omittedLines } = truncateDiff(diff);
     const report = buildProposalReport({
       task: message.body,
+      requester: message.author,
       repoFullName,
       branch,
       diffText,
@@ -316,6 +340,7 @@ export async function handleTask({ message, channelId, tool, me }, cfg, depsOver
     repoPath,
     branch,
     task: message.body,
+    requester: message.author,
     cfg,
     tool,
     channelId,