@saadnvd1/agent-os 0.3.728 → 0.3.731

package/app/api/bus/ports/route.test.ts

@@ -0,0 +1,43 @@
+import { NextRequest } from "next/server";
+import { describe, expect, it, vi } from "vitest";
+
+const ensure = vi.hoisted(() => vi.fn());
+vi.mock("@/lib/ports/ensurePorts", () => ({ ensurePorts: ensure }));
+
+const { POST } = await import("./route");
+
+const call = (body: unknown) =>
+  POST(
+    new NextRequest("http://localhost/api/bus/ports", {
+      method: "POST",
+      body: JSON.stringify(body),
+    })
+  );
+
+describe("POST /api/bus/ports (aos port)", () => {
+  it("refuses a body without a session or with a target that's neither a name nor a port", async () => {
+    expect((await call({})).status).toBe(400);
+    expect((await call({ from: "s", target: "3000; rm -rf /" })).status).toBe(
+      400
+    );
+    expect(ensure).not.toHaveBeenCalled();
+  });
+
+  it("hands the session and target to ensurePorts and returns its report", async () => {
+    ensure.mockResolvedValueOnce({
+      text: "PORT=3101 is free.",
+      blocked: false,
+    });
+    const res = await call({ from: "s1", target: "PORT" });
+    expect(res.status).toBe(200);
+    expect(await res.json()).toMatchObject({ text: "PORT=3101 is free." });
+    expect(ensure).toHaveBeenCalledWith("s1", "PORT");
+  });
+
+  it("is 404 for an unknown session and 409 for anything else it refuses", async () => {
+    ensure.mockRejectedValueOnce(new Error("No session nope"));
+    expect((await call({ from: "nope" })).status).toBe(404);
+    ensure.mockRejectedValueOnce(new Error("No port named X"));
+    expect((await call({ from: "s1", target: "X" })).status).toBe(409);
+  });
+});

package/app/api/bus/ports/route.ts

@@ -0,0 +1,35 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { ensurePorts } from "@/lib/ports/ensurePorts";
+
+const body = z.object({
+  from: z.string().min(1),
+  target: z
+    .string()
+    .regex(/^(\d{1,5}|[A-Za-z_][A-Za-z0-9_]*)$/)
+    .optional(),
+});
+
+// POST /api/bus/ports { from, target? } - `aos port`: whether the caller's
+// ports are free on this machine, who holds the ones that aren't, and a free
+// one in place of each taken one.
+export async function POST(request: NextRequest) {
+  const parsed = body.safeParse(await request.json().catch(() => null));
+  if (!parsed.success)
+    return NextResponse.json(
+      {
+        error: "Send { from: your session id, target?: a port name or number }",
+      },
+      { status: 400 }
+    );
+  const { from, target } = parsed.data;
+  try {
+    return NextResponse.json(await ensurePorts(from, target));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json(
+      { error: message },
+      { status: /^No session /.test(message) ? 404 : 409 }
+    );
+  }
+}

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

@@ -0,0 +1,65 @@
+import { randomUUID } from "crypto";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const route = await import("./route");
+const { saveItem } = await import("@/lib/chat/store");
+const { seedSession } = await import("@/lib/orchestrator/testing");
+const { createProject } = await import("@/lib/projects");
+
+const secret = ["gh", "p_", "d".repeat(36)].join("");
+const post = (b: unknown) =>
+  new Request("http://localhost/x", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(b),
+  });
+const params = (id: string) => ({ params: Promise.resolve({ id }) });
+
+function session() {
+  const project = createProject({
+    name: `p-${randomUUID().slice(0, 6)}`,
+    workingDirectory: "/tmp/p",
+  });
+  const id = seedSession({
+    projectId: project.id,
+    name: "Copy me",
+    view: "chat",
+  });
+  let t = 1;
+  const add = (i: Record<string, unknown>) =>
+    saveItem(id, { id: `c${t}`, createdAt: t++, ...i } as never);
+  add({ kind: "user", text: "first" });
+  add({ kind: "assistant", text: "one" });
+  add({ kind: "user", text: "second" });
+  add({ kind: "assistant", text: `two ${secret}` });
+  return id;
+}
+
+afterEach(() => vi.unstubAllEnvs());
+
+describe("POST /api/sessions/:id/export/turn", () => {
+  it("returns the turn and its response, secrets masked", async () => {
+    const id = session();
+    const res = await route.POST(post({ startId: "c3" }), params(id));
+    expect(res.status).toBe(200);
+    const j = await res.json();
+    expect(j.response).toContain("two [secret]");
+    expect(j.full).toContain("two [secret]");
+    expect(j.full).not.toContain("one");
+    expect(JSON.stringify(j)).not.toContain(secret);
+  });
+
+  it("404s an unknown turn and 400s a missing id", async () => {
+    const id = session();
+    expect((await route.POST(post({ startId: "zz" }), params(id))).status).toBe(
+      404
+    );
+    expect((await route.POST(post({}), params(id))).status).toBe(400);
+  });
+
+  it("refuses in the demo", async () => {
+    vi.stubEnv("AGENTOS_DEMO", "1");
+    const res = await route.POST(post({ startId: "c1" }), params(session()));
+    expect(res.status).toBe(403);
+  });
+});

