@saadnvd1/agent-os 0.3.555 → 0.3.556

package/app/api/sessions/[id]/done/route.test.ts

@@ -0,0 +1,70 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const doneSession = vi.hoisted(() => vi.fn());
+const deadline = vi.hoisted(() => vi.fn());
+vi.mock("@/lib/done", () => ({
+  doneSession,
+  getDoneTarget: (id: string) => {
+    if (id === "gone") throw new Error("Session not found");
+    return { id, name: "Fix pair page menu label" };
+  },
+}));
+vi.mock("@/lib/done/deadline", () => ({
+  withinDeadline: (...a: unknown[]) => {
+    deadline(...a);
+    return a[0];
+  },
+}));
+
+const { POST } = await import("./route");
+const post = (id: string) =>
+  POST(new Request("http://x", { method: "POST" }), {
+    params: Promise.resolve({ id }),
+  });
+
+const unhandled: unknown[] = [];
+process.on("unhandledRejection", (e) => unhandled.push(e));
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  unhandled.length = 0;
+});
+
+describe("POST /api/sessions/:id/done", () => {
+  it("answers 404 for an unknown id, without starting anything or leaving a rejection", async () => {
+    const res = await post("gone");
+    expect(res.status).toBe(404);
+    expect(doneSession).not.toHaveBeenCalled();
+    await new Promise((r) => setTimeout(r, 10));
+    expect(unhandled).toEqual([]);
+  });
+
+  it("runs a quick change's done through the deadline wrapper", async () => {
+    doneSession.mockResolvedValue({ text: "Merged." });
+    const res = await post("q1");
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ outcome: { text: "Merged." } });
+    expect(deadline).toHaveBeenCalledWith(
+      expect.any(Promise),
+      "Fix pair page menu label"
+    );
+  });
+
+  it("returns the refusal, and a second done while one runs is refused", async () => {
+    let finish!: (v: unknown) => void;
+    doneSession.mockReturnValueOnce(new Promise((r) => (finish = r)));
+    const first = post("q2");
+    await new Promise((r) => setTimeout(r, 0));
+    const second = await post("q2");
+    expect(second.status).toBe(409);
+    expect((await second.json()).error).toMatch(/already being finished/);
+    expect(doneSession).toHaveBeenCalledTimes(1);
+    finish({ text: "ok" });
+    expect((await first).status).toBe(200);
+
+    doneSession.mockRejectedValueOnce(new Error("Not done. ci failed"));
+    const refused = await post("q2");
+    expect(refused.status).toBe(409);
+    expect((await refused.json()).error).toMatch(/ci failed/);
+  });
+});

package/app/api/sessions/[id]/done/route.ts

@@ -1,19 +1,45 @@
 import { NextResponse } from "next/server";
-import { doneSession } from "@/lib/done";
+import { doneSession, getDoneTarget } from "@/lib/done";
+import { withinDeadline } from "@/lib/done/deadline";
+
+// Sessions with a done running. Released when the work ends, not when the
+// request's deadline does, so a retry can't start a parallel run beside one
+// that is still going.
+const g = globalThis as unknown as { __agentosDoneRunning?: Set<string> };
+const running: Set<string> = (g.__agentosDoneRunning ??= new Set());
 
 // POST /api/sessions/:id/done - finished work: merge through the gates if
