hilos-agent 0.10.1 → 0.11.2

package/src/mcp.mjs

@@ -1,7 +1,27 @@
-// Minimal MCP-over-HTTP client (JSON-RPC 2.0). Dependency-free: uses global
-// fetch (Node >= 18). One bearer token, one endpoint.
+// Small MCP-over-HTTP client for the local daemon. It speaks hilos's current
+// stateless protocol when the server advertises it and falls back to the bare
+// legacy request shape for older servers. No runtime dependency is required.
+import { readFileSync } from "node:fs";
 import os from "node:os";
 
+export const MCP_PROTOCOL_VERSION = "2026-07-28";
+const META_PROTOCOL_VERSION = "io.modelcontextprotocol/protocolVersion";
+const META_CLIENT_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
+const META_CLIENT_INFO = "io.modelcontextprotocol/clientInfo";
+const DEFAULT_TIMEOUT_MS = 35_000;
+const DISCOVERY_TIMEOUT_MS = 10_000;
+const RETRY_DELAY_MS = 250;
+
+function installedVersion() {
+  try {
+    return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+  } catch {
+    return "unknown";
+  }
+}
+
+const CLIENT_INFO = { name: "hilos-agent", version: installedVersion() };
+
 // Best-effort host label so hilos can show "whose machine" this daemon runs on.
 export const DAEMON_CLIENT = (() => {
   try {
@@ -11,36 +31,379 @@ export const DAEMON_CLIENT = (() => {
   }
 })();
 
-export function makeClient({ url, token }) {
-  let id = 0;
+class McpRequestError extends Error {
+  constructor(message, details = {}) {
+    super(message);
+    this.name = "McpRequestError";
+    Object.assign(this, details);
+  }
+}
 
-  async function rpc(method, params) {
-    const res = await fetch(url, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${token}`,
-        "x-hilos-connection-mode": "daemon",
-        ...(DAEMON_CLIENT ? { "x-hilos-client": DAEMON_CLIENT } : {}),
-      },
-      body: JSON.stringify({ jsonrpc: "2.0", id: ++id, method, params }),
+// An authenticated daemon can be told that its credential is permanently no
+// longer usable (revoked/deleted agent, rotated token, etc.). Keep that signal
+// distinct from an ordinary auth lookup failure so the poll loop can stop
+// instead of retrying forever, without broadening every 401/403 into shutdown.
+export class McpAuthStopError extends McpRequestError {
+  constructor(message, details = {}) {
+    super(message, details);
+    this.name = "McpAuthStopError";
+    this.stop = true;
+  }
+}
+
+function headerValue(value) {
+  const text = String(value);
+  return /^[\x20-\x7e]+$/.test(text)
+    ? text
+    : `=?base64?${Buffer.from(text, "utf8").toString("base64")}?=`;
+}
+
+function namedParam(method) {
+  if (method === "tools/call" || method === "prompts/get") return "name";
+  if (method === "resources/read") return "uri";
+  if (["tasks/get", "tasks/update", "tasks/cancel"].includes(method)) return "taskId";
+  return null;
+}
+
+function requestSignal(parentSignal, timeoutMs, stopSignal) {
+  const controller = new AbortController();
+  const abortFromParent = () => controller.abort(parentSignal?.reason);
+  const abortFromStop = () => controller.abort(stopSignal?.reason);
+  if (stopSignal?.aborted) abortFromStop();
+  else if (parentSignal?.aborted) abortFromParent();
+  else {
+    parentSignal?.addEventListener("abort", abortFromParent, { once: true });
+    stopSignal?.addEventListener("abort", abortFromStop, { once: true });
+  }
+  const timer = setTimeout(() => controller.abort(new Error("request timed out")), timeoutMs);
+  timer.unref?.();
+  return {
+    signal: controller.signal,
+    cleanup() {
+      clearTimeout(timer);
+      parentSignal?.removeEventListener("abort", abortFromParent);
+      stopSignal?.removeEventListener("abort", abortFromStop);
+    },
+  };
+}
+
+function combinedSignal(...signals) {
+  const active = signals.filter(Boolean);
+  if (active.length === 0) return { signal: undefined, cleanup() {} };
+  const controller = new AbortController();
+  const listeners = new Map();
+  for (const source of active) {
+    const abort = () => controller.abort(source.reason);
+    listeners.set(source, abort);
+    if (source.aborted) {
+      abort();
+      break;
+    }
+    source.addEventListener("abort", abort, { once: true });
+  }
+  return {
+    signal: controller.signal,
+    cleanup() {
+      for (const [source, abort] of listeners) source.removeEventListener("abort", abort);
+    },
+  };
+}
+
+function retryable(error) {
+  if (error instanceof McpAuthStopError || error?.abortedByCaller || error?.retryExhausted) {
+    return false;
+  }
+  if (typeof error?.status === "number") {
+    return error.status === 408 || error.status === 429 || error.status >= 500;
+  }
+  return error?.code !== -32600 && error?.code !== -32601 && error?.code !== -32602;
+}
+
+function callerCanceled(cause) {
+  return new McpRequestError("hilos request canceled", {
+    cause,
+    abortedByCaller: true,
+  });
+}
+
+const defaultDelay = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) {
+    reject(callerCanceled(signal.reason));
+    return;
+  }
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(callerCanceled(signal.reason));
+  };
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve();
+  }, ms);
+  timer.unref?.();
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+
+function retryAfterMs(response) {
+  const raw = response?.headers?.get?.("retry-after");
+  if (!raw) return 0;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds) && seconds >= 0) return Math.ceil(seconds * 1000);
+  const at = Date.parse(raw);
+  return Number.isFinite(at) ? Math.max(0, at - Date.now()) : 0;
+}
+
+async function abortableDelay(delay, ms, signal) {
+  if (delay === defaultDelay) return defaultDelay(ms, signal);
+  if (!signal) return delay(ms);
+  if (signal.aborted) throw callerCanceled(signal.reason);
+  let onAbort;
+  const canceled = new Promise((_resolve, reject) => {
+    onAbort = () => reject(callerCanceled(signal.reason));
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    await Promise.race([Promise.resolve().then(() => delay(ms)), canceled]);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+
+function assertJsonRpcResponse(json, expectedId) {
+  const record = json && typeof json === "object" && !Array.isArray(json) ? json : null;
+  const hasResult = record && Object.prototype.hasOwnProperty.call(record, "result");
+  const hasError = record && Object.prototype.hasOwnProperty.call(record, "error");
+  const error = record?.error;
+  if (
+    !record ||
+    record.jsonrpc !== "2.0" ||
+    record.id !== expectedId ||
+    Boolean(hasResult) === Boolean(hasError) ||
+    (hasError && (
+      !error ||
+      typeof error !== "object" ||
+      Array.isArray(error) ||
+      !Number.isInteger(error.code) ||
+      typeof error.message !== "string"
+    ))
+  ) {
+    throw new McpRequestError("hilos returned an invalid JSON-RPC response", {
+      malformedResponse: true,
     });
+  }
+  return record;
+}
+
+export function makeClient({
+  url,
+  token,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  retryDelayMs = RETRY_DELAY_MS,
+  delay = defaultDelay,
+  fetchImpl = globalThis.fetch,
+}) {
+  let id = 0;
+  let negotiated = null;
+  let terminalError = null;
+  const stopController = new AbortController();
+
+  const latchStop = (error) => {
+    if (!terminalError) {
+      terminalError = error;
+      stopController.abort(error);
+    }
+    return terminalError;
+  };
+
+  async function request(method, params, options = {}) {
+    if (terminalError) throw terminalError;
+    const modern = options.protocolVersion === MCP_PROTOCOL_VERSION;
+    const requestParams = modern
+      ? {
+          ...(params ?? {}),
+          _meta: {
+            [META_PROTOCOL_VERSION]: MCP_PROTOCOL_VERSION,
+            [META_CLIENT_CAPABILITIES]: {},
+            [META_CLIENT_INFO]: CLIENT_INFO,
+          },
+        }
+      : params;
+    const headers = {
+      "content-type": "application/json",
+      accept: "application/json, text/event-stream",
+      authorization: `Bearer ${token}`,
+      "x-hilos-connection-mode": "daemon",
+      ...(DAEMON_CLIENT ? { "x-hilos-client": DAEMON_CLIENT } : {}),
+      ...(modern
+        ? {
+            "mcp-protocol-version": MCP_PROTOCOL_VERSION,
+            "mcp-method": method,
+          }
+        : {}),
+    };
+    const nameField = modern ? namedParam(method) : null;
+    if (nameField && typeof requestParams?.[nameField] === "string") {
+      headers["mcp-name"] = headerValue(requestParams[nameField]);
+    }
+
+    const callerSignal = options.signal;
+    if (callerSignal?.aborted) throw callerCanceled(callerSignal.reason);
+    const bounded = requestSignal(
+      callerSignal,
+      options.timeoutMs ?? timeoutMs,
+      stopController.signal,
+    );
+    const requestId = ++id;
+    let res;
+    let json = null;
+    let transportError = null;
+    try {
+      try {
+        res = await fetchImpl(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ jsonrpc: "2.0", id: requestId, method, params: requestParams }),
+          signal: bounded.signal,
+        });
+      } catch (error) {
+        transportError = error;
+      }
+      if (res) {
+        try {
+          // Keep the request bound alive until the entire response body has
+          // arrived. Fetch can resolve as soon as headers land while the body
+          // remains stalled indefinitely.
+          json = await res.json();
+        } catch (error) {
+          transportError = error;
+        }
+      }
+    } finally {
+      bounded.cleanup();
+    }
+
+    if (terminalError) throw terminalError;
+    if (callerSignal?.aborted) throw callerCanceled(transportError || callerSignal.reason);
+    if (bounded.signal.aborted) {
+      throw new McpRequestError("hilos request failed: request timed out", {
+        cause: transportError || bounded.signal.reason,
+      });
+    }
+    if (!res) {
+      throw new McpRequestError(
+        `hilos request failed: ${transportError?.message || transportError || "no response"}`,
+        { cause: transportError },
+      );
+    }
     if (!res.ok) {
-      const hint =
+      const authHint =
         res.status === 401 || res.status === 403
-          ? "token rejected — generate a fresh one in hilos (Connect)"
-          : await res.text().catch(() => "");
-      throw new Error(`hilos ${res.status}: ${hint.slice(0, 200)}`);
+          ? "token rejected; generate a fresh one in hilos (Connect)"
+          : typeof json?.error?.message === "string"
+            ? json.error.message
+            : `request failed with HTTP ${res.status}`;
+      const ErrorType =
+        (res.status === 401 || res.status === 403) && json?.stop === true
+          ? McpAuthStopError
+          : McpRequestError;
+      const error = new ErrorType(`hilos ${res.status}: ${authHint.slice(0, 200)}`, {
+        status: res.status,
+        stop: json?.stop === true,
+        code: json?.error?.code,
+        retryAfterMs: retryAfterMs(res),
+      });
+      throw error instanceof McpAuthStopError ? latchStop(error) : error;
     }
-    const json = await res.json();
-    if (json.error) throw new Error(json.error.message || "rpc error");
-    return json.result;
+    if (transportError) {
+      throw new McpRequestError("hilos returned an invalid JSON-RPC response", {
+        cause: transportError,
+        malformedResponse: true,
+      });
+    }
+    const envelope = assertJsonRpcResponse(json, requestId);
+    if (Object.prototype.hasOwnProperty.call(envelope, "error")) {
+      throw new McpRequestError(envelope.error.message, {
+        code: envelope.error.code,
+        data: envelope.error.data,
+      });
+    }
+    return envelope.result;
+  }
+
+  async function waitBeforeRetry(error, options) {
+    const waitMs = Math.max(retryDelayMs, Number(error?.retryAfterMs) || 0);
+    const linked = combinedSignal(options?.signal, stopController.signal);
+    try {
+      await abortableDelay(delay, waitMs, linked.signal);
+    } catch (delayError) {
+      if (terminalError) throw terminalError;
+      throw delayError;
+    } finally {
+      linked.cleanup();
+    }
+  }
+
+  async function discover(options = {}) {
+    let lastError;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        const result = await request("server/discover", undefined, {
+          signal: options.signal,
+          timeoutMs: Math.min(timeoutMs, DISCOVERY_TIMEOUT_MS),
+          protocolVersion: MCP_PROTOCOL_VERSION,
+        });
+        if (!Array.isArray(result?.supportedVersions)) {
+          throw new McpRequestError("hilos server/discover returned an invalid result", {
+            malformedResponse: true,
+          });
+        }
+        return result.supportedVersions.includes(MCP_PROTOCOL_VERSION) ? MCP_PROTOCOL_VERSION : null;
+      } catch (error) {
+        if (error?.code === -32601 || error?.status === 404) return null;
+        lastError = error;
+        if (attempt === 1 || !retryable(error)) {
+          // listTools also has one read retry. Mark a discovery error whose own
+          // retry is spent so that outer layer cannot accidentally negotiate
+          // two more times before surfacing the same failure.
+          if (attempt === 1 && error && typeof error === "object") error.retryExhausted = true;
+          throw error;
+        }
+        await waitBeforeRetry(error, options);
+      }
+    }
+    throw lastError;
+  }
+
+  async function protocol(options = {}) {
+    if (!negotiated) {
+      negotiated = discover(options).catch((error) => {
+        negotiated = null;
+        throw error;
+      });
+    }
+    return negotiated;
+  }
+
+  async function rpc(method, params, options = {}) {
+    if (method === "server/discover") {
+      return request(method, params, {
+        ...options,
+        protocolVersion: MCP_PROTOCOL_VERSION,
+      });
+    }
+    const protocolVersion = await protocol(options);
+    return request(method, params, { ...options, protocolVersion });
   }
 
   // Call a tool and parse its first text block (hilos tools return JSON text).
-  async function tool(name, args = {}) {
-    const r = await rpc("tools/call", { name, arguments: args });
-    const text = r?.content?.[0]?.text;
+  async function tool(name, args = {}, options = {}) {
+    const result = await rpc("tools/call", { name, arguments: args }, options);
+    const first = Array.isArray(result?.content) ? result.content[0] : null;
+    if (!first || first.type !== "text" || typeof first.text !== "string") {
+      throw new McpRequestError("hilos tools/call returned an invalid result", {
+        malformedResponse: true,
+      });
+    }
+    const text = first.text;
     try {
       return JSON.parse(text);
     } catch {
@@ -48,20 +411,34 @@ export function makeClient({ url, token }) {
     }
   }
 
-  // Full tool objects, schemas included — capability sniffing reads these
-  // (0866: an ARG-level addition like waitMs shows up in a tool's inputSchema,
-  // not in the tool list's names).
-  async function listTools() {
+  // Full tool objects, schemas included. Never turn discovery errors into an
+  // empty registry: that would silently downgrade a current daemon until its
+  // next restart. One bounded retry handles a transient read failure.
+  async function listTools(options = {}) {
     try {
-      return (await rpc("tools/list"))?.tools ?? [];
-    } catch {
-      return [];
+      const result = await rpc("tools/list", undefined, options);
+      if (!Array.isArray(result?.tools) || result.tools.some((tool) => !tool || typeof tool.name !== "string")) {
+        throw new McpRequestError("hilos tools/list returned an invalid result", {
+          malformedResponse: true,
+        });
+      }
+      return result.tools;
+    } catch (error) {
+      if (!retryable(error)) throw error;
+      await waitBeforeRetry(error, options);
+      const result = await rpc("tools/list", undefined, options);
+      if (!Array.isArray(result?.tools) || result.tools.some((tool) => !tool || typeof tool.name !== "string")) {
+        throw new McpRequestError("hilos tools/list returned an invalid result", {
+          malformedResponse: true,
+        });
+      }
+      return result.tools;
     }
   }
 
-  async function listToolNames() {
-    return (await listTools()).map((t) => t.name);
+  async function listToolNames(options = {}) {
+    return (await listTools(options)).map((tool) => tool.name);
   }
 
-  return { rpc, tool, listTools, listToolNames };
+  return { rpc, tool, listTools, listToolNames, stopSignal: stopController.signal };
 }

package/src/model-resolve.mjs

@@ -16,6 +16,8 @@
 // PURE + node-builtins-only; the resolver takes an injected `run` (runCli) so
 // tests drive it with no CLI; a resolution failure NEVER breaks a run ([]).
 
+import { commandArgv } from "./argv.mjs";
+
 /** Strip ANSI SGR color codes (`--list-models` output is colorized). */
 export function stripAnsi(s) {
   // eslint-disable-next-line no-control-regex
@@ -253,7 +255,7 @@ export function createModelArgsResolver({ run } = {}) {
       // Hand-pinned wins — including codex's short spelling (`-m gpt-5.6-sol`),
       // which is what its own help leads with.
       if (/(^|\s)(--model|-m)(\s|=)/.test(cmd + " ")) return [];
-      const bin = cmd.trim().split(/\s+/)[0] || spec.bin;
+      const bin = commandArgv(cmd)[0] || spec.bin;
       const key = `${bin} ${tier}`;
       if (cache.has(key)) return cache.get(key);
       const r = await run({ cmd: bin, args: spec.args, timeoutMs: 30000, heartbeatMs: 0 });

package/src/opencode-session.mjs

@@ -29,6 +29,13 @@ function abortError(reason = "cancelled") {
   return error;
 }
 
+function authorityLostError(reason) {
+  const error = new Error("execution authority lost before OpenCode spawn");
+  error.code = "HILOS_AUTHORITY_LOST";
+  if (reason !== undefined) error.cause = reason;
+  return error;
+}
+
 function basicAuthorization(username, password) {
   return `Basic ${Buffer.from(`${username}:${password}`, "utf8").toString("base64")}`;
 }
@@ -220,7 +227,7 @@ function terminateProcessGroup(child, {
  * @param {any} [options]
  * @returns {Promise<any>}
  */
-export function startOpenCodeServer({
+export async function startOpenCodeServer({
   cmd = "opencode",
   cwd,
   env,
@@ -228,12 +235,21 @@ export function startOpenCodeServer({
   password = randomBytes(24).toString("base64url"),
   username = "opencode",
   signal,
+  beforeSpawn,
   spawnImpl = spawn,
   kill = process.kill,
   setTimer = setTimeout,
   clearTimer = clearTimeout,
   startupTimeoutMs = STARTUP_TIMEOUT_MS,
 } = {}) {
+  if (typeof beforeSpawn === "function") {
+    try {
+      if ((await beforeSpawn()) === false) throw authorityLostError();
+    } catch (error) {
+      if (error?.code === "HILOS_AUTHORITY_LOST") throw error;
+      throw authorityLostError(error);
+    }
+  }
   return new Promise((resolve, reject) => {
     if (signal?.aborted) return reject(abortError(signal.reason));
     let child;
@@ -376,6 +392,7 @@ export async function runOpenCodeHttpSession({
   env,
   timeoutMs = 30 * 60_000,
   signal,
+  beforeSpawn,
   onData,
   requestPermission,
   getPermissionDecision,
@@ -470,6 +487,7 @@ export async function runOpenCodeHttpSession({
       serverArgs: parsed.serverArgs,
       password: randomPassword(),
       signal: controller.signal,
+      beforeSpawn,
       spawnImpl,
       kill,
       setTimer,
@@ -730,13 +748,15 @@ export async function runOpenCodeHttpSession({
       sessionId,
     };
   } catch (error) {
-    const aborted = abortKind === "cancelled";
+    const authorityLost = error?.code === "HILOS_AUTHORITY_LOST";
+    const aborted = abortKind === "cancelled" || authorityLost;
     const timedOut = abortKind === "timeout";
     return {
       status: null,
       stdout: stdout.trimEnd(),
       stderr: stderr.trimEnd(),
       ...(aborted ? { aborted: true } : {}),
+      ...(authorityLost ? { authorityLost: true } : {}),
       ...(sessionId ? { sessionId } : {}),
       error:
         error instanceof Error

package/src/progress-emitter.mjs

@@ -186,7 +186,7 @@ export function imagesNeedReading(vendor, { gated = false } = {}) {
  * @returns {string|null}
  */
 export function attachTarget(codingCmd) {
-  const tokens = String(codingCmd || "").trim().split(/\s+/).filter(Boolean);
+  const tokens = commandArgv(codingCmd);
   for (let i = 0; i < tokens.length; i++) {
     if (tokens[i] === "--attach") return tokens[i + 1] && !tokens[i + 1].startsWith("-") ? tokens[i + 1] : "";
     if (tokens[i].startsWith("--attach=")) return tokens[i].slice("--attach=".length);