package/app/api/sessions/[id]/export/turn/route.ts

@@ -0,0 +1,33 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { loadSession } from "@/lib/export/load";
+import { copyTurn } from "@/lib/export/turn";
+import { shareContext } from "@/lib/share/context";
+import { readJson, refuseDemo, toResponse } from "@/lib/share/route";
+import { BadShare } from "@/lib/share/service";
+
+const Body = z.object({ startId: z.string().min(1).max(200) });
+
+// POST /api/sessions/:id/export/turn - one turn as Markdown for the clipboard,
+// secrets masked: the whole turn, and its last agent message.
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const refused = refuseDemo();
+  if (refused) return refused;
+  const read = await readJson(request);
+  if ("refused" in read) return read.refused;
+  try {
+    const { id } = await params;
+    const body = Body.safeParse(read.body);
+    if (!body.success) throw new BadShare("startId is required", 400);
+    const loaded = loadSession(id);
+    return NextResponse.json(
+      copyTurn(loaded.items, body.data.startId, shareContext(), loaded.meta),
+      { headers: { "Cache-Control": "no-store" } }
+    );
+  } catch (err) {
+    return toResponse(err);
+  }
+}

package/components/Chat/Messages.tsx

@@ -24,6 +24,7 @@ import { FileChip } from "./FileChip";
 import { ImageThumb } from "./ImageThumb";
 import { Markdown } from "./Markdown";
 import { openSessionLink } from "./session-link";
+import { TurnCopy } from "./TurnCopy";
 import { UndoButton } from "./Undo";
 import { useRowState } from "./rowState";
 import { useBookmarkChat } from "@/components/Bookmarks/context";