-// its PR is open, clean up, archive. 409 with the reason when refused.
+// its PR is open, clean up, archive. 404 for an unknown session, 409 with
+// the reason when refused or already running.
 export async function POST(
   _request: Request,
   { params }: { params: Promise<{ id: string }> }
 ) {
+  const id = (await params).id;
+  let name: string;
+  try {
+    name = getDoneTarget(id).name;
+  } catch {
+    return NextResponse.json({ error: "Session not found" }, { status: 404 });
+  }
+  if (running.has(id))
+    return NextResponse.json(
+      { error: `${name} is already being finished: wait for it to end.` },
+      { status: 409 }
+    );
+  running.add(id);
   try {
-    const outcome = await doneSession((await params).id, {
-      by: "direct",
-      onPeer: true,
-    });
+    const work = doneSession(id, { by: "direct", onPeer: true });
+    work.then(
+      () => running.delete(id),
+      () => running.delete(id)
+    );
+    const outcome = await withinDeadline(work, name);
     return NextResponse.json({ outcome });
   } catch (error) {
+    // A done that threw before it started has nothing left to hold.
+    if (!(error instanceof Error) || !/taking longer/.test(error.message))
+      running.delete(id);
     const message = error instanceof Error ? error.message : String(error);
     return NextResponse.json({ error: message }, { status: 409 });
   }

package/components/SessionList/useDoneAction.test.ts

@@ -0,0 +1,149 @@
+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 { useDoneAction } = 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 confirmSpy = vi.fn(() => false);
+const fetchSpy = vi.fn();
+
+function Probe() {
+  const markDone = useDoneAction();
+  useEffect(() => {
+    hook.current = markDone;
+  });
+  return null;
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.stubGlobal("confirm", confirmSpy);
+  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 quick = {
+  id: "q1",
+  name: "Fix pair page menu label",
+  quick_of: "orch",
+  task_status: "running",
+  pr_status: "open",
+  pr_number: 281,
+} as Session;
+
+const respond = (status: number, body: object) =>
+  fetchSpy.mockResolvedValue({
+    ok: status < 400,
+    status,
+    json: async () => body,
+  });
+// Done on an open PR asks first, in a toast; Merge is its action.
+const confirmMerge = () => {
+  const [, opts] = toast.mock.calls.at(-1) as unknown as [
+    string,
+    { action: { onClick: () => void } },
+  ];
+  act(() => opts.action.onClick());
+};
+const settle = () => act(() => new Promise((r) => setTimeout(r, 0)));
+
+describe("Done from a row's menu", () => {
+  it("asks in the app, not with confirm(), and does nothing until Merge is chosen", async () => {
+    respond(200, {
+      outcome: {
+        id: "q1",
+        name: quick.name,
+        merged: "Merged.",
+        worktree: { action: "none" },
+        text: "Merged. Agent stopped, no worktree.",
+      },
+    });
+    act(() => hook.current(quick));
+    expect(fetchSpy).not.toHaveBeenCalled();
+    confirmMerge();
+    await settle();
+    expect(confirmSpy).not.toHaveBeenCalled();
+    expect(fetchSpy).toHaveBeenCalledWith(
+      "/api/sessions/q1/done",
+      expect.objectContaining({ method: "POST" })
+    );
+    expect(toast.success).toHaveBeenCalledWith(
+      "Merged. Agent stopped, no worktree.",
+      expect.objectContaining({ id: "t1" })
+    );
+  });
+
+  it("shows a refusal as a toast naming the gate, for a quick change and a task", async () => {
+    respond(409, {
+      error: "Not done, nothing merged.\n- ci failed: CI failed",
+    });
+    act(() => hook.current(quick));
+    confirmMerge();
+    await settle();
+    act(() => hook.current({ ...quick, id: "t2", quick_of: null } as Session));
+    confirmMerge();
+    await settle();
+    expect(fetchSpy).toHaveBeenCalledTimes(2);
+    expect(toast.error).toHaveBeenCalledTimes(2);
+    expect(toast.error).toHaveBeenCalledWith(
+      expect.stringContaining("ci failed"),
+      expect.objectContaining({ id: "t1" })
+    );
+  });
+
+  it("ends the Merging toast with an error when the server never answers", async () => {
+    vi.useFakeTimers();
+    fetchSpy.mockImplementation(
+      (_url: string, init: { signal?: AbortSignal }) =>
+        new Promise((_, reject) =>
+          init.signal?.addEventListener("abort", () =>
+            reject(init.signal?.reason)
+          )
+        )
+    );
+    act(() => hook.current(quick));
+    confirmMerge();
+    expect(toast.error).not.toHaveBeenCalled();
+    await act(() => vi.advanceTimersByTimeAsync(181_000));
+    vi.useRealTimers();
+    expect(toast.error).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({ id: "t1" })
+    );
+  });
+});

package/components/SessionList/useDoneAction.ts

@@ -7,21 +7,12 @@ import {
 } from "@/data/done";
 import { useSettleSession } from "@/data/sessions/shelf";
 
-// Done from a session's menu: an open PR merges through the gates, so that
-// one asks first; the rest can be undone from the toast.
+// Done from a session's menu: an open PR merges through the gates, after an
+// in-app confirmation; a failing gate comes back as an error toast naming it.
 export function useDoneAction() {
   const done = useDoneSession();
   const settle = useSettleSession();
-  return (session: Session) => {
-    const merges =
-      session.task_status === "running" && session.pr_status === "open";
-    if (
-      merges &&
-      !confirm(
-        `Merge ${session.name}'s PR through the gates and finish it? A failing gate refuses and nothing merges.`
-      )
-    )
-      return;
+  const run = (session: Session, merges: boolean) => {
     const id = toast.loading(
       merges ? `Merging ${session.name}…` : `Finishing ${session.name}…`
     );
@@ -45,6 +36,20 @@ export function useDoneAction() {
       onError: (e) => toast.error(e.message, { id, duration: 12000 }),
     });
   };
+  return (session: Session) => {
+    const merges =
+      session.task_status === "running" && session.pr_status === "open";
+    if (!merges) return run(session, false);
+    // Merging is the one Done that can't be undone: asked in the app, not
+    // with confirm(), which a webview drops.
+    toast(`Merge ${session.name}'s PR and finish it?`, {
+      description:
+        "It merges only through the orchestrator's gates; a failing gate refuses and nothing merges.",
+      duration: 15000,
+      action: { label: "Merge", onClick: () => run(session, true) },
+      cancel: { label: "Cancel", onClick: () => {} },
+    });
+  };
 }
 
 // Archive from a session's menu: puts it away; Unarchive brings it back.

package/data/done/index.ts

@@ -17,12 +17,34 @@ async function json<T>(res: Response): Promise<T> {
   return data;
 }
 
-const post = (url: string, body?: object) =>
-  fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: body ? JSON.stringify(body) : undefined,
-  });
+// Longer than the server's own deadline for done (lib/done/deadline.ts), so
+// the pending toast always ends even if the server never answers.
+export const DONE_REQUEST_TIMEOUT_MS = 180_000;
+
+async function post(url: string, body?: object, timeoutMs?: number) {
+  const abort = new AbortController();
+  const timer = timeoutMs
+    ? setTimeout(
+        () =>
+          abort.abort(
+            new Error(
+              "The server didn't answer in time. It may still be working: check the row, then try again."
+            )
+          ),
+        timeoutMs
+      )
+    : undefined;
+  try {
+    return await fetch(url, {
+      signal: abort.signal,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+}
 
 function useDoneMutation<V, R>(fn: (v: V) => Promise<R>) {
   const queryClient = useQueryClient();
@@ -40,7 +62,11 @@ export function useDoneSession() {
     async (id: string) =>
       (
         await json<{ outcome: DoneOutcome }>(
-          await post(`/api/sessions/${id}/done`)
+          await post(
+            `/api/sessions/${id}/done`,
+            undefined,
+            DONE_REQUEST_TIMEOUT_MS
+          )
         )
       ).outcome
   );

package/lib/done/deadline.ts

@@ -0,0 +1,45 @@
+// Done merges, stops the agent and cleans up; any step can stall on a lock or
+// a slow remote. A request must always end: past this it answers that it is
+// still going, rather than leaving the row on "Merging…".
+export const DONE_DEADLINE_MS = 150_000;
+
+export async function withinDeadline<T>(
+  work: Promise<T>,
+  name: string,
+  ms = DONE_DEADLINE_MS
+): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const late = new Promise<never>((_, reject) => {
+    timer = setTimeout(
+      () =>
+        reject(
+          new Error(
+            `Done on ${name} is taking longer than ${Math.round(ms / 1000)}s and is still running in the background. Check the row in a moment; if it hasn't moved, try Done again.`
+          )
+        ),
+      ms
+    );
+  });
+  // The work keeps going; its late failure must not be an unhandled rejection.
+  work.catch(() => {});
+  try {
+    return await Promise.race([work, late]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// Best-effort: waits for `work` up to `ms`, then carries on without it.
+export async function withTimeout(
+  work: Promise<unknown>,
+  ms: number
+): Promise<void> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  work.catch(() => {});
+  await Promise.race([
+    work,
+    new Promise((resolve) => {
+      timer = setTimeout(resolve, ms);
+    }),
+  ]).finally(() => clearTimeout(timer));
+}

package/lib/done/index.ts

@@ -22,6 +22,7 @@ import { archiveSession } from "./archive";
 import { settleSession } from "../sidebar/shelf-state";
 import { demoMode } from "../security/demo";
 import { planDone } from "./plan";
+import { withTimeout } from "./deadline";
 import { deleteMergedRemote } from "./remote";
 import { settleWorktree, type WorktreeFate } from "./worktree";
 import { sessionMergePolicy } from "../tasks/finish";
@@ -151,7 +152,9 @@ export async function doneSession(
   // A sign-off just before this (the orchestrator's sign_off, then done)
   // is still cleaning up in the background: read what it leaves.
   await mergeSettled(s.id);
-  await statusDetector.refreshCache();
+  // A quick change has no tmux session, and a listing that stalls (a slow
+  // ssh host, a loaded tmux) must not hold up a merge that doesn't read it.
+  if (!s.quick_of) await withTimeout(statusDetector.refreshCache(), 10_000);
   const plan = await planDone(s, opts.callerId);
   if (plan.action === "refuse") throw new Error(plan.reason);
   if (plan.action === "merge" && opts.noMerge)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.555",
+  "version": "0.3.556",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"