@staix/agent-hub 0.21.0 → 0.23.0

package/src/hub/control-client.ts

@@ -9,7 +9,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 = ["conductor_recovery", "encrypted_rooms", "external_adapter_instances", "external_adapter_modules", "configured_acp", "native_hook_launch", "task_cancel", "recovery_deferred_hub", "peer_instances", "role_stages", "task_planners", "release_trains", "reviewer_pool", "native_tui_launch", "terminal_owner", "cli_audit_delegated"] as const;
+export const DAEMON_FEATURES = ["conductor_recovery", "encrypted_rooms", "external_adapter_instances", "external_adapter_modules", "configured_acp", "native_hook_launch", "task_cancel", "invocation", "recovery_deferred_hub", "peer_instances", "role_stages", "task_planners", "release_trains", "reviewer_pool", "native_tui_launch", "terminal_owner", "cli_audit_delegated"] 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;
 
@@ -86,15 +86,25 @@ export function readControl(stateDir: string): ControlDescriptor | undefined {
 
 const instancePins = new Map<string, { instanceId: string }>();
 
+/** Maximum supported 3600 s approval plus admission/transport margin; applies to every hub_invoke client path. */
+export const INVOCATION_CONTROL_TIMEOUT_MS = 3_665_000;
+export function controlRequestTimeout(msg: Record<string, unknown>, requested = 30_000): number {
+  return msg.t === "task" && msg.op === "hub_invoke" && requested !== 0
+    ? Math.max(Number.isFinite(requested) ? requested : 0, INVOCATION_CONTROL_TIMEOUT_MS) : requested;
+}
+
+
 /** One authenticated control connection. `request` correlates replies by `rid`; everything else goes to `onPush`. */
 export class ControlClient {
   features: readonly string[] = [];
   private welcomeInstanceId?: string;
   /** Identity from the authenticated welcome, never the unauthenticated descriptor alone. */
   get instanceId(): string | undefined { return this.welcomeInstanceId; }
-  get isOpen(): boolean { return this.ws.readyState === WebSocket.OPEN; }
+  get isOpen(): boolean { return !this.closing && this.ws.readyState === WebSocket.OPEN; }
   private nextRid = 1;
   private readonly pending = new Map<number, (msg: any) => void>();
+  private readonly invocations = new Set<number>();
+  private closing = false;
   onPush: (msg: any) => void = () => {};
   /** `code`/`reason`: what the hub closed with, e.g. 4000 when another client attached as the same peer. */
   onClose: (code: number, reason: string) => void = () => {};
@@ -179,13 +189,32 @@ export class ControlClient {
   }
 
   /** `timeoutMs`: for calls a person waits on. The hub has its own budget; this one only makes sure the CLI never hangs. */
-  request(msg: Record<string, unknown>, timeoutMs = 30_000): Promise<any> {
-    if (this.ws.readyState !== WebSocket.OPEN) return Promise.resolve({ ok: false, error: "hub connection is not open" });
+  request(msg: Record<string, unknown>, timeoutMs = 30_000, signal?: AbortSignal): Promise<any> {
+    if (this.ws.readyState !== WebSocket.OPEN || this.closing && msg.t !== "request_cancel") return Promise.resolve({ ok: false, error: "hub connection is not open" });
+    const invocation = msg.t === "task" && msg.op === "hub_invoke";
+    timeoutMs = controlRequestTimeout(msg, timeoutMs);
+    if (signal?.aborted) return Promise.resolve({ ok: false, error: "hub request cancelled before sending" });
     const rid = this.nextRid++;
     return new Promise((resolve) => {
-      const timer = timeoutMs ? setTimeout(() => (this.pending.delete(rid), resolve({ ok: false, error: `no answer from the hub within ${Math.round(timeoutMs / 1000)} s` })), timeoutMs) : undefined;
-      this.pending.set(rid, (reply) => (clearTimeout(timer), resolve(reply)));
-      this.ws.send(JSON.stringify({ ...msg, rid }));
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      const done = (reply: any) => {
+        this.pending.delete(rid); this.invocations.delete(rid); clearTimeout(timer); signal?.removeEventListener("abort", aborted); resolve(reply);
+      };
+      const abandon = (error: string) => {
+        if (!this.pending.has(rid)) return;
+        if (invocation && this.ws.readyState === WebSocket.OPEN) {
+          try { this.ws.send(JSON.stringify({ t: "request_cancel", request: rid })); } catch { /* Socket close also withdraws admission. */ }
+        }
+        done({ ok: false, error: invocation ? `${error}; invocation admission unconfirmed, inspect before retrying` : error });
+      };
+      const aborted = () => abandon("hub request cancelled");
+      this.pending.set(rid, done);
+      if (invocation) this.invocations.add(rid);
+      signal?.addEventListener("abort", aborted, { once: true });
+      if (signal?.aborted) { aborted(); return; }
+      timer = timeoutMs ? setTimeout(() => abandon(`no answer from the hub within ${Math.round(timeoutMs / 1000)} s`), timeoutMs) : undefined;
+      try { this.ws.send(JSON.stringify({ ...msg, rid })); }
+      catch { abandon("hub request could not be sent"); }
     });
   }
 
@@ -194,6 +223,10 @@ export class ControlClient {
   }
 
   close(): void {
-    this.ws.close();
+    if (this.closing) return;
+    this.closing = true;
+    if (!this.invocations.size || this.ws.readyState !== WebSocket.OPEN) { this.ws.close(); return; }
+    // Withdraw admissions before reporting a graceful close to callers. An abrupt transport loss is fenced by the daemon close handler.
+    void Promise.allSettled([...this.invocations].map(request => this.request({ t: "request_cancel", request }, 3000))).finally(() => this.ws.close());
   }
 }