@staix/agent-hub 0.12.31 → 0.12.33

package/src/hub/config-reload.ts

@@ -0,0 +1,120 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { validateRawConfig, type ConfigLayer } from "./config-apply.ts";
+import { parseOverlay, parseRouting, type Routing } from "./routing.ts";
+import { CLASSES } from "./board.ts";
+
+export const CONFIG_SOURCE_FILES = ["config.json", "config.local.json", "routing.toml", "routing.local.toml"] as const;
+export type ConfigSourceName = typeof CONFIG_SOURCE_FILES[number];
+export type ConfigSourceTexts = Record<ConfigSourceName, string | null>;
+export interface ConfigSources {
+  texts: ConfigSourceTexts;
+  layers: ConfigLayer[];
+  trustLayers: { name: ConfigSourceName; raw: Record<string, unknown> }[];
+  routing: Routing;
+  fingerprint: string;
+}
+const MAX_CONFIG_BYTES = 1024 * 1024;
+
+/** Capture once; a missing file is distinct from a read failure. Errors never quote file contents. */
+export function configSourceTexts(cwd: string): ConfigSourceTexts {
+  return Object.fromEntries(CONFIG_SOURCE_FILES.map(name => {
+    try {
+      const text = readFileSync(join(cwd, ".agenthub", name), "utf8");
+      if (Buffer.byteLength(text) > MAX_CONFIG_BYTES) throw new Error("oversized");
+      return [name, text];
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") return [name, null];
+      throw new Error(`.agenthub/${name}: configuration unavailable or oversized`);
+    }
+  })) as ConfigSourceTexts;
+}
+
+export const configFingerprint = (texts: ConfigSourceTexts): string => createHash("sha256").update(JSON.stringify(texts)).digest("hex");
+
+/** Validate only the hub-owned routing schema; Switchyard target/route fields remain extensible. */
+function validateRoutingRaw(value: unknown): void {
+  const bad = (key: string): never => { throw new Error(`.agenthub/routing.toml: ${key} is invalid or unknown`); };
+  const table = (v: unknown, key: string): Record<string, unknown> => {
+    if (!v || typeof v !== "object" || Array.isArray(v) || Object.keys(v).length > 256) return bad(key);
+    if (Object.keys(v).some(name => ["__proto__", "constructor", "prototype"].includes(name))) return bad(key);
+    return v as Record<string, unknown>;
+  };
+  const text = (v: unknown, key: string) => { if (typeof v !== "string" || !v || v.length > 4096 || /[\x00-\x1f\x7f]/.test(v)) bad(key); };
+  const numeric = (v: unknown, key: string, min = 1, max = Number.MAX_SAFE_INTEGER) => { if (typeof v !== "number" || !Number.isSafeInteger(v) || v < min || v > max) bad(key); };
+  const choice = (v: unknown, key: string, choices: readonly string[]) => { if (typeof v !== "string" || !choices.includes(v)) bad(key); };
+  const closed = (v: unknown, key: string, fields: Record<string, (v: unknown, key: string) => void>) => {
+    for (const [name, item] of Object.entries(table(v, key))) { if (!Object.hasOwn(fields, name)) bad(`${key}.${name}`); fields[name]!(item, `${key}.${name}`); }
+  };
+  const peers = (v: unknown, key: string) => {
+    if (!Array.isArray(v) || v.length > 128 || new Set(v).size !== v.length || v.some(peer => typeof peer !== "string" || !/^[a-z][a-z0-9-]{0,31}$/.test(peer))) bad(key);
+  };
+  const strings = (v: unknown, key: string) => { if (!Array.isArray(v) || v.length > 256 || v.some(x => typeof x !== "string" || x.length > 4096)) bad(key); };
+  const bool = (v: unknown, key: string) => { if (typeof v !== "boolean") bad(key); };
+  const openValue = (v: unknown, key: string, depth = 0): void => {
+    if (depth > 16) bad(key);
+    if (typeof v === "string") { if (v.length > 16_384) bad(key); }
+    else if (typeof v === "number") { if (!Number.isFinite(v)) bad(key); }
+    else if (typeof v === "boolean" || v === null) return;
+    else if (Array.isArray(v)) { if (v.length > 1024) bad(key); for (const item of v) openValue(item, key, depth + 1); }
+    else for (const item of Object.values(table(v, key))) openValue(item, key, depth + 1);
+  };
+  const switchyard = (v: unknown, key: string, required: "id" | "type") => {
+    for (const [name, item] of Object.entries(table(v, key))) {
+      if (!name || name.length > 128 || ["__proto__", "constructor", "prototype"].includes(name)) bad(key);
+      const entry = table(item, `${key}.${name}`); text(entry[required], `${key}.${name}.${required}`); openValue(entry, `${key}.${name}`);
+    }
+  };
+  closed(value, "routing", {
+    local: (v, k) => closed(v, k, { route: text, fixed_model: text }),
+    targets: (v, k) => switchyard(v, k, "id"), routes: (v, k) => switchyard(v, k, "type"),
+    // parseRouting delegates these tables to the existing parseHubRoutes validator.
+    hub_routes: (v, k) => { table(v, k); },
+    stay_switch: (v, k) => choice(v, k, ["off", "shadow", "enforce"]), max_switch_prefill_tokens: numeric,
+    signals: (v, k) => closed(v, k, { pii_patterns: strings, long_context_tokens: numeric, pii_screen: (x, p) => choice(x, p, ["off", "local"]) }),
+    constraints: (v, k) => closed(v, k, { pii: (x, p) => choice(x, p, ["local_only", "off"]), long_context: (x, p) => choice(x, p, ["skip_local", "off"]), budget_paused: (x, p) => choice(x, p, ["skip_peer", "off"]) }),
+    pi: (v, k) => closed(v, k, { dgx_max_context_tokens: numeric, mlx_max_context_tokens: numeric, efficient_wait_ms: (x, p) => numeric(x, p, 0, 119999) }),
+    classes: (v, k) => { for (const [name, item] of Object.entries(table(v, k))) {
+      if (!(CLASSES as readonly string[]).includes(name)) bad(`${k}.${name}`);
+      closed(item, `${k}.${name}`, { peers, escalate_to: peers, route: text, fixed_model: text, local_allowed: bool, pi_backend: (x, p) => choice(x, p, ["dgx", "mlx"]) });
+    } },
+  });
+}
+
+/** Strict reloads never use routing's last-good fallback. Startup can retain its existing fallback explicitly. */
+export function parseConfigSources(texts: ConfigSourceTexts, fallbackRouting?: Routing): ConfigSources {
+  const layers: ConfigLayer[] = [], trustLayers: ConfigSources["trustLayers"] = [];
+  for (const name of CONFIG_SOURCE_FILES) {
+    const text = texts[name];
+    if (text === null) continue;
+    let raw: Record<string, unknown>;
+    try {
+      const value: unknown = name.endsWith(".json") ? JSON.parse(text) : Bun.TOML.parse(text);
+      if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error();
+      raw = value as Record<string, unknown>;
+    } catch {
+      if (!fallbackRouting) throw new Error(`.agenthub/${name}: invalid ${name.endsWith(".json") ? "JSON object" : "TOML"}`);
+      continue;
+    }
+    if (name === "config.json" || name === "config.local.json") {
+      if (!fallbackRouting) {
+        try { validateRawConfig(raw); }
+        catch (error) { throw new Error(`.agenthub/${name}: ${(error as Error).message}`); }
+      }
+      layers.push({ name, raw });
+    }
+    trustLayers.push({ name, raw });
+  }
+  let routing = fallbackRouting;
+  if (!routing) {
+    const base = texts["routing.toml"] ?? readFileSync(new URL("../../templates/routing.toml", import.meta.url), "utf8");
+    validateRoutingRaw(Bun.TOML.parse(base));
+    let overlay;
+    try { overlay = texts["routing.local.toml"] === null ? undefined : parseOverlay(texts["routing.local.toml"]); }
+    catch { throw new Error(".agenthub/routing.local.toml: invalid routing overlay"); }
+    try { routing = parseRouting(base, overlay); }
+    catch { throw new Error(".agenthub/routing.toml / routing.local.toml: invalid effective routing"); }
+  }
+  return { texts, layers, trustLayers, routing, fingerprint: configFingerprint(texts) };
+}

