@saadnvd1/agent-os 0.3.646 → 0.3.649

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

@@ -12,7 +12,7 @@ export async function GET(request: NextRequest) {
   if (held)
     return NextResponse.json({ peer: { id: held.id, name: held.name } });
   try {
-    const { session, note } = resolveTarget(ref);
+    const { session, note } = resolveTarget(ref, from || null);
     return NextResponse.json({
       peer: { id: session.id, name: session.name },
       note,

package/components/SessionList/OrchestratorPinRow.tsx

@@ -15,7 +15,7 @@ import { orchestratorOpenActions } from "@/stores/orchestratorOpen";
 import { useRowContext } from "./RowContext";
 import { SessionRowMenu } from "./SessionRowMenu";
 import { ActiveTick, ROW_MENU_CONTENT } from "./RowShell";
-import { RowRename, UnreadDot } from "./RowParts";
+import { keepRenameFocus, RowRename, UnreadDot } from "./RowParts";
 import { QuickChangeRow } from "./QuickChangeRow";
 import { NestRail } from "./RowParts";
 
@@ -159,6 +159,7 @@ export const OrchestratorPinRow = memo(function OrchestratorPinRow({
         <DM.DropdownMenuContent
           align="end"
           className={ROW_MENU_CONTENT}
+          onCloseAutoFocus={keepRenameFocus(renaming)}
           onClick={(e) => e.stopPropagation()}
         >
           {menu("dropdown")}
@@ -171,7 +172,10 @@ export const OrchestratorPinRow = memo(function OrchestratorPinRow({
     <>
       <CM.ContextMenu>
         <CM.ContextMenuTrigger asChild>{content}</CM.ContextMenuTrigger>
-        <CM.ContextMenuContent className={ROW_MENU_CONTENT}>
+        <CM.ContextMenuContent
+          className={ROW_MENU_CONTENT}
+          onCloseAutoFocus={keepRenameFocus(renaming)}
+        >
           {menu("context")}
         </CM.ContextMenuContent>
       </CM.ContextMenu>

package/components/SessionList/RowParts.tsx

@@ -61,6 +61,12 @@ export function CardBadge({ count }: { count: number }) {
   );
 }
 
+// For a menu's onCloseAutoFocus: while a rename is open, the input keeps the
+// focus instead of the menu's trigger getting it back.
+export const keepRenameFocus = (renaming: boolean) => (e: Event) => {
+  if (renaming) e.preventDefault();
+};
+
 export function RowRename({
   initial,
   onDone,
@@ -70,13 +76,26 @@ export function RowRename({
 }) {
   const [value, setValue] = useState(initial);
   const ref = useRef<HTMLInputElement>(null);
-  // The menu closing hands focus back to its trigger; take it after that.
+  const hadFocus = useRef(false);
+  // The menu closing hands focus back to its trigger (RowShell stops that
+  // while renaming); keep taking it until we hold it, then leave it alone.
   useEffect(() => {
-    const t = setTimeout(() => {
-      ref.current?.focus();
-      ref.current?.select();
-    }, 50);
-    return () => clearTimeout(t);
+    const take = () => {
+      const el = ref.current;
+      if (!el || hadFocus.current) return;
+      el.focus();
+      if (document.activeElement === el) {
+        hadFocus.current = true;
+        el.select();
+      }
+    };
+    take();
+    const t = setInterval(take, 50);
+    const stop = setTimeout(() => clearInterval(t), 1000);
+    return () => {
+      clearInterval(t);
+      clearTimeout(stop);
+    };
   }, []);
   return (
     <input
@@ -84,7 +103,13 @@ export function RowRename({
       value={value}
       aria-label="Session name"
       onChange={(e) => setValue(e.target.value)}
-      onBlur={() => onDone(value.trim() || null)}
+      onFocus={() => {
+        hadFocus.current = true;
+      }}
+      onBlur={() => {
+        // Only once we've held focus: the menu closing hands it to its trigger.
+        if (hadFocus.current) onDone(value.trim() || null);
+      }}
       onKeyDown={(e) => {
         e.stopPropagation();
         if (e.key === "Enter") onDone(value.trim() || null);

package/components/SessionList/RowRename.test.ts

@@ -0,0 +1,102 @@
+import "@/components/Chat/composer/test-dom";
+import { act, createElement, useState } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { keepRenameFocus, RowRename } from "./RowParts";
+
+(
+  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+let root: Root;
+let host: HTMLElement;
+const input = () => host.querySelector("input")!;
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  host = document.createElement("div");
+  document.body.appendChild(host);
+  root = createRoot(host);
+});
+afterEach(() => {
+  act(() => root.unmount());
+  host.remove();
+  vi.useRealTimers();
+});
+
+function mount(onDone: (n: string | null) => void, initial = "old") {
+  act(() => root.render(createElement(RowRename, { initial, onDone })));
+}
+
+describe("RowRename", () => {
+  it("retries focus the menu stole, and ignores blur until it has it", () => {
+    const real = window.HTMLElement.prototype.focus;
+    let calls = 0;
+    // The first focus attempts land while the menu still traps focus.
+    vi.spyOn(window.HTMLElement.prototype, "focus").mockImplementation(
+      function (this: HTMLElement) {
+        if (++calls > 2) real.call(this);
+      }
+    );
+    const done = vi.fn();
+    mount(done);
+    act(() => input().dispatchEvent(new window.FocusEvent("blur")));
+    expect(done).not.toHaveBeenCalled();
+    act(() => vi.advanceTimersByTime(150));
+    expect(document.activeElement).toBe(input());
+    vi.restoreAllMocks();
+  });
+
+  it("keeps typed text across a parent re-render (list refresh)", () => {
+    function Parent() {
+      const [n, setN] = useState(0);
+      return createElement(
+        "div",
+        null,
+        createElement("button", { onClick: () => setN(n + 1) }),
+        createElement(RowRename, { initial: "old", onDone: () => {} })
+      );
+    }
+    act(() => root.render(createElement(Parent)));
+    const el = input();
+    act(() => {
+      const set = Object.getOwnPropertyDescriptor(
+        window.HTMLInputElement.prototype,
+        "value"
+      )!.set!;
+      set.call(el, "typed");
+      el.dispatchEvent(new window.Event("input", { bubbles: true }));
+    });
+    act(() => host.querySelector("button")!.click());
+    expect(input()).toBe(el);
+    expect(input().value).toBe("typed");
+  });
+
+  it("saves on Enter, cancels on Escape, saves on blur once focused", () => {
+    const done = vi.fn();
+    mount(done);
+    act(() => vi.advanceTimersByTime(60));
+    const key = (k: string) =>
+      act(() => {
+        input().dispatchEvent(
+          new window.KeyboardEvent("keydown", { key: k, bubbles: true })
+        );
+      });
+    key("Enter");
+    expect(done).toHaveBeenLastCalledWith("old");
+    key("Escape");
+    expect(done).toHaveBeenLastCalledWith(null);
+    act(() => input().blur());
+    expect(done).toHaveBeenCalledTimes(3);
+  });
+});
+
+describe("keepRenameFocus", () => {
+  it("stops the menu returning focus only while renaming", () => {
+    const e = { preventDefault: vi.fn() } as unknown as Event;
+    keepRenameFocus(false)(e);
+    expect(e.preventDefault).not.toHaveBeenCalled();
+    keepRenameFocus(true)(e);
+    expect(e.preventDefault).toHaveBeenCalled();
+  });
+});

package/components/SessionList/RowShell.tsx

@@ -6,6 +6,7 @@ import { Button } from "@/components/ui/button";
 import * as DM from "@/components/ui/dropdown-menu";
 import * as CM from "@/components/ui/context-menu";
 import { cn } from "@/lib/utils";
+import { keepRenameFocus } from "./RowParts";
 
 // The open row's accent: a thin rounded tick at the left edge, inside the
 // row so the list's overflow can't clip it.
@@ -41,6 +42,7 @@ export function RowShell({
   menu,
   menuLabel,
   menuButton = true,
+  renaming = false,
 }: {
   title: string;
   tipKey?: string;
@@ -60,6 +62,8 @@ export function RowShell({
   menuLabel: string;
   // False keeps the right-click menu but hides the ⋯ (while selecting).
   menuButton?: boolean;
+  // A rename input is open: closing the menu mustn't move focus off it.
+  renaming?: boolean;
 }) {
   const content = (
     <div
@@ -114,6 +118,7 @@ export function RowShell({
           <DM.DropdownMenuContent
             align="end"
             className={ROW_MENU_CONTENT}
+            onCloseAutoFocus={keepRenameFocus(renaming)}
             onClick={(e) => e.stopPropagation()}
           >
             {menu("dropdown")}
@@ -126,7 +131,10 @@ export function RowShell({
   return (
     <CM.ContextMenu>
       <CM.ContextMenuTrigger asChild>{content}</CM.ContextMenuTrigger>
-      <CM.ContextMenuContent className={ROW_MENU_CONTENT}>
+      <CM.ContextMenuContent
+        className={ROW_MENU_CONTENT}
+        onCloseAutoFocus={keepRenameFocus(renaming)}
+      >
         {menu("context")}
       </CM.ContextMenuContent>
     </CM.ContextMenu>

package/components/SessionList/SessionRow.tsx

@@ -115,6 +115,7 @@ export const SessionRow = memo(function SessionRow({
         menu={menu}
         menuLabel="Session actions"
         menuButton={!selecting}
+        renaming={renaming}
       >
         {renaming ? (
           <RowRename

package/lib/agents/brief.ts

@@ -2,7 +2,7 @@
 export const BUS_BRIEF = `You are one of several coding agents running in AgentOS. Other sessions may be working on related projects at the same time, and you can talk to them with the \`aos\` command:
 
 - \`aos peers\`: list sessions, their project and what each is doing
-- \`aos send <session> "<message>"\`: message a session by name (or project/name, an old name, or its id); it prints delivered, queued or FAILED
+- \`aos send <session> "<message>"\`: message a session by name (or project/name, an old name, or its id; \`orchestrator\` is your workspace's orchestrator); it prints delivered, queued or FAILED
 - \`aos inbox\`: read messages sent to you
 - \`aos history <session>\`: your conversation with a session
 - \`aos spawn <project> "<prompt>"\`: start a new agent session in a project

package/lib/bus/index.ts

@@ -7,7 +7,9 @@
 import { db, type Session } from "../db";
 import { getProject } from "../projects";
 import { statusDetector } from "../status-detector";
-import { sendChatConfirmed } from "../chat/runner";
+import { chatState, sendChatConfirmed } from "../chat/runner";
+import { chatActivityLine } from "../chat/activity";
+import { getWorkspace } from "../workspaces";
 import type { ChatOrigin, PeerMessage } from "../chat/events";
 import { sessionRowInfo } from "../session-meta";
 import { previousNames } from "../session-names";
@@ -38,6 +40,10 @@ export interface Peer {
   hostId: string;
   running: boolean;
   doing: string | null;
+  // The workspace it is the orchestrator of, else null.
+  orchestratorOf: string | null;
+  // The asking session's own workspace orchestrator.
+  yours?: boolean;
 }
 
 function liveSessions(): Session[] {
@@ -68,19 +74,41 @@ const sessionById = (id: string | null | undefined) =>
         | undefined)
     : undefined;
 
+// A chat has no pane: its worker is the state, and it can always take a
+// message (queued as its next prompt), so it is never "not running".
+async function peerState(
+  s: Session
+): Promise<{ running: boolean; subtitle: string | null }> {
+  if (s.view === "chat") {
+    const busy = chatState(s.id) === "running";
+    return {
+      running: true,
+      subtitle: chatActivityLine(s.id) ?? (busy ? "working" : "idle"),
+    };
+  }
+  const status = statusDetector.sessionExists(s.tmux_name)
+    ? await statusDetector.getStatus(s.tmux_name)
+    : "dead";
+  const info = sessionRowInfo(status, statusDetector.titleFor(s.tmux_name));
+  return { running: info.running, subtitle: info.subtitle };
+}
+
+const orchestratorOf = (s: Session) =>
+  s.role === "orchestrator" && s.workspace_id
+    ? (getWorkspace(s.workspace_id)?.name ?? "a workspace")
+    : null;
+
 // `callerId`: the asking session. A task its orchestrator moved here also
 // sees that orchestrator, which it can message though it runs elsewhere.
 export async function listPeers(callerId?: string): Promise<Peer[]> {
   await statusDetector.refreshCache();
   const sessions = liveSessions();
   const named = candidates(sessions);
-  const orchestrator = heldOrchestrator(sessionById(callerId));
+  const caller = sessionById(callerId);
+  const orchestrator = heldOrchestrator(caller);
   const listed = await Promise.all(
     sessions.map(async (s, i) => {
-      const status = statusDetector.sessionExists(s.tmux_name)
-        ? await statusDetector.getStatus(s.tmux_name)
-        : "dead";
-      const info = sessionRowInfo(status, statusDetector.titleFor(s.tmux_name));
+      const info = await peerState(s);
       return {
         id: s.id,
         name: s.name,
@@ -90,6 +118,10 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
         hostId: s.host_id,
         running: info.running,
         doing: info.subtitle,
+        orchestratorOf: orchestratorOf(s),
+        ...(caller?.workspace_id &&
+          s.role === "orchestrator" &&
+          s.workspace_id === caller.workspace_id && { yours: true }),
       };
     })
   );
@@ -105,6 +137,8 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
       hostId: "remote",
       running: true,
       doing: `your orchestrator, on ${orchestrator.heldFrom}`,
+      orchestratorOf: null,
+      yours: true,
     },
   ];
 }
@@ -116,28 +150,60 @@ export function resolveHeldOrchestrator(callerId: string, ref: string) {
 
 // A live session by name, old name, project/name, id or id prefix. The note
 // says when the name meant something other than its current owner.
-export function resolveTarget(ref: string): {
+export function resolveTarget(
+  ref: string,
+  callerId?: string | null
+): {
   session: Session;
   note?: string;
 } {
-  const found = tryResolveTarget(ref);
+  const found = tryResolveTarget(ref, callerId);
   if (!found.ok) throw new Error(found.error);
   return found;
 }
 
+// "orchestrator" / "my orchestrator": the caller's own workspace orchestrator.
+function ownOrchestrator(
+  ref: string,
+  sessions: Session[],
+  callerId?: string | null
+): Session | undefined {
+  if (!/^(my )?orchestrator$/i.test(ref.trim())) return undefined;
+  const workspace = sessionById(callerId)?.workspace_id;
+  if (!workspace) return undefined;
+  return sessions.find(
+    (s) => s.role === "orchestrator" && s.workspace_id === workspace
+  );
+}
+
 function tryResolveTarget(
-  ref: string
+  ref: string,
+  callerId?: string | null
 ):
   | { ok: true; session: Session; note?: string }
   | { ok: false; none: boolean; error: string } {
   const sessions = liveSessions();
+  const own = ownOrchestrator(ref, sessions, callerId);
+  if (own) return { ok: true, session: own };
   const r = resolveRef(ref, candidates(sessions));
-  if (!r.ok)
+  if (!r.ok) {
+    const orchestrators = /^(my )?orchestrator$/i.test(ref.trim())
+      ? sessions.filter((s) => s.role === "orchestrator")
+      : [];
+    if (orchestrators.length)
+      return {
+        ok: false,
+        none: true,
+        error: `You are in no workspace, so "${ref}" is ambiguous. Orchestrators: ${orchestrators
+          .map((s) => `${s.name} (id ${s.id.slice(0, 8)})`)
+          .join(", ")}`,
+      };
     return {
       ok: false,
       none: r.reason === "none",
       error: r.reason === "none" ? `${r.error}. Run: aos peers` : r.error,
     };
+  }
   return {
     ok: true,
     session: sessions.find((s) => s.id === r.id)!,
@@ -287,7 +353,7 @@ export async function sendMessage(opts: {
   // A held task's message to its orchestrator is kept for the holder to pull.
   const held = heldTarget(from, opts.to);
   if (from && held) return storeForHolder(from, held, body);
-  const target = tryResolveTarget(opts.to);
+  const target = tryResolveTarget(opts.to, opts.fromId);
   if (!target.ok) {
     // A task still in the start queue has no session yet: hold it.
     const queued = target.none ? findQueuedTarget(opts.to) : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.646",
+  "version": "0.3.649",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"
@@ -48,7 +48,7 @@
     "lint": "eslint .",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
-    "test": "vitest run",
+    "test": "scripts/test",
     "test:watch": "vitest",
     "check": "scripts/check",
     "screenshots": "tsx scripts/screenshots/run.ts",

package/scripts/check

@@ -56,7 +56,7 @@ if has static; then
   fi
 fi
 if has test; then
-  step "test";      npx vitest run ${vitest_args[@]+"${vitest_args[@]}"}
+  step "test";      scripts/test ${vitest_args[@]+"${vitest_args[@]}"}
 fi
 if has build; then
   # The build imports the generated migrations index, so it needs it even

package/scripts/test

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+# The full suite, kindly: through `aos heavy` (so other sessions are told) and
+# at low priority on a Mac. CI and machines without aos run plain vitest.
+set -euo pipefail
+cd "$(dirname "$0")/.."
+cmd=(npx vitest run "$@")
+[ "$(uname)" = Darwin ] && [ -z "${CI:-}" ] && cmd=(nice -n 10 "${cmd[@]}")
+if [ -z "${CI:-}" ] && command -v aos >/dev/null 2>&1; then
+  exec aos heavy -- "${cmd[@]}"
+fi
+exec "${cmd[@]}"