hilos-agent 0.1.15 → 0.4.0

package/src/run.mjs

@@ -2,16 +2,66 @@
 // each one to the task handler. Prefers the workspace-wide list_mentions tool
 // (one poll, cursor-based); falls back to per-channel scanning on older servers.
 
+import { hostname } from "node:os";
+import { basename } from "node:path";
 import { makeClient } from "./mcp.mjs";
 import { mentionHandle } from "./daemon.mjs";
 import { handleTask } from "./handler.mjs";
 import { createQueue, looksLikeCancel, dedupeKey } from "./queue.mjs";
 import { reloadConfig } from "./config.mjs";
 
-export async function run(cfg, { handler = handleTask, log = console } = {}) {
+/**
+ * The poll loop. Embeddable: pass a `signal` to stop it cleanly (interrupts the
+ * inter-poll sleep, cancels the active job, then resolves) and an `onEvent`
+ * listener to observe lifecycle events (status / task-start / task-done /
+ * task-error). Both are optional and backward compatible.
+ *
+ * @param {any} cfg
+ * @param {{
+ *   handler?: (ctx: any, cfg: any, deps?: any, opts?: any) => Promise<any>,
+ *   log?: any,
+ *   signal?: AbortSignal,
+ *   onEvent?: (event: { type: string, [k: string]: any }) => void,
+ * }} [opts]
+ */
+export async function run(cfg, { handler = handleTask, log = console, signal, onEvent } = {}) {
   if (!cfg.token) {
-    log.error("No token. Run `hilos-agent init`, set HILOS_TOKEN, or use --join <blob>.");
-    process.exit(1);
+    // Throw, don't process.exit — the CLI's main().catch prints + exits 1 exactly
+    // as before, and an embedding host (the desktop Local Agents runner) must
+    // never be killed by the daemon.
+    throw new Error("No token. Run `hilos-agent init`, set HILOS_TOKEN, or use --join <blob>.");
+  }
+
+  // Lifecycle events for an embedding host (e.g. the desktop Local Agents window).
+  // EVERY listener call is wrapped so a bad listener can never crash the loop.
+  const emit = (event) => {
+    if (!onEvent) return;
+    try {
+      onEvent(event);
+    } catch {
+      /* a bad event listener must never break the daemon */
+    }
+  };
+  // A sleep that resolves immediately when the signal aborts, so "stop" doesn't
+  // wait out the whole poll interval.
+  const interruptibleSleep = (ms) =>
+    new Promise((resolve) => {
+      if (signal?.aborted) return resolve();
+      const timer = setTimeout(() => {
+        signal?.removeEventListener?.("abort", onAbort);
+        resolve();
+      }, ms);
+      function onAbort() {
+        clearTimeout(timer);
+        resolve();
+      }
+      signal?.addEventListener?.("abort", onAbort, { once: true });
+    });
+
+  // Already asked to stop before we even connect → return cleanly, do nothing.
+  if (signal?.aborted) {
+    emit({ type: "status", text: "stopping" });
+    return;
   }
 
   const { tool, listToolNames } = makeClient({ url: cfg.url, token: cfg.token });
@@ -19,8 +69,8 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
   const who = await tool("whoami");
   const me = { ...who, handle: mentionHandle(who.agentName) };
   if (!me.handle) {
-    log.error("This agent has no display name / handle — set one in hilos, then reconnect.");
-    process.exit(1);
+    // Throw for the same reason as the token guard above — embed-safe, CLI-equal.
+    throw new Error("This agent has no display name / handle — set one in hilos, then reconnect.");
   }
   log.log(`hilos-agent: ${me.agentName} (@${me.handle}) — ${cfg.url}`);
   if (cfg.channelId) log.log(`scope: channel ${cfg.channelId}`);
@@ -31,7 +81,42 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
   const useMentions = !cfg.channelId && toolNames.includes("list_mentions");
   // Capabilities of THIS server, so the handler degrades gracefully on older
   // deploys (e.g. no edit_message → no live heartbeat, rather than erroring).
-  const caps = { editMessage: toolNames.includes("edit_message") };
+  const caps = {
+    editMessage: toolNames.includes("edit_message"),
+    postProgress: toolNames.includes("post_progress"),
+    // The RUNS entity (0279/0280): when absent (older server) the handler skips
+    // start_run/update_run silently and behaves exactly as before.
+    runs: toolNames.includes("start_run"),
+    // Cross-agent REVIEW execution (0288): the reviewer needs to read a PR's diff
+    // AND post an advisory review. Absent on older servers → review-requests fall
+    // through to today's chat/code behavior, exactly as before.
+    review: toolNames.includes("post_review") && toolNames.includes("get_pr_diff"),
+    // Agent memory (0297): when present the handler best-effort recalls team
+    // learnings before each coding task and prepends them to the prompt so the
+    // coding agent has the workspace's conventions and gotchas from the start.
+    // Absent on older servers → silently skipped, no change in behavior.
+    recall: toolNames.includes("recall"),
+  };
+
+  // Register local folders (0324/0325): a folder-mode daemon announces each
+  // channel→folder mapping to the server so the channel shows a folder chip
+  // without any manual step. Capability-gated on the server advertising
+  // link_folder (older deploys skip silently, exactly like recall). Best-effort:
+  // each call is wrapped so a failure logs one line and NEVER blocks startup.
+  // Done ONCE here at startup — config live-reload (reloadConfig, below) does NOT
+  // re-register, so a folders entry added while running needs a restart to link.
+  if (toolNames.includes("link_folder") && cfg.folders && Object.keys(cfg.folders).length) {
+    for (const [channelId, path] of Object.entries(cfg.folders)) {
+      if (!channelId || !path) continue;
+      const title = basename(path);
+      try {
+        await tool("link_folder", { channelId, path, title, hostname: hostname() });
+        emit({ type: "status", text: `linked folder ${title} to its channel` });
+      } catch (e) {
+        log.error(`link_folder failed for ${path}: ${e?.message || e}`);
+      }
+    }
+  }
 
   let channelIds = [];
   if (!useMentions) {
@@ -39,6 +124,7 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
     else channelIds = ((await tool("list_channels"))?.channels ?? []).map((c) => c.id);
   }
   log.log(useMentions ? "watching: @-mentions" : `watching: ${channelIds.length} channel(s)`);
+  emit({ type: "status", text: useMentions ? "watching @-mentions" : `watching ${channelIds.length} channel(s)` });
 
   const seen = new Set();
   const cursor = { value: since ? new Date(since).toISOString() : null };
@@ -52,15 +138,34 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
   // lets a "stop" (and new mentions) be picked up while a task is still running.
   const queue = createQueue({
     concurrency: cfg.queueConcurrency || 1,
-    runJob: (job, { signal }) => safeHandle(job.message, job.channelId, signal),
+    runJob: (job, { signal: jobSignal }) => safeHandle(job.message, job.channelId, jobSignal),
   });
 
-  async function safeHandle(message, channelId, signal) {
+  // Stopping the embedded daemon: the moment the caller aborts, cancel the active
+  // job (via the queue's existing cancel path — it aborts the in-flight job's
+  // signal) so a multi-minute run is torn down promptly, and emit a stopping
+  // event. New tasks are refused in intake(); the loop below exits on the same
+  // signal and run() resolves cleanly.
+  if (signal) {
+    signal.addEventListener(
+      "abort",
+      () => {
+        emit({ type: "status", text: "stopping" });
+        queue.cancelActive("run() aborted");
+      },
+      { once: true },
+    );
+  }
+
+  async function safeHandle(message, channelId, jobSignal) {
+    emit({ type: "task-start", channelId, messageId: message.id, text: (message.body || "").slice(0, 200) });
     try {
       log.log(`→ task in ${channelId}: "${(message.body || "").slice(0, 80)}"`);
       // liveCfg so a job uses the latest model/permission/codingCmd at run time.
-      await handler({ message, channelId, tool, me, caps }, liveCfg, undefined, { signal });
+      const result = await handler({ message, channelId, tool, me, caps }, liveCfg, undefined, { signal: jobSignal });
+      emit({ type: "task-done", channelId, status: result && result.status });
     } catch (e) {
+      emit({ type: "task-error", channelId, error: e?.message || String(e) });
       log.error(`handler error: ${e.message}`);
       await tool("post_message", {
         channelId,
@@ -73,6 +178,8 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
   // enqueued (deduped against an identical in-flight/queued ask), with an ack
   // when it lands behind work already in progress.
   async function intake(m, channelId) {
+    // Once we're stopping, don't start anything new.
+    if (signal?.aborted) return;
     if (looksLikeCancel(m.body) && (queue.active() || queue.size())) {
       queue.cancelActive("user asked to stop");
       await tool("post_message", {
@@ -125,11 +232,15 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
   }
 
   do {
+    if (signal?.aborted) break;
     // Pick up live edits to hilos-agent.json (model/permission/codingCmd/etc.)
     // before each pass. Guarded: a bad file leaves liveCfg untouched.
     try {
       const next = reloadConfig(liveCfg);
-      if (next.codingCmd !== liveCfg.codingCmd) log.log(`daemon: coding command → ${next.codingCmd}`);
+      if (next.codingCmd !== liveCfg.codingCmd) {
+        log.log(`daemon: coding command → ${next.codingCmd}`);
+        emit({ type: "status", text: "config reloaded" });
+      }
       liveCfg = next;
     } catch (e) {
       log.error(`config reload error (keeping previous): ${e.message}`);
@@ -145,6 +256,16 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
       await queue.idle();
       break;
     }
-    await new Promise((r) => setTimeout(r, liveCfg.pollMs));
-  } while (true);
+    if (signal?.aborted) break;
+    // Interruptible so an abort during the sleep returns promptly instead of
+    // waiting out the full poll interval.
+    await interruptibleSleep(liveCfg.pollMs);
+  } while (!signal?.aborted);
+
+  // Clean stop: make sure any active job is cancelled (the abort listener already
+  // fired for the common case, but this covers a break for other reasons) and let
+  // in-flight teardown settle before returning.
+  if (signal?.aborted) {
+    queue.cancelActive("run() aborted");
+  }
 }