@saadnvd1/agent-os 0.3.779 → 0.3.780

package/lib/chat/registry.ts

@@ -45,6 +45,8 @@ export interface Live {
   canBackground?: boolean;
   // Whether it takes "mcp_auth" (sign in to an MCP server).
   canMcpAuth?: boolean;
+  // Whether it holds a live guest's turns to the host's taps (Drive).
+  canGuestGate?: boolean;
   // From an older build and idle: retired once its guess at the next
   // message is in, or this fires.
   retiring?: NodeJS.Timeout;

package/lib/chat/runner.ts

@@ -21,6 +21,7 @@ import type {
   ApprovalDecision,
   ChatFile,
   ChatImage,
+  ChatOrigin,
   ChatServerMessage,
   ChatState,
   Compacting,
@@ -47,6 +48,7 @@ import {
 import { noteToolResult } from "../health/env/recordHit";
 import {
   deleteQueued,
+  deleteQueuedWhere,
   editQueued,
   enqueue,
   listQueue,
@@ -78,7 +80,7 @@ import {
   waitForExit,
 } from "./worker/client";
 import { buildId, isStaleWorker } from "../build";
-import type { WorkerEvent } from "./worker/protocol";
+import { GUEST_GATE_CAP, type WorkerEvent } from "./worker/protocol";
 import type { WorkerClient } from "./worker/client";
 import { DEMO_REFUSAL, demoMode } from "../security/demo";
 import { chatHold, chatRefusal } from "./hold";
@@ -118,6 +120,7 @@ export async function carryOutPlan(
       id: `user-carry-${planId}`,
       text: CARRY_OUT,
       origin: { kind: "decision", label: "Saad" },
+      host: true,
     },
     timeoutMs
   );
@@ -348,6 +351,7 @@ async function ensureLive(sessionId: string, spawn = true): Promise<Live> {
       canFresh: !!hello.caps?.includes("fresh"),
       canBackground: !!hello.caps?.includes("background"),
       canMcpAuth: !!hello.caps?.includes("mcp_auth"),
+      canGuestGate: !!hello.caps?.includes(GUEST_GATE_CAP),
     };
     // From an older build and busy, or running background work: it goes at
     // its next turn boundary, by itself if it can. Messages meanwhile wait
@@ -402,10 +406,11 @@ function queuedIfHeld(
   return true;
 }
 
-const sentBy = ({ from, peer, origin }: SentBy): SentBy => ({
+const sentBy = ({ from, peer, origin, host }: SentBy): SentBy => ({
   from,
   peer,
   origin,
+  host,
 });
 
 // Already a message in the chat or its queue.
@@ -460,6 +465,64 @@ export async function sendChat(
   });
 }
 
+export const GATE_MISSING = "Reopen this chat on the host to let guests drive";
+
+/**
+ * A live guest's Drive prompt (lib/live/drive): always its own turn, behind
+ * anything running. `check` runs again right before the worker gets it, in
+ * the same tick, so a Drive that ended meanwhile sends nothing. Returns why
+ * it wasn't sent, or null.
+ */
+export async function sendGuestPrompt(
+  sessionId: string,
+  m: { id: string; text: string; origin: ChatOrigin },
+  check: () => string | null
+): Promise<string | null> {
+  const held = () =>
+    chatRefusal(sessionId) ??
+    chatHold(sessionId) ??
+    (settingUp(sessionId) || launchPending(sessionId)
+      ? "The task isn't running yet"
+      : null);
+  if (held()) return held();
+  const live = await ensureLive(sessionId);
+  if (!live.canGuestGate) return GATE_MISSING;
+  const why = held() ?? check();
+  if (why) return why;
+  if (taken(sessionId, m.id)) return "Already sent";
+  live.worker.command({ type: "send", ...m, queue: true });
+  return null;
+}
+
+// A live share's Drive ended: its queued prompts go here and in the worker
+// (which also stops a turn it steers and refuses that wheel from now on).
+export function releaseGuestChat(
+  sessionId: string,
+  share: string,
+  wheel: string
+): void {
+  const gone = deleteQueuedWhere(
+    sessionId,
+    (by) => by.origin?.kind === "guest-drive" && by.origin.share === share
+  );
+  if (gone.length) emitQueue(sessionId);
+  registry.live
+    .get(sessionId)
+    ?.worker.command({ type: "guest_release", share, wheel });
+}
+
+// The driving guest's Stop: the worker ends the turn only if their wheel
+// steers it.
+export function stopGuestTurn(
+  sessionId: string,
+  share: string,
+  wheel: string
+): void {
+  registry.live
+    .get(sessionId)
+    ?.worker.command({ type: "guest_stop", share, wheel });
+}
+
 // The queue lives in SQLite, so it can be changed with no worker running;
 // a worker reads it only when it sends the next message.
 export function editQueuedChat(sessionId: string, id: string, text: string) {

package/lib/chat/socket.ts

@@ -150,15 +150,18 @@ function onChatMessage(
     const id = send.id;
     // Taken in now: a new worker can take seconds to start.
     if (id) reply({ type: "accepted", id });
-    void sendChat(sessionId, { ...send, queue: true }).catch((err) => {
-      if (id)
-        reply({
-          type: "send_failed",
-          id,
-          message: err instanceof Error ? err.message : String(err),
-        });
-      fail(err);
-    });
+    // Typed in the host's own composer (this socket is theirs).
+    void sendChat(sessionId, { ...send, queue: true, host: true }).catch(
+      (err) => {
+        if (id)
+          reply({
+            type: "send_failed",
+            id,
+            message: err instanceof Error ? err.message : String(err),
+          });
+        fail(err);
+      }
+    );
     // "Session 4" is named after its first message.
     run(titleChatFromMessage(sessionId, send.text));
   } else if (msg.type === "queue_edit" && typeof msg.text === "string")

package/lib/chat/worker/gate-testing.ts

@@ -0,0 +1,131 @@
+/**
+ * For tests: a real chat worker (ChatHost) over a fake agent, with the guest
+ * gate's PreToolUse hook driven as the SDK would and real approval cards.
+ * A test file mocks the drivers with this module's `drivers`:
+ *   vi.mock("@/lib/chat/drivers", async () => (await import("@/lib/chat/worker/gate-testing")).drivers)
+ */
+
+import { randomUUID } from "crypto";
+import { vi } from "vitest";
+import type { HookJSONOutput } from "@anthropic-ai/claude-agent-sdk";
+import type { Session } from "@/lib/db";
+import type { ChatConversation, ChatStartOptions } from "../driver";
+import type { ChatItem, DriverEvent } from "../events";
+import { InputQueue } from "../queue";
+import { Approvals, preToolUseHooks } from "../drivers/claude-approvals";
+import type { WorkerEvent } from "./protocol";
+
+export function fakeConversation() {
+  const events = new InputQueue<DriverEvent>();
+  return {
+    send: vi.fn(() => "checkpoint-1"),
+    runLocal: vi.fn(() => null),
+    interrupt: vi.fn(async () => {}),
+    setModel: vi.fn(async () => {}),
+    setAccess: vi.fn(async () => {}),
+    setPlan: vi.fn(async () => {}),
+    respond: vi.fn(),
+    stopTask: vi.fn(async () => {}),
+    backgroundTask: vi.fn(async () => true),
+    undo: vi.fn(),
+    close: vi.fn(() => events.end()),
+    events,
+  } satisfies ChatConversation;
+}
+
+const fake: {
+  current?: ReturnType<typeof fakeConversation>;
+  started?: ChatStartOptions;
+} = {};
+
+export const drivers = {
+  chatDriverFor: () => ({
+    id: "fake",
+    atRest: true,
+    start: (options: ChatStartOptions) => {
+      fake.started = options;
+      return fake.current!;
+    },
+  }),
+};
+
+export const tick = () => new Promise((r) => setTimeout(r, 0));
+
+// The host is imported late: it imports the drivers, which this module mocks.
+export async function gatedHost(
+  session: Session,
+  cwd: string,
+  onEvent: (e: WorkerEvent) => void = () => {}
+) {
+  const { ChatHost } = await import("./host");
+  fake.current = fakeConversation();
+  const conversation = fake.current;
+  const emitted: ChatItem[] = [];
+  const host = new ChatHost(session, (e) => {
+    if (e.type === "item") emitted.push(e.item);
+    onEvent(e);
+  });
+  const approvals = new Approvals((e) => conversation.events.push(e));
+  conversation.respond.mockImplementation((cardId, answer) =>
+    approvals.respond(cardId, answer)
+  );
+  const gate = fake.started!.guestGate!;
+  const [first] = preToolUseHooks(approvals, undefined, null, { gate, cwd });
+  const hook = first.hooks[0];
+  const results = new Map<string, HookJSONOutput>();
+  const call = (tool: string, input: Record<string, unknown>) => {
+    const useId = `tu-${randomUUID().slice(0, 8)}`;
+    const ac = new AbortController();
+    void hook(
+      {
+        hook_event_name: "PreToolUse",
+        tool_name: tool,
+        tool_input: input,
+        tool_use_id: useId,
+        session_id: "x",
+        transcript_path: "",
+        cwd,
+      } as never,
+      useId,
+      { signal: ac.signal }
+    ).then((r) => results.set(useId, r));
+    return { useId, abort: () => ac.abort() };
+  };
+  /** allow, deny, none (no decision), or pending (still waiting on the host). */
+  const decision = async (useId: string) => {
+    try {
+      await gate.placedFiles(cwd);
+    } catch {
+      // A test that makes it throw.
+    }
+    await tick();
+    await tick();
+    const r = results.get(useId) as
+      { hookSpecificOutput?: { permissionDecision?: string } } | undefined;
+    return (
+      r?.hookSpecificOutput?.permissionDecision ?? (r ? "none" : "pending")
+    );
+  };
+  const card = (useId: string) =>
+    emitted
+      .filter(
+        (i): i is Extract<ChatItem, { kind: "approval" }> =>
+          i.kind === "approval" && i.id === `approval-${useId}`
+      )
+      .at(-1);
+  const idle = async () => {
+    conversation.events.push({ type: "state", state: "idle" });
+    await tick();
+  };
+  return {
+    host,
+    gate,
+    approvals,
+    conversation,
+    call,
+    decision,
+    card,
+    idle,
+    emitted,
+  };
+}