hilos-agent 0.11.9 → 0.11.11

package/bin/hilos-agent.mjs

@@ -30,6 +30,7 @@ import { hookMain, hooksMain } from "../src/hook.mjs";
 import { runWebMcpCommand } from "../src/webmcp-bridge.mjs";
 import { detectVendor, fastChatCmd, webCapability } from "../src/progress-emitter.mjs";
 import { commandArgv } from "../src/argv.mjs";
+import { runWithTerminalSignals } from "../src/cli.mjs";
 
 // 1251 — the plugin writes `hook --claude --personal`, so the client flags name
 // the vendor for `hook` the same way they choose a target for `hooks install`.
@@ -318,7 +319,7 @@ async function main() {
   delete cliFlags.joinStdin;
   delete cliFlags.help;
   const cfg = resolveConfig({ flags: cliFlags, join: joinPayload });
-  await run(cfg);
+  await runWithTerminalSignals((signal) => run(cfg, { signal }));
 }
 
 main().catch((e) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hilos-agent",
-  "version": "0.11.9",
+  "version": "0.11.11",
   "description": "Run your own coding agent (Claude Code, Codex, Cursor, OpenCode, Hermes, or any command) as a teammate in a hilos room. The checkout and credentials stay local; changes go to your configured Git remote as a PR for human review, and bounded progress and reports go to hilos.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -7,6 +7,30 @@
 
 import { spawn } from "node:child_process";
 
+/**
+ * Let the daemon finish its existing abort/cleanup path before exiting.
+ * @param {(signal: AbortSignal) => Promise<any>} task
+ * @param {import("node:events").EventEmitter & { exitCode?: number | string }} signalSource
+ */
+export async function runWithTerminalSignals(task, signalSource = process) {
+  const controller = new AbortController();
+  const interrupt = () => stop("SIGINT", 130);
+  const terminate = () => stop("SIGTERM", 143);
+  const stop = (name, code) => {
+    if (controller.signal.aborted) return;
+    signalSource.exitCode = code;
+    controller.abort(new Error(`Daemon received ${name}`));
+  };
+  signalSource.once("SIGINT", interrupt);
+  signalSource.once("SIGTERM", terminate);
+  try {
+    return await task(controller.signal);
+  } finally {
+    signalSource.removeListener("SIGINT", interrupt);
+    signalSource.removeListener("SIGTERM", terminate);
+  }
+}
+
 // ── Environment isolation ────────────────────────────────────────────────────
 // The coding/chat CLI we spawn (`claude -p`, `codex`, …) is a model with tool
 // use: it can run `env`/`printenv` and echo whatever it sees into the channel.

package/src/handler.mjs

@@ -4975,6 +4975,11 @@ export async function handleTask({ message, channelId, tool, me, caps = {}, iter
       body,
     });
     await updateChannelMarker(compactRunMarker("cancelled", branch));
+    // 1270 — a process interruption has no server-side Stop action to settle
+    // the row. Iterate claims keep their fenced recovery path in run().
+    if (runId && caps.runs && !iterateClaimId) {
+      await tool("update_run", { runId, status: "failed", reason: "daemon-stopped" }).catch(() => {});
+    }
     // Every repo-lane cancel funnels through here, so one settle covers them
     // all: a stopped run still spent tokens (0787).
     await settleRunUsage();
@@ -5254,8 +5259,19 @@ export async function handleTask({ message, channelId, tool, me, caps = {}, iter
       compactRunMarker(staged.failed ? "run-failed" : "no-changes", branch),
     );
     await settleRunUsage(); // "no changes" is not "no spend" (0787)
-    // 1182 — no turn is left in this pass: what is held is answered now.
+    // 1182 — retry direction receipts before terminal settlement drops any
+    // still-unacknowledged input. No turn is left in this pass.
     if (directions) await directions.close();
+    // A terminal progress card is presentation; it does not settle this row.
+    // Keep an existing PR at its review gate when feedback produces no diff.
+    if (runId && caps.runs && !iterateClaimId) {
+      await tool("update_run", {
+        runId,
+        status: continuingPrUrl ? "awaiting_review" : staged.failed ? "failed" : "succeeded",
+        ...(continuingPrUrl ? { prUrl: continuingPrUrl } : {}),
+        ...(!continuingPrUrl ? { reason: staged.failed ? "coding-tool-failed" : "no-changes" } : {}),
+      });
+    }
     return { status: staged.failed ? "run-failed" : "no-changes" };
   };
   if (staged.empty) return await finishEmptyTree({ afterDirection: afterCoding.advanced });

package/src/hook.mjs

@@ -26,6 +26,7 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { sanitizeText, webTarget } from "./agent-events.mjs";
 import { resolveConfig } from "./config.mjs";
+import { normalizeSeatRepository } from "./seat-repository.mjs";
 
 export const HOOK_STATE_DIR = join(homedir(), ".hilos", "hook-state");
 export const CODEX_HOOK_SCOPE_FILE = join(homedir(), ".hilos", "codex-hook-scope.json");
@@ -402,24 +403,25 @@ export function seatLabel(value) {
 }
 
 /**
- * The label for this session's seat: the repo from `git remote`, else the
- * folder name. `git` is asked once per session (SessionStart) with a short
- * timeout, and a failure just falls back — a hook never blocks the CLI.
+ * The canonical origin for this session. Git is asked once at attach with a
+ * short timeout. A missing or unsupported origin leaves the seat unbound.
  */
-export function readSeatLabel(cwd, { spawn = spawnSync } = {}) {
-  const folder = seatLabel(cwd);
+export function readSeatRepository(cwd, { spawn = spawnSync } = {}) {
   try {
     const out = spawn("git", ["-C", String(cwd || "."), "remote", "get-url", "origin"], {
       encoding: "utf8",
       timeout: 1500,
     });
-    const remote = out?.status === 0 ? seatLabel(out.stdout) : "";
-    return remote || folder;
+    return out?.status === 0 ? normalizeSeatRepository(out.stdout) : null;
   } catch {
-    return folder;
+    return null;
   }
 }
 
+export function readSeatLabel(cwd, options) {
+  return seatLabel(readSeatRepository(cwd, options)) || seatLabel(cwd);
+}
+
 /** One bounded personal `tools/call`. Returns the parsed payload, or null. */
 export async function callPersonalTool({ url, token, client, name, args }) {
   const controller = new AbortController();
@@ -463,7 +465,8 @@ export async function runPersonalSeat({
   now = Date.now,
   note = "",
   call = callPersonalTool,
-  label = readSeatLabel,
+  label,
+  repository = readSeatRepository,
 }) {
   if (!personal || !ev) return state;
   const seat = state.seat && typeof state.seat === "object" ? state.seat : {};
@@ -479,12 +482,14 @@ export async function runPersonalSeat({
     ev.event === "PostToolUse";
   if (!seat.id && !wantsSeat) return state;
   if (ev.event === "SessionStart" || !seat.id) {
+    const repositoryUrl = repository(ev.cwd);
     const attached = await call({
       ...base,
       name: "attach_session",
       args: {
         client: personal.client,
-        label: label(ev.cwd),
+        label: label ? label(ev.cwd) : seatLabel(repositoryUrl) || seatLabel(ev.cwd),
+        ...(repositoryUrl ? { repositoryUrl } : {}),
         sessionKey: ev.sessionId,
       },
     });

package/src/seat-repository.d.mts

@@ -0,0 +1 @@
+export function normalizeSeatRepository(value: unknown): string | null;

package/src/seat-repository.mjs

@@ -0,0 +1,24 @@
+/**
+ * A GitHub origin as a credential-free HTTPS URL. Room links currently name
+ * GitHub repositories, so another host (even with the same owner/repo), local
+ * paths, SSH aliases, and malformed remotes cannot select a room.
+ */
+export function normalizeSeatRepository(value) {
+  if (typeof value !== "string") return null;
+  const text = value.trim();
+  if (!text || /[\\\s]/.test(text)) return null;
+  let url;
+  try {
+    const scp = text.match(/^git@github\.com:([^?#]+)$/i);
+    url = new URL(scp ? `https://github.com/${scp[1]}` : text);
+  } catch {
+    return null;
+  }
+  if (!["https:", "http:", "ssh:", "git:"].includes(url.protocol) ||
+      url.hostname.toLowerCase() !== "github.com" || url.port) return null;
+  const path = url.pathname.replace(/\/$/, "").replace(/\.git$/i, "");
+  if (!/^\/[a-z0-9-]+\/[a-z0-9_.-]+$/i.test(path)) return null;
+  const [, owner, repo] = path.split("/");
+  if (repo === "." || repo === "..") return null;
+  return `https://github.com/${owner.toLowerCase()}/${repo.toLowerCase()}`;
+}