@@ -407,6 +408,7 @@ export function TurnEnd({ item }: { item: Of<"turn_end"> }) {
       <div className="group text-muted-foreground/60 flex items-center gap-3 font-mono text-[11px]">
         <span className="bg-foreground/[0.06] h-px flex-1" />
         {label}
+        <TurnCopy turnEndId={item.id} />
         <TurnBookmark turnEndId={item.id} />
         <span className="bg-foreground/[0.06] h-px flex-1" />
       </div>

package/components/Chat/TurnCopy.tsx

@@ -0,0 +1,84 @@
+"use client";
+
+import { useState } from "react";
+import { Check, Copy } from "lucide-react";
+import { cn } from "@/lib/utils";
+import { fetchTurnCopy } from "@/data/exports";
+import { useBookmarkChat, useTurnStart } from "@/components/Bookmarks/context";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+
+type Part = "response" | "full";
+
+// "Copy" on a finished turn's end line: the answer alone, or the whole turn
+// (reasoning, tools, output, errors) as Markdown. One menu, so a phone's
+// turn row gets one button, not two.
+export function TurnCopy({ turnEndId }: { turnEndId: string }) {
+  const chat = useBookmarkChat();
+  const start = useTurnStart(turnEndId);
+  const [state, setState] = useState<"idle" | "copied" | "failed">("idle");
+  if (!chat || !start) return null;
+
+  const copy = async (part: Part) => {
+    try {
+      const turn = await fetchTurnCopy(chat.sessionId, start);
+      const text = part === "full" ? turn.full : turn.response;
+      if (!text) throw new Error("nothing to copy");
+      await navigator.clipboard.writeText(text);
+      setState("copied");
+    } catch {
+      setState("failed");
+    }
+    setTimeout(() => setState("idle"), 1500);
+  };
+
+  return (
+    <DropdownMenu>
+      <DropdownMenuTrigger asChild>
+        <button
+          type="button"
+          aria-label="Copy turn"
+          className={cn(
+            "hover:text-foreground hover:bg-foreground/[0.06] -my-2 flex min-h-11 shrink-0 items-center gap-1 rounded-md px-2 md:-my-1 md:min-h-7",
+            state === "idle"
+              ? "opacity-60 group-hover:opacity-100 focus-visible:opacity-100"
+              : state === "failed"
+                ? "text-destructive"
+                : "text-foreground"
+          )}
+        >
+          {state === "copied" ? (
+            <Check className="h-3 w-3" />
+          ) : (
+            <Copy className="h-3 w-3" />
+          )}
+          <span className="md:hidden">
+            {state === "failed"
+              ? "Copy failed"
+              : state === "copied"
+                ? "Copied"
+                : "Copy"}
+          </span>
+        </button>
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align="end" className="font-sans text-sm">
+        <DropdownMenuItem
+          className="min-h-11 md:min-h-8"
+          onSelect={() => void copy("response")}
+        >
+          Copy Response
+        </DropdownMenuItem>
+        <DropdownMenuItem
+          className="min-h-11 md:min-h-8"
+          onSelect={() => void copy("full")}
+        >
+          Copy Full Turn
+        </DropdownMenuItem>
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}

package/components/SessionList/GroupShelves.tsx

@@ -18,6 +18,7 @@ import {
 } from "@/components/ui/dropdown-menu";
 import { cn } from "@/lib/utils";
 import { SessionRow } from "./SessionRow";
+import { useDropZone } from "./useGroupDrag";
 
 function GroupHeader({
   shelf,
@@ -154,6 +155,51 @@ function GroupHeader({
   );
 }
 
+function GroupSection({
+  shelf,
+  siblings,
+  workspaceName,
+}: {
+  shelf: GroupShelf;
+  siblings: GroupShelf[];
+  workspaceName?: string;
+}) {
+  const { group } = shelf;
+  const update = useUpdateGroup();
+  const drop = useDropZone(
+    { groupId: group.id, workspaceId: group.workspace_id },
+    group.collapsed
+      ? () => update.mutate({ id: group.id, collapsed: false })
+      : undefined
+  );
+  const empty = !group.collapsed && shelf.rows.length === 0;
+  return (
+    <section
+      aria-label={group.name}
+      data-drop-over={drop.over || undefined}
+      className={cn(
+        "rounded-lg transition-colors",
+        drop.over && "bg-primary/10 ring-primary/50 ring-1"
+      )}
+      {...drop.props}
+    >
+      <GroupHeader
+        shelf={shelf}
+        siblings={siblings}
+        workspaceName={workspaceName}
+      />
+      {empty && (
+        <p className="text-muted-foreground/70 px-2.5 pb-2 text-xs">
+          Nothing here yet · drag a session in, or use its ⋯ menu
+        </p>
+      )}
+      {(group.collapsed ? [] : shelf.rows).map((r) => (
+        <SessionRow key={r.session.id} row={r} muted={r.settled === "auto"} />
+      ))}
+    </section>
+  );
+}
+
 // The user's groups, in order, between Pinned and the status shelves. A
 // folded group keeps its header and counts; an auto-settled member is muted.
 export function GroupShelves({
@@ -166,30 +212,19 @@ export function GroupShelves({
 }) {
   return groups.map((shelf) => {
     const { group } = shelf;
-    const siblings = groups.filter(
-      (g) => g.group.workspace_id === group.workspace_id
-    );
-    const empty = !group.collapsed && shelf.rows.length === 0;
     return (
-      <section key={group.id} aria-label={group.name}>
-        <GroupHeader
-          shelf={shelf}
-          siblings={siblings}
-          workspaceName={
-            workspaceNames && group.workspace_id
-              ? workspaceNames.get(group.workspace_id)
-              : undefined
-          }
-        />
-        {empty && (
-          <p className="text-muted-foreground/70 px-2.5 pb-2 text-xs">
-            Nothing here yet · move a session in from its ⋯ menu
-          </p>
+      <GroupSection
+        key={group.id}
+        shelf={shelf}
+        siblings={groups.filter(
+          (g) => g.group.workspace_id === group.workspace_id
         )}
-        {(group.collapsed ? [] : shelf.rows).map((r) => (
-          <SessionRow key={r.session.id} row={r} muted={r.settled === "auto"} />
-        ))}
-      </section>
+        workspaceName={
+          workspaceNames && group.workspace_id
+            ? workspaceNames.get(group.workspace_id)
+            : undefined
+        }
+      />
     );
   });
 }

package/components/SessionList/MoveToGroupMenu.test.ts

@@ -0,0 +1,77 @@
+import "@/components/Chat/composer/test-dom";
+import { act, createElement } 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 { sessionKeys } from "@/data/sessions/keys";
+import type { SessionGroup } from "@/lib/sidebar/shelves";
+import { groupTargets } from "./SidebarContextMenu";
+
+// Radix menus need a real browser; plain elements show what the menu offers.
+vi.mock("./RowMenuParts", async () => {
+  const { createElement: h } = await import("react");
+  const part = (p: { children?: unknown }) =>
+    h("div", null, p.children as never);
+  return {
+    icon: "",
+    MenuItem: part,
+    Expander: part,
+  };
+});
+
+(
+  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+let root: Root;
+let host: HTMLElement;
+beforeEach(() => {
+  host = document.createElement("div");
+  document.body.append(host);
+  root = createRoot(host);
+});
+afterEach(() => {
+  act(() => root.unmount());
+  host.remove();
+});
+
+const group = (id: string, name: string, workspace_id: string | null) =>
+  ({ id, name, workspace_id, sort_order: 0 }) as SessionGroup;
+
+async function menuText(groups: SessionGroup[], workspaceId: string | null) {
+  const { MoveToGroupMenu } = await import("./MoveToGroupMenu");
+  const client = new QueryClient();
+  client.setQueryData(sessionKeys.list(), {
+    sessions: [],
+    sessionGroups: groups,
+  });
+  await act(async () =>
+    root.render(
+      createElement(
+        QueryClientProvider,
+        { client },
+        createElement(MoveToGroupMenu, {
+          kind: "dropdown",
+          sessionId: "s1",
+          groupId: null,
+          workspaceId,
+        })
+      )
+    )
+  );
+  return host.textContent ?? "";
+}
+
+describe("Move to group", () => {
+  it("offers an empty group, and one made from the all-workspaces view", async () => {
+    // Viewing every workspace, "New group" files the group under a workspace
+    // (it used to be none, which no session can join).
+    const [target] = groupTargets(null, [{ id: "w1", name: "Work" }]);
+    const text = await menuText(
+      [group("g1", "Fresh", target.id), group("g2", "Elsewhere", "w2")],
+      "w1"
+    );
+    expect(text).toContain("Fresh");
+    expect(text).not.toContain("Elsewhere");
+  });
+});

package/components/SessionList/SessionRow.tsx

@@ -26,6 +26,7 @@ import { RowShell, type RowMenuKind } from "./RowShell";
 import { CardBadge, NestRail, RowDot, RowRename, UnreadDot } from "./RowParts";
 import { RowSubtitle } from "./RowSubtitle";
 import { OrchestratorAsks } from "./OrchestratorAsks";
+import { useRowDrag } from "./useGroupDrag";
 
 // One session: status dot, title over its project, and on the right what
 // needs you or when it last moved. Workers sit under their conductor. Drawn
@@ -64,6 +65,16 @@ export const SessionRow = memo(function SessionRow({
     ctx.onSelect(session.id);
   };
 
+  // The server files by the project's workspace first.
+  const workspaceId =
+    ctx.projects.find((p) => p.id === session.project_id)?.workspace_id ??
+    session.workspace_id ??
+    null;
+  const drag = useRowDrag(
+    { id: session.id, groupId: session.session_group_id ?? null, workspaceId },
+    !renaming
+  );
+
   const badge = rowStatusBadge(row);
   const cardCount = usePendingCardSessions().get(session.id) ?? 0;
 
@@ -77,7 +88,7 @@ export const SessionRow = memo(function SessionRow({
   );
 
   return (
-    <div data-session-row={session.id}>
+    <div data-session-row={session.id} {...drag}>
       <RowShell
         title={session.name}
         tipKey={`session:${session.id}`}

package/components/SessionList/SidebarContextMenu.test.ts

@@ -34,7 +34,11 @@ vi.mock("@/components/ui/dialog", async () => {
   };
 });
 
-import { SidebarContextMenu, isEditableTarget } from "./SidebarContextMenu";
+import {
+  SidebarContextMenu,
+  groupTargets,
+  isEditableTarget,
+} from "./SidebarContextMenu";
 
 (
   globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
@@ -102,3 +106,19 @@ describe("SidebarContextMenu", () => {
     expect(isEditableTarget(div)).toBe(false);
   });
 });
+
+describe("groupTargets", () => {
+  const ws = [
+    { id: "w1", name: "Work" },
+    { id: "w2", name: "Home" },
+  ];
+  it("uses the selected workspace", () => {
+    expect(groupTargets("w2", ws)).toEqual([{ id: "w2", label: "New group" }]);
+  });
+  it("never offers a group of no workspace when workspaces exist", () => {
+    expect(groupTargets(null, [ws[0]])).toEqual([
+      { id: "w1", label: "New group" },
+    ]);
+    expect(groupTargets(null, ws).map((t) => t.id)).toEqual(["w1", "w2"]);
+  });
+});

package/components/SessionList/SidebarContextMenu.tsx

@@ -16,15 +16,33 @@ export function isEditableTarget(target: EventTarget | null): boolean {
 // Right-click anywhere in the session list (empty space or a group header)
 // offers "New group". Rows keep their own menu, which wins because it has
 // already handled the event; text fields keep the browser's.
+// A group belongs to one workspace and only that workspace's sessions can
+// join it. With a workspace selected the group goes there; viewing all of
+// them, the choice is one entry per workspace (a group of no workspace could
+// hold nothing).
+export function groupTargets(
+  workspaceId: string | null,
+  workspaces: readonly { id: string; name: string }[]
+): { id: string | null; label: string }[] {
+  if (workspaceId || workspaces.length === 0)
+    return [{ id: workspaceId, label: "New group" }];
+  if (workspaces.length === 1)
+    return [{ id: workspaces[0].id, label: "New group" }];
+  return workspaces.map((w) => ({ id: w.id, label: `New group in ${w.name}` }));
+}
+
 export function SidebarContextMenu({
   workspaceId,
+  workspaces = [],
   children,
 }: {
   workspaceId: string | null;
+  workspaces?: readonly { id: string; name: string }[];
   children?: ReactNode;
 }) {
   const createGroup = useCreateGroup();
   const [naming, setNaming] = useState(false);
+  const [target, setTarget] = useState<string | null>(workspaceId);
 
   return (
     <>
@@ -37,21 +55,27 @@ export function SidebarContextMenu({
         >
           {children}
         </CM.ContextMenuTrigger>
-        <CM.ContextMenuContent className="w-44">
-          <CM.ContextMenuItem
-            className="min-h-11 md:min-h-8"
-            onSelect={() => setNaming(true)}
-          >
-            <FolderPlus className="mr-2 h-3.5 w-3.5" />
-            New group
-          </CM.ContextMenuItem>
+        <CM.ContextMenuContent className="w-52">
+          {groupTargets(workspaceId, workspaces).map((t) => (
+            <CM.ContextMenuItem
+              key={t.id ?? "none"}
+              className="min-h-11 md:min-h-8"
+              onSelect={() => {
+                setTarget(t.id);
+                setNaming(true);
+              }}
+            >
+              <FolderPlus className="mr-2 h-3.5 w-3.5" />
+              <span className="truncate">{t.label}</span>
+            </CM.ContextMenuItem>
+          ))}
         </CM.ContextMenuContent>
       </CM.ContextMenu>
       <WorkspaceNameDialog
         open={naming}
         title="New group"
         submitLabel="Create"
-        onSubmit={(name) => createGroup.mutate({ name, workspaceId })}
+        onSubmit={(name) => createGroup.mutate({ name, workspaceId: target })}
         onClose={() => setNaming(false)}
       />
     </>

package/components/SessionList/index.tsx

@@ -21,6 +21,7 @@ import { SidebarSearch } from "./SidebarSearch";
 import { ProjectFilter } from "./ProjectFilter";
 import { SelectionToolbar } from "./SelectionToolbar";
 import { SidebarBody } from "./SidebarBody";
+import { useDropZone } from "./useGroupDrag";
 import { SidebarContextMenu } from "./SidebarContextMenu";
 import { SidebarDialogs, type SidebarDialog } from "./SidebarDialogs";
 import type { SessionListProps } from "./SessionList.types";
@@ -43,6 +44,8 @@ export function SessionList({
   pinControls,
 }: SessionListProps) {
   const data = useSidebarData(sessionStatuses);
+  // Dropping outside every group takes a session out of its group.
+  const outside = useDropZone(null);
   useSessionTips(data);
   const { shelves, ui, project } = data;
   const mutations = useSessionListMutations({ onSelectSession: onSelect });
@@ -194,8 +197,14 @@ export function SessionList({
       )}
 
       <ScrollArea className="w-full flex-1">
-        <SidebarContextMenu workspaceId={data.workspace?.id ?? null}>
-          <div className="min-h-[60vh] max-w-full px-1.5 pb-6">
+        <SidebarContextMenu
+          workspaceId={data.workspace?.id ?? null}
+          workspaces={data.workspaces}
+        >
+          <div
+            className="min-h-[60vh] max-w-full px-1.5 pb-6"
+            {...outside.props}
+          >
             <RowProvider value={rowContext}>
               <SidebarBody
                 data={data}