@saadnvd1/agent-os 0.3.591 → 0.3.594

package/components/SessionList/SessionRowMenu.tsx

@@ -34,7 +34,11 @@ import { schedulesUiActions } from "@/stores/schedulesUi";
 import { recipesUiActions } from "@/stores/recipesUi";
 import { rowGroup } from "@/lib/recipes/chip";
 import { finishActions } from "@/lib/sidebar/row-actions";
-import { useArchiveAction, useDoneAction } from "./useDoneAction";
+import {
+  useArchiveAction,
+  useDoneAction,
+  useResurrectAction,
+} from "./useDoneAction";
 import { useShelfActions } from "./useShelfActions";
 import {
   PAUSE_PRESETS,
@@ -106,6 +110,7 @@ function FinishItems({
 }) {
   const markDone = useDoneAction();
   const archive = useArchiveAction();
+  const restore = useResurrectAction();
   const actions = finishActions(session, plain);
   return (
     <>
@@ -115,6 +120,12 @@ function FinishItems({
           Done
         </Item>
       )}
+      {actions.includes("restore") && (
+        <Item onClick={() => restore(session)}>
+          <RotateCcw className={icon} />
+          Restore
+        </Item>
+      )}
       {actions.includes("archive") && (
         <Item onClick={() => archive(session)}>
           <Archive className={icon} />

package/components/SessionList/useDoneAction.ts

@@ -3,6 +3,7 @@ import type { Session } from "@/lib/db";
 import {
   useArchiveSession,
   useDoneSession,
+  useResurrectSession,
   useUnarchiveSession,
 } from "@/data/done";
 import { useSettleSession } from "@/data/sessions/shelf";
@@ -68,3 +69,16 @@ export function useArchiveAction() {
       onError: (e) => toast.error(e.message, { duration: 12000 }),
     });
 }
+
+// Restore from a session's menu: the same conversation, its worktree back.
+export function useResurrectAction() {
+  const resurrect = useResurrectSession();
+  return (session: Session) => {
+    const id = toast.loading(`Restoring ${session.name}…`);
+    resurrect.mutate(session.id, {
+      onSuccess: (outcome) =>
+        toast.success(outcome.text, { id, duration: 8000 }),
+      onError: (e) => toast.error(e.message, { id, duration: 12000 }),
+    });
+  };
+}

package/components/SessionList/useResurrectAction.test.ts

@@ -0,0 +1,96 @@
+import "@/components/Chat/composer/test-dom";
+import { act, createElement, useEffect } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { Session } from "@/lib/db/types";
+
+const toast = vi.hoisted(() =>
+  Object.assign(vi.fn(), {
+    loading: vi.fn(() => "t1"),
+    success: vi.fn(),
+    error: vi.fn(),
+  })
+);
+vi.mock("sonner", () => ({ toast }));
+
+const { useResurrectAction } = await import("./useDoneAction");
+
+(
+  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+let root: Root;
+let host: HTMLElement;
+const hook: { current: (s: Session) => void } = { current: () => {} };
+const fetchSpy = vi.fn();
+
+function Probe() {
+  const restore = useResurrectAction();
+  useEffect(() => {
+    hook.current = restore;
+  });
+  return null;
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.stubGlobal("fetch", fetchSpy);
+  host = document.createElement("div");
+  document.body.append(host);
+  root = createRoot(host);
+  act(() =>
+    root.render(
+      createElement(
+        QueryClientProvider,
+        { client: new QueryClient() },
+        createElement(Probe)
+      )
+    )
+  );
+});
+afterEach(() => {
+  act(() => root.unmount());
+  host.remove();
+  vi.unstubAllGlobals();
+});
+
+const task = {
+  id: "s1",
+  name: "Bookmark plan",
+  task_status: "done",
+} as Session;
+const respond = (status: number, body: object) =>
+  fetchSpy.mockResolvedValue({
+    ok: status < 400,
+    status,
+    json: async () => body,
+  });
+const restore = async () => {
+  await act(async () => {
+    hook.current(task);
+    await new Promise((r) => setTimeout(r, 0));
+  });
+};
+
+describe("Restore from a session's menu", () => {
+  it("posts to the resurrect route and shows what came back", async () => {
+    respond(200, { outcome: { text: "Bookmark plan is back" } });
+    await restore();
+    expect(fetchSpy.mock.calls[0][0]).toBe("/api/sessions/s1/resurrect");
+    expect(fetchSpy.mock.calls[0][1]).toMatchObject({ method: "POST" });
+    expect(toast.success).toHaveBeenCalledWith(
+      "Bookmark plan is back",
+      expect.objectContaining({ id: "t1" })
+    );
+  });
+
+  it("shows a refusal's reason", async () => {
+    respond(409, { error: "its PR #3 was merged" });
+    await restore();
+    expect(toast.error).toHaveBeenCalledWith(
+      "its PR #3 was merged",
+      expect.objectContaining({ id: "t1" })
+    );
+  });
+});

package/components/Tasks/TaskRow.tsx

@@ -5,6 +5,7 @@ import {
   ChefHat,
   ExternalLink,
   GitMerge,
+  RotateCcw,
   KanbanSquare,
   SquareTerminal,
 } from "lucide-react";
@@ -12,6 +13,7 @@ import { Button } from "@/components/ui/button";
 import type { TaskView } from "@/lib/tasks";
 import { isFinished } from "@/lib/tasks/state";
 import { useArmTask, useDropTask, useSignOffTask } from "@/data/tasks";
+import { useResurrectSession } from "@/data/done";
 import { tmuxAttachActions } from "@/stores/tmuxAttach";
 import { tasksUiActions } from "@/stores/tasksUi";
 import { recipesUiActions } from "@/stores/recipesUi";
@@ -27,6 +29,7 @@ export function TaskRow({ task }: { task: TaskView }) {
   const signOff = useSignOffTask();
   const drop = useDropTask();
   const arm = useArmTask();
+  const restore = useResurrectSession();
   const [confirmDrop, setConfirmDrop] = useState(false);
   const [moveError, setMoveError] = useState<string | null>(null);
   const live = !isFinished(task.state);
@@ -34,6 +37,7 @@ export function TaskRow({ task }: { task: TaskView }) {
     signOff.error?.message ||
     drop.error?.message ||
     arm.error?.message ||
+    restore.error?.message ||
     moveError ||
     task.hostError;
   const settingUp = live && task.setup?.status === "running";
@@ -165,6 +169,20 @@ export function TaskRow({ task }: { task: TaskView }) {
         </div>
       )}
       {live && task.state === "plan-ready" && <PlanReview task={task} />}
+      {!live && task.state !== "merged" && (
+        <div>
+          <Button
+            size="sm"
+            variant="outline"
+            className="h-11 md:h-8"
+            disabled={restore.isPending}
+            onClick={() => restore.mutate(task.id)}
+          >
+            <RotateCcw className="h-3.5 w-3.5" />
+            {restore.isPending ? "Restoring..." : "Restore"}
+          </Button>
+        </div>
+      )}
       {!live && !task.hostId && (
         <div>
           <Button

package/data/chat/useChat.ts

@@ -23,6 +23,26 @@ import type {
 import type { SearchResult } from "@/lib/chat/find";
 import { addBody, touchBody } from "@/lib/chat/bodyCache";
 import { backgroundFailure, type TaskOutput } from "@/lib/chat/background";
+import {
+  NOT_SENT,
+  clientId,
+  overSends,
+  toResend,
+  type PendingSend,
+} from "@/lib/chat/pending";
+import { usePending } from "./usePending";
+
+// A pending send as the socket's `send`, under its own id.
+const sendFrame = (
+  p: Pick<PendingSend, "id" | "text" | "images" | "compact">
+) =>
+  JSON.stringify({
+    type: "send",
+    text: p.text,
+    images: p.images,
+    clientId: p.id,
+    ...(p.compact && { compact: true }),
+  });
 
 // The index of the item with `id`, searched from the end: what changes is
 // almost always the latest.
@@ -180,6 +200,12 @@ export function useChat(
     onUndoneRef.current = onUndone;
   });
   const wsRef = useRef<WebSocket | null>(null);
+  const {
+    pending,
+    pendingRef,
+    dispatch: pend,
+    restore: restorePending,
+  } = usePending(sessionId, connected);
 
   useEffect(() => {
     let closed = false;
@@ -214,7 +240,18 @@ export function useChat(
         `${protocol}//${window.location.host}/ws/chat?session=${encodeURIComponent(sessionId)}&paged=1`
       );
       wsRef.current = ws;
-      ws.onopen = () => setConnected(true);
+      ws.onopen = () => {
+        setConnected(true);
+        restorePending();
+        // Sends the last socket took and may have lost: the server drops
+        // any it already has.
+        for (const p of overSends(pendingRef.current))
+          pend({ type: "failed", id: p.id, error: NOT_SENT });
+        for (const p of toResend(pendingRef.current)) {
+          ws.send(sendFrame(p));
+          pend({ type: "resent", id: p.id, now: Date.now() });
+        }
+      };
       ws.onmessage = (event) => {
         const m = JSON.parse(event.data) as ChatServerMessage;
         if (m.type === "snapshot") {
@@ -235,8 +272,17 @@ export function useChat(
           setQueue(m.queue ?? []);
           setSuggestion(m.suggestion ?? null);
           setLoadedFor(sessionId);
+          pend({
+            type: "resolved",
+            ids: [...m.items, ...(m.queue ?? [])].map((i) => i.id),
+          });
         } else if (m.type === "queue") {
           setQueue(m.queue);
+          pend({ type: "resolved", ids: m.queue.map((q) => q.id) });
+        } else if (m.type === "accepted") {
+          pend({ type: "accepted", id: m.id, now: Date.now() });
+        } else if (m.type === "send_failed") {
+          pend({ type: "failed", id: m.id, error: m.message });
         } else if (m.type === "suggestion") {
           setSuggestion(m.text);
         } else if (m.type === "files") {
@@ -303,6 +349,8 @@ export function useChat(
             addBody(prev, m.id, m.body, visibleBodies.current)
           );
         } else if (m.type === "item") {
+          if (m.item.kind === "user")
+            pend({ type: "resolved", ids: [m.item.id] });
           withDeltas(() => {
             const routed = routeItem(
               itemsRef.current,
@@ -346,25 +394,44 @@ export function useChat(
       document.removeEventListener("visibilitychange", onVisible);
       wsRef.current?.close();
     };
-  }, [sessionId, setItems, setEarlierTasks]);
+  }, [sessionId, setItems, setEarlierTasks, pend, pendingRef, restorePending]);
 
   const queryClient = useQueryClient();
   const send = useCallback(
     // `compact`: the reader let a stale chat compact first (lib/chat/stale).
+    // It shows as a pending bubble at once, until it's in the chat.
     (text: string, images?: ChatImage[], compact?: boolean) => {
+      const p = { id: clientId(), text, images, compact };
+      pend({ type: "add", send: p, now: Date.now() });
       const ws = wsRef.current;
-      if (!ws) return;
-      ws.send(
-        JSON.stringify({
-          type: "send",
-          text,
-          images,
-          ...(compact && { compact: true }),
-        })
-      );
-      if (ws.readyState === WebSocket.OPEN) markRunning(queryClient, sessionId);
+      if (ws?.readyState !== WebSocket.OPEN) {
+        pend({ type: "failed", id: p.id, error: NOT_SENT });
+        return;
+      }
+      ws.send(sendFrame(p));
+      markRunning(queryClient, sessionId);
     },
-    [queryClient, sessionId]
+    [queryClient, sessionId, pend]
+  );
+
+  const retrySend = useCallback(
+    (id: string) => {
+      const p = pendingRef.current.find((s) => s.id === id);
+      const ws = wsRef.current;
+      if (!p) return;
+      if (ws?.readyState !== WebSocket.OPEN) {
+        pend({ type: "failed", id, error: NOT_SENT });
+        return;
+      }
+      ws.send(sendFrame(p));
+      pend({ type: "resent", id, now: Date.now() });
+    },
+    [pend, pendingRef]
+  );
+
+  const dropSend = useCallback(
+    (id: string) => pend({ type: "drop", id }),
+    [pend]
   );
 
   const interrupt = useCallback(() => {
@@ -549,6 +616,9 @@ export function useChat(
     loadTaskOutput,
     taskOutputs,
     queue,
+    pending,
+    retrySend,
+    dropSend,
     queueEdit,
     queueMove,
     queueDelete,

package/data/chat/usePending.ts

@@ -0,0 +1,70 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import {
+  loadPending,
+  pendingReducer,
+  savePending,
+  type PendingAction,
+  type PendingSend,
+} from "@/lib/chat/pending";
+
+const NONE: PendingSend[] = [];
+
+// The composer's sends not yet in the chat (lib/chat/pending), kept in this
+// browser per session. `dispatch` and `restore` are stable and read no
+// render's state, so the socket's handlers can call them.
+export function usePending(sessionId: string, connected: boolean) {
+  const [state, setState] = useState({ session: sessionId, list: NONE });
+  // Another session's sends never show here, even for the render before
+  // its own are restored.
+  const pending = state.session === sessionId ? state.list : NONE;
+  const ref = useRef<PendingSend[]>(NONE);
+  const session = useRef(sessionId);
+  const restored = useRef<string | null>(null);
+  useEffect(() => {
+    session.current = sessionId;
+    ref.current = NONE;
+  }, [sessionId]);
+
+  const replace = useCallback((list: PendingSend[]) => {
+    ref.current = list;
+    setState({ session: session.current, list });
+  }, []);
+  const dispatch = useCallback(
+    (action: PendingAction) => {
+      const next = pendingReducer(ref.current, action);
+      if (next === ref.current) return;
+      replace(next);
+      savePending(session.current, next);
+    },
+    [replace]
+  );
+  // Once per session, as its socket first opens: what an earlier page left
+  // mid-send, to be sent again.
+  const restore = useCallback(() => {
+    if (restored.current === session.current) return;
+    restored.current = session.current;
+    const now = Date.now();
+    replace(
+      loadPending(session.current).map((p) =>
+        p.status === "failed"
+          ? p
+          : { ...p, status: "sending" as const, at: now }
+      )
+    );
+  }, [replace]);
+
+  // Timeouts only count while connected: a reconnect sends them again.
+  const live = connected && pending.some((p) => p.status !== "failed");
+  useEffect(() => {
+    if (!live) return;
+    const timer = setInterval(
+      () => dispatch({ type: "tick", now: Date.now() }),
+      1000
+    );
+    return () => clearInterval(timer);
+  }, [live, dispatch]);
+
+  return { pending, pendingRef: ref, dispatch, restore };
+}

package/data/done/index.ts

@@ -2,6 +2,7 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import type { DoneOutcome } from "@/lib/done";
 import type { BulkResult, PreviewRow } from "@/lib/done/bulk";
 import type { ArchivedView } from "@/lib/done/archive";
+import type { ResurrectOutcome } from "@/lib/resurrect";
 import { sessionKeys } from "../sessions/keys";
 import { taskKeys } from "../tasks";
 
@@ -90,6 +91,22 @@ export function useUnarchiveSession() {
   );
 }
 
+// Brings a dropped, done or archived session back (lib/resurrect).
+export function useResurrectSession() {
+  return useDoneMutation(
+    async (id: string) =>
+      (
+        await json<{ outcome: ResurrectOutcome }>(
+          await post(
+            `/api/sessions/${id}/resurrect`,
+            undefined,
+            DONE_REQUEST_TIMEOUT_MS
+          )
+        )
+      ).outcome
+  );
+}
+
 export function useArchivedQuery(workspaceId?: string, enabled = true) {
   return useQuery({
     queryKey: archivedKeys.list(workspaceId),

package/lib/chat/client-send.ts

@@ -3,20 +3,27 @@ import type { CompactFirst } from "./stale";
 
 // What a browser's send may carry: its text and images, and whether the
 // reader chose to compact a stale chat first. Who a message is from (`from`,
-// `peer`, `origin`) is set by the server alone, never by a client.
+// `peer`, `origin`) is set by the server alone, never by a client. Its own
+// id for the message is kept only in a shape no server id takes.
 export function clientSend(msg: unknown): {
   text: string;
   images?: ChatImage[];
   compact?: CompactFirst;
+  id?: string;
 } {
   const m = (msg ?? {}) as {
     text?: unknown;
     images?: unknown;
     compact?: unknown;
+    clientId?: unknown;
   };
   return {
     text: typeof m.text === "string" ? m.text : "",
     images: Array.isArray(m.images) ? (m.images as ChatImage[]) : undefined,
     ...(m.compact === true && { compact: "yes" as const }),
+    ...(isClientId(m.clientId) && { id: m.clientId }),
   };
 }
+
+export const isClientId = (id: unknown): id is string =>
+  typeof id === "string" && /^user-c-[A-Za-z0-9-]{8,64}$/.test(id);

package/lib/chat/demo.ts

@@ -5,6 +5,7 @@
  */
 
 import { randomUUID } from "crypto";
+import { clientSend } from "./client-send";
 import type { ChatConversation } from "./driver";
 import type { ChatClientMessage, ChatServerMessage } from "./events";
 import { demoConversation } from "./drivers/demo";
@@ -37,7 +38,11 @@ function conversation(sessionId: string): ChatConversation {
   return c;
 }
 
-export function sendDemoChat(sessionId: string, text: string): void {
+export function sendDemoChat(
+  sessionId: string,
+  text: string,
+  id = `user-${Date.now()}-${randomUUID().slice(0, 5)}`
+): void {
   const trimmed = text.trim();
   if (!trimmed) return;
   getSession(sessionId);
@@ -45,7 +50,7 @@ export function sendDemoChat(sessionId: string, text: string): void {
   if (count >= MAX_SENDS) throw new Error(DEMO_REFUSAL);
   sends.set(sessionId, count + 1);
   const item = {
-    id: `user-${Date.now()}-${randomUUID().slice(0, 5)}`,
+    id,
     kind: "user" as const,
     text: DEMO_VISITOR_TEXT,
     tagged: true as const,
@@ -84,7 +89,21 @@ export function handleDemoChat(
   msg: ChatClientMessage,
   reply: (m: ChatServerMessage) => void
 ): void {
-  if (msg.type === "send") return sendDemoChat(sessionId, String(msg.text));
+  if (msg.type === "send") {
+    const { id } = clientSend(msg);
+    if (!id) return sendDemoChat(sessionId, String(msg.text));
+    reply({ type: "accepted", id });
+    try {
+      return sendDemoChat(sessionId, String(msg.text), id);
+    } catch (err) {
+      reply({
+        type: "send_failed",
+        id,
+        message: err instanceof Error ? err.message : String(err),
+      });
+      throw err;
+    }
+  }
   if (msg.type === "interrupt") {
     void conversations.get(sessionId)?.interrupt();
     return;

package/lib/chat/drivers/claude.ts

@@ -183,6 +183,19 @@ export const claudeDriver: ChatDriver = {
     );
     let access = options.access;
     let plan = !options.permissionMode && !!options.plan;
+    // The mode the CLI is in. Asking again for the same one waits on the
+    // CLI starting up (seconds, on a new worker) for nothing.
+    let applied = sdkMode(access, plan);
+    const applyMode = async () => {
+      const mode = sdkMode(access, plan);
+      if (mode === applied) return;
+      const before = applied;
+      applied = mode;
+      await q.setPermissionMode(mode).catch((error: unknown) => {
+        if (applied === mode) applied = before;
+        throw error;
+      });
+    };
     const q = query({
       prompt: input,
       options: {
@@ -344,12 +357,12 @@ export const claudeDriver: ChatDriver = {
       async setAccess(next) {
         access = next;
         if (options.permissionMode || plan) return;
-        await q.setPermissionMode(sdkMode(access, plan));
+        await applyMode();
       },
       async setPlan(next) {
         if (options.permissionMode) return;
         plan = next;
-        await q.setPermissionMode(sdkMode(access, plan));
+        await applyMode();
       },
       respond(id, answer) {
         approvals.respond(id, answer);

package/lib/chat/drivers/opencode.ts

@@ -209,6 +209,7 @@ export const openCodeDriver: ChatDriver = {
         model = openCodeModel(next);
       },
       async setAccess(next) {
+        if (next === access) return;
         access = next;
         await ready;
         await setRules();

package/lib/chat/events.ts

@@ -381,11 +381,16 @@ export type ChatServerMessage =
       ok: boolean;
       error?: string;
     }
-  | { type: "undone"; from: string; text: string };
+  | { type: "undone"; from: string; text: string }
+  // A send with a `clientId` was taken in (before any worker is up), or
+  // failed. The message itself still comes as an item or in the queue.
+  | { type: "accepted"; id: string }
+  | { type: "send_failed"; id: string; message: string };
 
 // What a browser sends.
 export type ChatClientMessage =
-  | { type: "send"; text: string; images?: ChatImage[] }
+  // `clientId` (`user-c-…`) becomes the message's id: a resend is a no-op.
+  | { type: "send"; text: string; images?: ChatImage[]; clientId?: string }
   | { type: "queue_edit"; id: string; text: string }
   | { type: "queue_move"; id: string; by: -1 | 1 }
   | { type: "queue_delete"; id: string }