@saadnvd1/agent-os 0.3.664 → 0.3.671

package/app/api/audits/[kind]/[id]/route.test.ts

@@ -1,14 +1,14 @@
 import fs from "fs";
-import os from "os";
 import path from "path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import type { NextRequest } from "next/server";
 import { GET as list } from "../../route";
 import { GET } from "./route";
+import { tempDir } from "@/lib/test-temp";
 
 let dir: string;
 beforeEach(() => {
-  dir = fs.mkdtempSync(path.join(os.tmpdir(), "audits-route-"));
+  dir = tempDir("audits-route-");
   process.env.AGENTOS_AUDITS_DIR = dir;
   fs.mkdirSync(path.join(dir, "sessions"));
   fs.mkdirSync(path.join(dir, "gaps"));

package/app/api/mcp-auth/callback/route.test.ts

@@ -0,0 +1,42 @@
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const finish = vi.hoisted(() => vi.fn());
+vi.mock("@/lib/chat/mcp-auth", () => ({ finishMcpSignInFromRedirect: finish }));
+
+const { GET } = await import("./route");
+const get = (query: string) =>
+  GET(new NextRequest(`http://localhost:3011/api/mcp-auth/callback?${query}`));
+
+beforeEach(() => vi.clearAllMocks());
+
+describe("GET /api/mcp-auth/callback", () => {
+  it("hands the query string over and says which server signed in, escaped", async () => {
+    finish.mockResolvedValue({ server: "<b>linear</b>" });
+    const res = await get("code=c&state=s");
+    const html = await res.text();
+    // Only the query string goes on: the origin comes from the pending sign-in
+    expect(finish).toHaveBeenCalledWith("?code=c&state=s");
+    expect(res.status).toBe(200);
+    expect(html).toContain("&lt;b&gt;linear&lt;/b&gt;");
+    expect(html).not.toContain("<b>linear");
+    expect(res.headers.get("cache-control")).toBe("no-store");
+    expect(res.headers.get("referrer-policy")).toBe("no-referrer");
+  });
+
+  it("shows a refusal as a page, never throws", async () => {
+    finish.mockRejectedValue(new Error("That sign-in expired"));
+    const res = await get("code=c&state=s");
+    expect(res.status).toBe(400);
+    expect(await res.text()).toContain("That sign-in expired");
+  });
+
+  it("shows the provider's error escaped", async () => {
+    finish.mockResolvedValue({ server: "x" });
+    const res = await get("error=access_denied&error_description=%3Cscript%3E");
+    const html = await res.text();
+    expect(res.status).toBe(400);
+    expect(html).toContain("&lt;script&gt;");
+    expect(html).not.toContain("<script>");
+  });
+});

package/app/api/mcp-auth/callback/route.ts

@@ -0,0 +1,56 @@
+import { NextRequest } from "next/server";
+import { finishMcpSignInFromRedirect } from "@/lib/chat/mcp-auth";
+
+const escape = (text: string) =>
+  text.replace(
+    /[&<>"']/g,
+    (c) =>
+      ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[
+        c
+      ] as string
+  );
+
+function page(ok: boolean, heading: string, message: string): Response {
+  const body = `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${escape(heading)}</title><style>:root{color-scheme:light dark}body{font:16px system-ui,sans-serif;margin:0;min-height:100vh;display:grid;place-items:center;padding:24px;text-align:center}main{max-width:26rem}h1{font-size:1.25rem;margin:0 0 .5rem}p{margin:0;opacity:.75}</style></head><body><main><h1>${escape(heading)}</h1><p>${escape(message)}</p></main></body></html>`;
+  return new Response(body, {
+    status: ok ? 200 : 400,
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      "Cache-Control": "no-store",
+      "Referrer-Policy": "no-referrer",
+    },
+  });
+}
+
+// GET /api/mcp-auth/callback - where an MCP server's sign-in sends the
+// browser back to. The address carries a one-time code, so nothing here
+// logs or rethrows it.
+export async function GET(request: NextRequest) {
+  const params = request.nextUrl.searchParams;
+  const failed = params.get("error");
+  try {
+    if (failed && !params.get("code")) {
+      const why = (params.get("error_description") || failed).slice(0, 200);
+      await finishMcpSignInFromRedirect(request.nextUrl.search).catch(() => {});
+      return page(
+        false,
+        "Sign-in wasn't completed",
+        `${why}. Press Sign in again in AgentOS.`
+      );
+    }
+    const { server } = await finishMcpSignInFromRedirect(
+      request.nextUrl.search
+    );
+    return page(
+      true,
+      `Signed in to ${server}`,
+      "You can close this tab and go back to AgentOS."
+    );
+  } catch (error) {
+    return page(
+      false,
+      "Sign-in wasn't completed",
+      error instanceof Error ? error.message : "Press Sign in again."
+    );
+  }
+}

package/app/api/projects/init/route.test.ts

@@ -1,11 +1,9 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
 import { describe, expect, it } from "vitest";
 import type { NextRequest } from "next/server";
 import { getProject } from "@/lib/projects";
 import { createWorkspace } from "@/lib/workspaces";
 import { POST } from "./route";
+import { tempDir } from "@/lib/test-temp";
 
 const post = (body: object) =>
   POST({ json: async () => body } as unknown as NextRequest);
@@ -14,7 +12,7 @@ describe("POST /api/projects/init", () => {
   it("answers a folder that's already a project with 409 and it, and moves it on moveExisting", async () => {
     const a = createWorkspace("Route A");
     const b = createWorkspace("Route B");
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "aos-init-route-"));
+    const dir = tempDir("aos-init-route-");
 
     const made = await post({ path: dir, workspaceId: a.id });
     expect(made.status).toBe(201);

package/app/api/sessions/[id]/mcp-auth/route.test.ts

@@ -0,0 +1,86 @@
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const auth = vi.hoisted(() => ({
+  start: vi.fn(),
+  finish: vi.fn(),
+  reconnect: vi.fn(),
+}));
+vi.mock("@/lib/chat/mcp-auth", () => ({
+  startMcpSignIn: auth.start,
+  finishMcpSignIn: auth.finish,
+  reconnectMcpServer: auth.reconnect,
+}));
+
+const { POST } = await import("./route");
+
+const post = (body: unknown, headers: Record<string, string> = {}) =>
+  POST(
+    new NextRequest("http://x/api/sessions/s1/mcp-auth", {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+    }),
+    { params: Promise.resolve({ id: "s1" }) }
+  );
+const base = { server: "linear", itemId: "mcp-1" };
+
+beforeEach(() => vi.clearAllMocks());
+
+describe("POST /api/sessions/[id]/mcp-auth", () => {
+  it("starts with the browser's own origin, never one from the body", async () => {
+    auth.start.mockResolvedValue({ mode: "callback", authUrl: "https://a/b" });
+    const res = await post(
+      { ...base, action: "start", origin: "https://evil.example" },
+      { origin: "https://mac.ts.net:3443" }
+    );
+    expect(await res.json()).toEqual({
+      mode: "callback",
+      authUrl: "https://a/b",
+    });
+    expect(auth.start).toHaveBeenCalledWith("s1", {
+      ...base,
+      origin: "https://mac.ts.net:3443",
+    });
+  });
+
+  it("finishes with a pasted address pinned to the row", async () => {
+    auth.finish.mockResolvedValue({ server: "linear" });
+    const res = await post({
+      ...base,
+      action: "submit",
+      url: " https://x/cb?code=1&state=2 ",
+    });
+    expect(res.status).toBe(200);
+    expect(auth.finish).toHaveBeenCalledWith("https://x/cb?code=1&state=2", {
+      sessionId: "s1",
+      server: "linear",
+    });
+  });
+
+  it("reconnects", async () => {
+    auth.reconnect.mockResolvedValue(undefined);
+    expect((await post({ ...base, action: "reconnect" })).status).toBe(200);
+    expect(auth.reconnect).toHaveBeenCalledWith("s1", base);
+  });
+
+  it("refuses a bad body without calling anything", async () => {
+    for (const body of [
+      null,
+      { action: "start" },
+      { ...base, action: "nope" },
+      { ...base, action: "submit" },
+      { ...base, server: "x".repeat(300), action: "start" },
+    ])
+      expect((await post(body)).status).toBe(400);
+    expect(auth.start).not.toHaveBeenCalled();
+    expect(auth.finish).not.toHaveBeenCalled();
+  });
+
+  it("answers a refusal with its reason", async () => {
+    auth.start.mockRejectedValue(new Error("This chat's agent isn't running."));
+    const res = await post({ ...base, action: "start" });
+    expect(res.status).toBe(409);
+    expect((await res.json()).error).toMatch(/isn't running/);
+  });
+});

package/app/api/sessions/[id]/mcp-auth/route.ts

@@ -0,0 +1,58 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  finishMcpSignIn,
+  reconnectMcpServer,
+  startMcpSignIn,
+} from "@/lib/chat/mcp-auth";
+
+// POST /api/sessions/[id]/mcp-auth - sign in to an MCP server listed in a
+// chat's /mcp item: start it (answers with the link to open), finish it with
+// the address the provider ended on, or reconnect.
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const body = (await request.json().catch(() => null)) as {
+    action?: unknown;
+    server?: unknown;
+    itemId?: unknown;
+    url?: unknown;
+  } | null;
+  const { action, server, itemId, url } = body ?? {};
+  if (
+    typeof server !== "string" ||
+    !server ||
+    server.length > 200 ||
+    typeof itemId !== "string" ||
+    !itemId ||
+    itemId.length > 200
+  )
+    return NextResponse.json({ error: "Bad request" }, { status: 400 });
+  try {
+    if (action === "start")
+      return NextResponse.json(
+        await startMcpSignIn(id, {
+          itemId,
+          server,
+          origin: request.headers.get("origin"),
+        })
+      );
+    if (action === "submit") {
+      if (typeof url !== "string" || !url || url.length > 4096)
+        return NextResponse.json({ error: "Bad request" }, { status: 400 });
+      await finishMcpSignIn(url.trim(), { sessionId: id, server });
+      return NextResponse.json({ ok: true });
+    }
+    if (action === "reconnect") {
+      await reconnectMcpServer(id, { itemId, server });
+      return NextResponse.json({ ok: true });
+    }
+    return NextResponse.json({ error: "Bad request" }, { status: 400 });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Sign-in failed" },
+      { status: 409 }
+    );
+  }
+}

package/app/api/shares/route.test.ts

@@ -6,9 +6,10 @@ import path from "path";
 import type { AddressInfo } from "net";
 import { randomUUID } from "crypto";
 import { afterAll, beforeEach, describe, expect, it } from "vitest";
+import { tempDir } from "@/lib/test-temp";
 
 // A fake Connect that verifies each signed request against the machine's key.
-const dir = fs.mkdtempSync(path.join(os.tmpdir(), "agentos-share-route-"));
+const dir = tempDir("agentos-share-route-");
 const keys = crypto.generateKeyPairSync("ed25519");
 const publicPem = keys.publicKey
   .export({ type: "spki", format: "pem" })
@@ -90,9 +91,7 @@ await new Promise<void>((r) => server.listen(0, "127.0.0.1", r));
 process.env.AGENTOS_CONNECT_DIR = dir;
 process.env.CONNECT_API_URL = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
 process.env.AGENTOS_CONNECT_OPERATOR = "1";
-process.env.AGENTOS_ARTIFACTS_DIR = fs.mkdtempSync(
-  path.join(os.tmpdir(), "agentos-share-art-")
-);
+process.env.AGENTOS_ARTIFACTS_DIR = tempDir("agentos-share-art-");
 
 const link = () => {
   fs.writeFileSync(

package/app/api/workspaces/[id]/route.ts

@@ -12,6 +12,7 @@ export async function PATCH(request: NextRequest, { params }: RouteParams) {
     sortOrder,
     maxRunningTasks,
     wakeTasksOnPR,
+    orchFullAccess,
     mcpServers,
   } = await request.json();
   if (wakeTasksOnPR !== undefined && typeof wakeTasksOnPR !== "boolean")
@@ -19,6 +20,11 @@ export async function PATCH(request: NextRequest, { params }: RouteParams) {
       { error: "wakeTasksOnPR is true or false" },
       { status: 400 }
     );
+  if (orchFullAccess !== undefined && typeof orchFullAccess !== "boolean")
+    return NextResponse.json(
+      { error: "orchFullAccess is true or false" },
+      { status: 400 }
+    );
   let workspace;
   try {
     workspace = updateWorkspace(id, {
@@ -27,6 +33,7 @@ export async function PATCH(request: NextRequest, { params }: RouteParams) {
       sortOrder,
       maxRunningTasks,
       wakeTasksOnPR,
+      orchFullAccess,
       mcpServers,
     });
   } catch (error) {
@@ -36,7 +43,8 @@ export async function PATCH(request: NextRequest, { params }: RouteParams) {
   if (!workspace) {
     return NextResponse.json({ error: "Workspace not found" }, { status: 404 });
   }
-  if (mcpServers !== undefined) await applyMcpServers(id);
+  if (mcpServers !== undefined || orchFullAccess !== undefined)
+    await applyMcpServers(id);
   return NextResponse.json({ workspace });
 }
 

package/app/api/worktree-sweep/route.test.ts

@@ -48,6 +48,27 @@ describe("/api/worktree-sweep", () => {
     expect((await (await GET()).json()).armed).toBe(false);
   });
 
+  it("lets a session turn it on only as an orchestrator with full access", async () => {
+    const { createWorkspace, updateWorkspace } =
+      await import("@/lib/workspaces");
+    const { ensureOrchestrator } = await import("@/lib/orchestrator/home");
+    const { db } = await import("@/lib/db");
+    const w = createWorkspace(`sw-${randomUUID().slice(0, 6)}`);
+    const o = ensureOrchestrator(w.id);
+    expect((await put({ armed: true, session: o.id })).status).toBe(200);
+    await put({ armed: false });
+    // A task agent's session, in the same workspace.
+    db.prepare(`UPDATE sessions SET role = NULL WHERE id = ?`).run(o.id);
+    expect((await put({ armed: true, session: o.id })).status).toBe(403);
+    db.prepare(`UPDATE sessions SET role = 'orchestrator' WHERE id = ?`).run(
+      o.id
+    );
+    updateWorkspace(w.id, { orchFullAccess: false });
+    expect((await put({ armed: true, session: o.id })).status).toBe(403);
+    expect((await put({ armed: true, session: "nobody" })).status).toBe(403);
+    expect((await (await GET()).json()).armed).toBe(false);
+  });
+
   it("refuses a number that isn't a whole 0-365", async () => {
     for (const days of [-1, 1.5, 400, "7", undefined]) {
       const res = await put({ days });

package/app/api/worktree-sweep/route.ts

@@ -7,6 +7,8 @@ import {
   sweepDays,
 } from "@/lib/worktree-sweep/settings";
 import { requireLocalTrust } from "@/lib/security/route-guard";
+import { db, type Session } from "@/lib/db";
+import { orchestratorFullAccess } from "@/lib/orchestrator/full-access";
 import { sweepState } from "@/lib/worktree-sweep/state";
 
 const body = z.union([
@@ -15,7 +17,8 @@ const body = z.union([
     days: sweepDays.nullable(),
     projectId: z.string().min(1).optional(),
   }),
-  z.object({ armed: z.boolean() }),
+  // `session`: the AgentOS session the `aos` command runs in, if any.
+  z.object({ armed: z.boolean(), session: z.string().min(1).optional() }),
 ]);
 
 export async function GET() {
@@ -33,12 +36,29 @@ export async function PUT(request: NextRequest) {
       { status: 400 }
     );
   if ("armed" in got.data) {
-    // Turning the removal on is a person's call, made on this machine or
-    // over Tailscale: a stolen device token must not be able to. Turning it
-    // off stays on the ordinary gate.
+    // Turning the removal on is Saad's call, made on this machine or over
+    // Tailscale: a stolen device token must not be able to. The orchestrator
+    // arms through its sweep_arm tool (a linked machine over ssh to its own
+    // loopback), never with a device token. Turning it off stays on the
+    // ordinary gate.
     if (got.data.armed) {
       const refused = requireLocalTrust(request);
       if (refused) return refused;
+      // A session turns it on only as an orchestrator whose workspace has
+      // Orchestrator full access on.
+      if (got.data.session) {
+        const s = db
+          .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+          .get(got.data.session) as Session | undefined;
+        if (!s || !orchestratorFullAccess(s))
+          return NextResponse.json(
+            {
+              error:
+                "a session can't turn the full clean-up on: Saad does (Health, Clean-up, Turn on), or the orchestrator's sweep_arm tool when he has said to",
+            },
+            { status: 403 }
+          );
+      }
     }
     setReaperArmed(got.data.armed);
     return NextResponse.json(sweepState());

package/components/Chat/ChatPanel.tsx

@@ -51,6 +51,7 @@ import { Background, type BackgroundValue } from "./background";
 import { FindBar } from "./FindBar";
 import { FIND_EVENT, isFindKey, useFind } from "./useFind";
 import { McpServers } from "./McpServers";
+import { ChatSessionId } from "./session";
 import { ArtifactCard } from "./Artifact";
 import { PlanCard } from "./PlanCard";
 import { ChatIdle } from "./idle";
@@ -677,9 +678,11 @@ export function ChatPanel({
                         </p>
                       )}
                   </div>
-                  <ChatIdle.Provider value={idle}>
-                    <TimelineRows blocks={blocks} actions={actions} />
-                  </ChatIdle.Provider>
+                  <ChatSessionId.Provider value={sessionId}>
+                    <ChatIdle.Provider value={idle}>
+                      <TimelineRows blocks={blocks} actions={actions} />
+                    </ChatIdle.Provider>
+                  </ChatSessionId.Provider>
                   {pending.map((p) => (
                     <div
                       key={p.id}

package/components/Chat/McpServers.tsx

@@ -4,6 +4,9 @@ import { useState } from "react";
 import { ChevronRight } from "lucide-react";
 import type { ChatItem, McpServerView } from "@/lib/chat/events";
 import { cn } from "@/lib/utils";
+import { McpSignIn } from "./McpSignIn";
+import { useChatSessionId } from "./session";
+import { useMcpSignIn } from "@/data/chat/mcpAuth";
 
 type Status = McpServerView["status"];
 
@@ -25,38 +28,72 @@ function summary(servers: McpServerView[]): string {
   return parts.join(" · ");
 }
 
-function Server({ server }: { server: McpServerView }) {
+function Server({ server, itemId }: { server: McpServerView; itemId: string }) {
+  const sessionId = useChatSessionId();
   const [open, setOpen] = useState(false);
+  const [signingIn, setSigningIn] = useState(false);
+  const flow = useMcpSignIn(sessionId ?? "", itemId, server.name);
+  const needsAuth = server.status === "needs-auth";
+  const cantSignIn = needsAuth && !server.signIn;
   const status = STATUS[server.status];
   const tools = server.tools.length;
+  const expandable = !!tools || !!server.error || cantSignIn;
   return (
     <li>
-      <button
-        type="button"
-        onClick={() => setOpen(!open)}
-        disabled={!tools && !server.error}
-        aria-expanded={open}
-        className="hover:bg-foreground/[0.04] flex min-h-11 w-full items-center gap-2.5 rounded-lg px-2 text-left disabled:hover:bg-transparent md:min-h-9"
-      >
-        <span className={cn("h-2 w-2 shrink-0 rounded-full", status.dot)} />
-        <span className="min-w-0 flex-1 truncate font-mono text-xs">
-          {server.name}
-        </span>
-        <span className="text-muted-foreground shrink-0 text-xs">
-          {status.label}
-          {tools ? ` · ${tools} tool${tools === 1 ? "" : "s"}` : ""}
-        </span>
-        <ChevronRight
-          className={cn(
-            "text-muted-foreground h-3.5 w-3.5 shrink-0 transition-transform",
-            open && "rotate-90",
-            !tools && !server.error && "invisible"
-          )}
+      <div className="flex items-center gap-1">
+        <button
+          type="button"
+          onClick={() => setOpen(!open)}
+          disabled={!expandable}
+          aria-expanded={open}
+          className="hover:bg-foreground/[0.04] flex min-h-11 min-w-0 flex-1 items-center gap-2.5 rounded-lg px-2 text-left disabled:hover:bg-transparent md:min-h-9"
+        >
+          <span className={cn("h-2 w-2 shrink-0 rounded-full", status.dot)} />
+          <span className="min-w-0 flex-1 truncate font-mono text-xs">
+            {server.name}
+          </span>
+          <span className="text-muted-foreground shrink-0 text-xs">
+            {status.label}
+            {tools ? ` · ${tools} tool${tools === 1 ? "" : "s"}` : ""}
+          </span>
+          <ChevronRight
+            className={cn(
+              "text-muted-foreground h-3.5 w-3.5 shrink-0 transition-transform",
+              open && "rotate-90",
+              !expandable && "invisible"
+            )}
+          />
+        </button>
+        {server.signIn && sessionId && !signingIn && (
+          <button
+            type="button"
+            onClick={() => {
+              setSigningIn(true);
+              flow.start.mutate();
+            }}
+            aria-label={`Sign in to ${server.name}`}
+            className="bg-secondary text-secondary-foreground hairline h-11 shrink-0 rounded-lg px-3 text-xs font-medium md:h-8"
+          >
+            Sign in
+          </button>
+        )}
+      </div>
+      {signingIn && sessionId && needsAuth && (
+        <McpSignIn
+          flow={flow}
+          server={server.name}
+          onClose={() => setSigningIn(false)}
         />
-      </button>
+      )}
       {open && (
         <div className="text-muted-foreground space-y-1 pt-1 pr-2 pb-2 pl-6.5 text-xs">
           {server.scope && <p>From {server.scope} config</p>}
+          {cantSignIn && (
+            <p>
+              AgentOS can&apos;t sign in to this server. Sign in from a terminal
+              session with /mcp.
+            </p>
+          )}
           {server.error && (
             <p className="text-destructive whitespace-pre-wrap">
               {server.error}
@@ -98,7 +135,7 @@ export function McpServers({
       ) : (
         <ul>
           {item.servers.map((s) => (
-            <Server key={s.name} server={s} />
+            <Server key={s.name} server={s} itemId={item.id} />
           ))}
         </ul>
       )}