package/src/hub/config-trust.ts

@@ -1,5 +1,5 @@
-import { statSync } from "node:fs";
-import { join } from "node:path";
+import { lstatSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { childEnv } from "./child-process.ts";
 import { hubGitSync } from "./git.ts";
 
@@ -31,6 +31,15 @@ export const MACHINE_LOCAL = [
 /** Legacy exported field list stays compatible; new policies use the complete list below. */
 export const ALL_MACHINE_LOCAL = [...MACHINE_LOCAL, "protect_instruction_files", "qwen_cmd", "jcode_cmd", "jcode_home", "jcode_provider_profile", "text_projection"] as const;
 
+/** A known repository, including an unreadable marker, must never be mistaken for a plain directory. */
+export function configRepositoryPresent(cwd: string): boolean {
+  for (let at = cwd; ; at = dirname(at)) {
+    try { lstatSync(join(at, ".git")); return true; }
+    catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") return true; }
+    if (dirname(at) === at) return false;
+  }
+}
+
 /**
  * Why `.agenthub/<name>` must not set machine-local fields, or undefined when git confirms nobody committed it.
  * Unknown is not untracked: no repository, no git, or a git error all refuse. The directory itself counts too (a

package/src/hub/control-client.ts

@@ -8,7 +8,7 @@ export function stateDirFor(cwd: string): string {
 
 /** Control WS wire version. 2 = `deliver` carries `envs` (digests); 3 = `tools` role and task messages; 4 = budget messages and `hub_checkpoint`; 5 = `ask`; 6 = console-only `ui` session bootstrap; 8 = controlled recovery; 9 = Pi bridge metadata; 10 = durable delivery receipts; 11 = queue hold diagnostics; 12 = generation-bound channel settlement and execution budgets; 13 = turn-free facts (`facts` with tool, session and transcript binding, `silenced`) and per-recipient send results (issue #108). 14 = native context-window status and session-bound context checkpoint request ids (issue #185). 15 = conductor tools and permission deadlines/closed events (issues #190, #194). 16 = a Claude session without channel evidence: hello `channel: false` and `inbox` (issue #205). The plugin is installed apart from the daemon, so they can drift. */
 export const PROTOCOL = 16;
-export const DAEMON_FEATURES = ["task_cancel"] as const;
+export const DAEMON_FEATURES = ["task_cancel", "recovery_deferred_hub"] as const;
 /** Protocols a current coordinator may authenticate while upgrading a running source. */
 export const RECOVERY_SOURCE_PROTOCOLS = [9, 10, 11, 12, 13, 14, 15, PROTOCOL] as const;
 

package/src/hub/crash.ts

@@ -1,3 +1,4 @@
+import { definitionOf } from "../adapters/registry.ts";
 import { chmodSync, existsSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { JournalDelivery } from "./delivery-journal.ts";
@@ -47,7 +48,7 @@ export function removeSessions(stateDir: string, instanceId?: string): void {
   if (instanceId === undefined || readSessions(stateDir)?.instanceId === instanceId) rmSync(fileOf(stateDir), { force: true });
 }
 
-export const qwenSessionId = (value: unknown): value is string => typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/.test(value);
+export { qwenSessionId } from "../adapters/definitions/qwen-native.ts";
 
 const str = (v: unknown) => (typeof v === "string" && v ? v : undefined);
 
@@ -59,6 +60,12 @@ export function crashPlan(records: SessionRecord[]): { peer: string; resume?: Re
   return records.map(({ peer, meta }) => {
     const launch = (meta.launch && typeof meta.launch === "object" ? meta.launch : {}) as Record<string, unknown>;
     const model = str(launch.model);
+    const adapter = definitionOf(peer);
+    if (adapter?.transport === "acp" && adapter.start.create) {
+      const sessionId = adapter.session.crashIdentity?.(meta).sessionId;
+      if (!sessionId) return { peer, how: `${peer}: saved ACP session identity unavailable; start it deliberately with ahub ${peer}` };
+      return { peer, resume: { sessionId, ...(model ? { model } : {}) }, how: `${peer}: the recorded conversation can be loaded again (ACP session/load)` };
+    }
     switch (peer) {
       case "claude":
         return { peer, how: "claude: the Claude Code plugin reconnects by itself while that session is still open" };
@@ -66,11 +73,6 @@ export function crashPlan(records: SessionRecord[]): { peer: string; resume?: Re
         return { peer, how: `codex: its app-server died with the hub; run ahub codex again${str(meta.threadId) ? ` (its conversation was thread ${meta.threadId})` : ""}` };
       case "jcode":
         return { peer, how: "jcode: native 0.94.0 load does not prove the restored id; reopen the original conversation with its native client, no automatic fresh replacement" };
-      case "qwen": {
-        const sessionId = meta.sessionId;
-        if (!qwenSessionId(sessionId)) return { peer, how: "qwen: saved ACP session identity unavailable; start it deliberately with ahub qwen" };
-        return { peer, resume: { sessionId, ...(model ? { model } : {}) }, how: "qwen: the recorded conversation can be loaded again (ACP session/load)" };
-      }
       case "kimi": {
         const sessionId = str(meta.sessionId);
         if (!sessionId) return { peer, how: "kimi: no session id was recorded; start it again with ahub kimi" };