@saadnvd1/agent-os 0.3.736 → 0.3.737

package/app/api/hosts/[id]/agents/route.ts

@@ -0,0 +1,22 @@
+import { NextResponse } from "next/server";
+import { machineCatalog } from "@/lib/machines/catalog";
+import { hostCatalog } from "@/lib/machines/remote";
+import { getHost, isRemoteHost } from "@/lib/hosts";
+import type { HostCatalogResponse } from "@/lib/machines/types";
+
+export const dynamic = "force-dynamic";
+
+// The agents and models a machine reports, for the new-session form: this
+// machine's own, or a linked machine's through its AgentOS.
+export async function GET(
+  _request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  if (!getHost(id))
+    return NextResponse.json({ error: "Unknown machine" }, { status: 404 });
+  const body: HostCatalogResponse = isRemoteHost(id)
+    ? await hostCatalog(id)
+    : { catalog: await machineCatalog(), error: null };
+  return NextResponse.json(body);
+}

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

@@ -1,5 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
-import { deleteHost } from "@/lib/hosts";
+import { deleteHost, renameHost } from "@/lib/hosts";
+import { requireLocalTrust } from "@/lib/security/route-guard";
 import { pinForHost } from "@/lib/peer/links";
 
 export async function DELETE(
@@ -21,3 +22,25 @@ export async function DELETE(
     return NextResponse.json({ error: message }, { status: 400 });
   }
 }
+
+// Rename a machine; "local" is this one, and its name is the one Work across
+// machines shows too.
+export async function PATCH(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const denied = requireLocalTrust(request);
+  if (denied) return denied;
+  try {
+    const id = (await params).id;
+    const body = (await request.json().catch(() => null)) as {
+      name?: unknown;
+    } | null;
+    return NextResponse.json({
+      name: renameHost(id, String(body?.name ?? "")),
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

package/app/api/hosts/route.ts

@@ -1,7 +1,10 @@
 import { NextRequest, NextResponse } from "next/server";
 import { createHost, listHosts } from "@/lib/hosts";
+import { refreshHostInfo } from "@/lib/machines/remote";
 
 export async function GET() {
+  // Linked machines' names and OS, for the next read; never waited on.
+  refreshHostInfo();
   return NextResponse.json({ hosts: listHosts() });
 }
 

package/app/api/machine/browser/route.ts

@@ -0,0 +1,22 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { browserMachine } from "@/lib/machines/browser";
+import { thisMachine } from "@/lib/machines/identity";
+import { allHostInfo } from "@/lib/machines/remote";
+import { REMOTE_HEADER, TRUST_HEADER } from "@/lib/security/auth";
+
+export const dynamic = "force-dynamic";
+
+// Which machine this browser is on, when the connection says.
+export function GET(request: NextRequest) {
+  return NextResponse.json(
+    browserMachine(
+      request.headers.get(TRUST_HEADER),
+      request.headers.get(REMOTE_HEADER),
+      thisMachine().addresses,
+      allHostInfo().map((i) => ({
+        hostId: i.hostId,
+        addresses: i.addresses,
+      }))
+    )
+  );
+}

package/app/api/machine/route.ts

@@ -0,0 +1,10 @@
+import { NextResponse } from "next/server";
+import { thisMachineReport } from "@/lib/machines/report";
+
+export const dynamic = "force-dynamic";
+
+// This machine's name, OS, addresses, agents and models. A linked machine
+// asks for it (it is on the peer allowlist) to fill the new-session form.
+export async function GET() {
+  return NextResponse.json(await thisMachineReport());
+}

package/components/Claims/ClaimsSheet.tsx

@@ -13,6 +13,9 @@ import {
 } from "@/components/ui/dialog";
 import { useNow } from "@/components/Chat/useNow";
 import { useClaims } from "@/data/claims";
+import { useHostsQuery } from "@/data/hosts";
+import { useBrowserMachine } from "@/data/machines";
+import { machineLabel } from "@/lib/machines/label";
 import { claimsUi, claimsUiActions } from "@/stores/claimsUi";
 import { cn } from "@/lib/utils";
 import { ClaimRow } from "./ClaimRow";
@@ -50,6 +53,12 @@ export function ClaimsSheet() {
         .flatMap((o) => o.shared)
     );
   const here = data?.machine.id;
+  const browser = useBrowserMachine();
+  const { data: hosts } = useHostsQuery();
+  // The browser's machine by name: claims know machines by their own ids.
+  const browserName = hosts
+    ?.find((h) => h.id === browser.hostId)
+    ?.name.toLowerCase();
 
   return (
     <Dialog open={snap.open} onOpenChange={claimsUiActions.setOpen}>
@@ -77,7 +86,16 @@ export function ClaimsSheet() {
                     key={m.id}
                     className="bg-muted/40 flex items-center gap-2 rounded-lg px-3 py-2 text-xs"
                   >
-                    <span className="font-medium">{m.name}</span>
+                    <span className="font-medium">
+                      {machineLabel(
+                        { id: m.self ? "local" : m.id, name: m.name },
+                        m.self
+                          ? browser.hostId
+                          : m.name.toLowerCase() === browserName
+                            ? m.id
+                            : null
+                      )}
+                    </span>
                     <span
                       className={cn(
                         "text-muted-foreground",

package/components/Claims/claims-ui.test.ts

@@ -103,7 +103,7 @@ describe("claims keys and helpers", () => {
     expect(startedText({ startedAt: 0 }, 12 * 60_000)).toBe("started 12m ago");
     expect(startedText({ startedAt: 0 }, 5_000)).toBe("just started");
     expect(lastHeardText(0, 6 * 60_000)).toBe("last heard 6m ago");
-    expect(lastHeardText(null, 0)).toBe("this machine");
+    expect(lastHeardText(null, 0)).toBe("serves this dashboard");
   });
 
   const c = (id: string, repo: string, startedAt: number) =>

package/components/Claims/format.ts

@@ -17,7 +17,7 @@ export const startedText = (c: Pick<Claim, "startedAt">, now: number) => {
 
 /** "last heard 6m ago". */
 export const lastHeardText = (at: number | null, now: number) => {
-  if (at === null) return "this machine";
+  if (at === null) return "serves this dashboard";
   const s = span(now - at);
   return s === "under a minute" ? "heard just now" : `last heard ${s} ago`;
 };

package/components/Draft/AgentModelChip.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import type { CatalogAgent, MachineCatalog } from "@/lib/machines/types";
+import { catalogBlocker, usableAgent } from "./AgentModelChip";
+
+const agent = (over: Partial<CatalogAgent>): CatalogAgent => ({
+  agent: "claude",
+  label: "Claude Code",
+  installed: true,
+  auth: "ready",
+  hint: null,
+  models: [],
+  defaultModel: "opus",
+  taskBlocked: null,
+  modelsError: null,
+  ...over,
+});
+
+describe("usableAgent", () => {
+  const catalog: MachineCatalog = {
+    agents: [
+      agent({ agent: "codex", installed: false }),
+      agent({ agent: "opencode", defaultModel: "default" }),
+      agent({ agent: "claude", auth: "needs-login" }),
+    ],
+    ollama: [],
+  };
+
+  it("keeps an agent the machine can run", () => {
+    expect(usableAgent(catalog, "opencode")).toBeNull();
+  });
+
+  it("moves to the first agent that is installed and signed in", () => {
+    expect(usableAgent(catalog, "codex")?.agent).toBe("opencode");
+    expect(usableAgent(catalog, "claude")?.agent).toBe("opencode");
+    expect(usableAgent(catalog, "aider")?.agent).toBe("opencode");
+  });
+
+  it("names what blocks an agent", () => {
+    expect(catalogBlocker(catalog.agents[0])).toBe("Not installed");
+    expect(catalogBlocker(catalog.agents[2])).toBe("Needs sign-in");
+    expect(catalogBlocker(catalog.agents[1])).toBeNull();
+  });
+});

package/components/Draft/AgentModelChip.tsx

@@ -0,0 +1,162 @@
+"use client";
+
+import { useEffect } from "react";
+import { Bot } from "lucide-react";
+import type { Draft } from "@/lib/drafts";
+import { AGENT_OPTIONS, agentLabel } from "@/lib/agent-options";
+import { resolveModelForAgent } from "@/lib/model-catalog";
+import { useMachineCatalog } from "@/data/machines";
+import type { CatalogAgent, MachineCatalog } from "@/lib/machines/types";
+import { ChipHeading, ChipItem, ChipMenu } from "./Chip";
+
+// What stands between an agent and its first prompt, if anything.
+export function catalogBlocker(a: CatalogAgent): string | null {
+  if (!a.installed) return "Not installed";
+  if (a.auth === "needs-login") return a.hint ?? "Needs sign-in";
+  return null;
+}
+
+/** The agent to use when the one chosen can't run on this machine. */
+export function usableAgent(
+  catalog: MachineCatalog,
+  agentType: Draft["agentType"]
+): CatalogAgent | null {
+  const have = catalog.agents.find((a) => a.agent === agentType);
+  if (have && !catalogBlocker(have)) return null;
+  return catalog.agents.find((a) => !catalogBlocker(a)) ?? null;
+}
+
+/**
+ * The agent and its model in one menu, grouped by agent, from what the
+ * machine the session will run on reports. A local Ollama model picks the
+ * agent that can run it.
+ */
+export function AgentModelChip({
+  draft,
+  onChange,
+}: {
+  draft: Draft;
+  onChange: (patch: Partial<Draft>) => void;
+}) {
+  const { data, isPending } = useMachineCatalog(draft.hostId);
+  const catalog = data?.catalog ?? null;
+
+  // The machine changed under the draft: move to an agent it has.
+  useEffect(() => {
+    if (!catalog) return;
+    const other = usableAgent(catalog, draft.agentType);
+    if (other) onChange({ agentType: other.agent, model: other.defaultModel });
+    else {
+      const mine = catalog.agents.find((a) => a.agent === draft.agentType);
+      if (
+        mine &&
+        !mine.modelsError &&
+        !mine.models.some((m) => m.value === draft.model)
+      )
+        onChange({ model: mine.defaultModel });
+    }
+  }, [catalog, draft.agentType, draft.model, onChange]);
+
+  const current = catalog?.agents.find((a) => a.agent === draft.agentType);
+  const model = current?.models.find((m) => m.value === draft.model);
+  const label =
+    model && draft.model !== current?.defaultModel
+      ? `${agentLabel(draft.agentType)} · ${model.label}`
+      : agentLabel(draft.agentType);
+
+  const blocker = current ? catalogBlocker(current) : null;
+
+  return (
+    <>
+      <ChipMenu icon={Bot} name="Agent" label={label}>
+        {!catalog &&
+          AGENT_OPTIONS.map((o) => (
+            <ChipItem
+              key={o.value}
+              checked={o.value === draft.agentType}
+              hint={
+                isPending
+                  ? "Checking the machine…"
+                  : (data?.error ?? "Couldn't check the machine")
+              }
+              onSelect={() =>
+                onChange({
+                  agentType: o.value,
+                  model: resolveModelForAgent(o.value, draft.model),
+                })
+              }
+            >
+              {o.label}
+            </ChipItem>
+          ))}
+        {catalog?.agents.map((a, i) => {
+          const blocked = catalogBlocker(a);
+          return (
+            <div key={a.agent}>
+              <ChipHeading first={i === 0}>
+                {a.label}
+                {blocked ? ` · ${blocked}` : ""}
+              </ChipHeading>
+              {a.models.map((m) => (
+                <ChipItem
+                  key={m.value}
+                  checked={
+                    a.agent === draft.agentType && m.value === draft.model
+                  }
+                  disabled={!!blocked}
+                  hint={m.description}
+                  onSelect={() =>
+                    onChange({ agentType: a.agent, model: m.value })
+                  }
+                >
+                  {m.label}
+                </ChipItem>
+              ))}
+              {a.modelsError && (
+                <p className="text-muted-foreground px-2 py-1 text-xs">
+                  Couldn&apos;t list its models: {a.modelsError}
+                </p>
+              )}
+            </div>
+          );
+        })}
+        {catalog && catalog.ollama.length > 0 && (
+          <div>
+            <ChipHeading>Ollama (local models)</ChipHeading>
+            {catalog.ollama.map((o) => (
+              <ChipItem
+                key={o.name}
+                checked={
+                  !!o.runsWith &&
+                  o.runsWith.agent === draft.agentType &&
+                  o.runsWith.model === draft.model
+                }
+                disabled={!o.runsWith}
+                hint={
+                  o.runsWith
+                    ? `Runs in ${agentLabel(o.runsWith.agent)}`
+                    : "No agent here is set up to run it"
+                }
+                onSelect={() =>
+                  o.runsWith &&
+                  onChange({
+                    agentType: o.runsWith.agent,
+                    model: o.runsWith.model,
+                  })
+                }
+              >
+                {o.name}
+              </ChipItem>
+            ))}
+          </div>
+        )}
+      </ChipMenu>
+      {blocker && (
+        <p className="w-full text-xs text-amber-600 dark:text-amber-400">
+          {blocker}
+          {current?.hint && blocker !== current.hint ? `: ${current.hint}` : ""}
+        </p>
+      )}
+    </>
+  );
+}

package/components/Draft/Chip.tsx

@@ -90,10 +90,17 @@ export function ChipItem({
   );
 }
 
-export function ChipHeading({ children }: { children: React.ReactNode }) {
+export function ChipHeading({
+  children,
+  first,
+}: {
+  children: React.ReactNode;
+  // The top of the menu: nothing above it to separate from.
+  first?: boolean;
+}) {
   return (
     <>
-      <DropdownMenuSeparator />
+      {!first && <DropdownMenuSeparator />}
       <DropdownMenuLabel className="text-muted-foreground text-[11px] font-medium">
         {children}
       </DropdownMenuLabel>

package/components/Draft/DraftChips.tsx

@@ -2,7 +2,6 @@
 
 import { useEffect } from "react";
 import {
-  Bot,
   Cpu,
   Eye,
   FolderGit2,
@@ -15,14 +14,13 @@ import {
 import type { Host } from "@/lib/db";
 import type { Project } from "@/lib/db";
 import { draftHostGone, newDraft, type Draft } from "@/lib/drafts";
-import { AGENT_OPTIONS, agentLabel } from "@/lib/agent-options";
-import { resolveModelForAgent } from "@/lib/model-catalog";
 import type { GitCheck } from "@/data/git/queries";
-import { useAgentStatusQuery } from "@/data/agents";
 import { useProjectMachinesQuery } from "@/data/projects";
 import { modelChoices, useModelsQuery } from "@/data/models";
-import type { AgentProbe } from "@/lib/agents/probe";
+import { useBrowserMachine } from "@/data/machines";
+import { machineLabel } from "@/lib/machines/label";
 import { RoleChips } from "./RoleChips";
+import { AgentModelChip } from "./AgentModelChip";
 import { ChipHeading, ChipItem, ChipMenu, ChipToggle } from "./Chip";
 import {
   DEFAULT_PRIORITY,
@@ -31,14 +29,6 @@ import {
   PRIORITY_LABEL,
 } from "@/lib/tasks/schedule-types";
 
-// What stands between an agent and its first prompt, if anything.
-export function agentBlocker(probe?: AgentProbe): string | null {
-  if (!probe) return null;
-  if (!probe.installed) return "Not installed";
-  if (probe.auth === "needs-login") return "Needs sign-in";
-  return null;
-}
-
 const BRANCHES_SHOWN = 20;
 
 // A draft's choices, above its composer: where it runs and how.
@@ -58,6 +48,7 @@ export function DraftChips({
   git: GitCheck | undefined;
   onChange: (patch: Partial<Draft>) => void;
 }) {
+  const browser = useBrowserMachine();
   const real = projects.filter((p) => !p.is_uncategorized);
   const project = real.find((p) => p.id === draft.projectId) ?? null;
   const projectHere = !!project && (project.host_id || "local") === "local";
@@ -70,10 +61,6 @@ export function DraftChips({
       : hosts;
   const host = hosts.find((h) => h.id === draft.hostId);
   const local = draft.hostId === "local";
-  // Which agents are installed and signed in, on this machine: a draft for
-  // another machine shows them all.
-  const { data: localProbes } = useAgentStatusQuery();
-  const probes = local ? localProbes : undefined;
   const base = draft.baseBranch ?? git?.defaultBranch ?? "main";
   const { data: models } = useModelsQuery(draft.openPr);
   // A project elsewhere runs where it lives; a scratch chat, a task or a
@@ -147,7 +134,7 @@ export function DraftChips({
         <ChipMenu
           icon={Monitor}
           name="Machine"
-          label={host?.name ?? draft.hostId}
+          label={host ? machineLabel(host) : draft.hostId}
           disabled={!canMove}
           title={canMove ? undefined : "Runs where the project lives"}
         >
@@ -164,31 +151,14 @@ export function DraftChips({
                 })
               }
             >
-              {h.name}
+              {machineLabel(h, browser.hostId)}
             </ChipItem>
           ))}
         </ChipMenu>
       )}
 
       {!draft.openPr && !draft.agentRole && (
-        <ChipMenu icon={Bot} name="Agent" label={agentLabel(draft.agentType)}>
-          {AGENT_OPTIONS.map((o) => (
-            <ChipItem
-              key={o.value}
-              checked={o.value === draft.agentType}
-              disabled={probes?.[o.value] ? !probes[o.value].installed : false}
-              hint={agentBlocker(probes?.[o.value]) ?? undefined}
-              onSelect={() =>
-                onChange({
-                  agentType: o.value,
-                  model: resolveModelForAgent(o.value, draft.model),
-                })
-              }
-            >
-              {o.label}
-            </ChipItem>
-          ))}
-        </ChipMenu>
+        <AgentModelChip draft={draft} onChange={onChange} />
       )}
 
       {!draft.openPr && local && (
@@ -314,14 +284,6 @@ export function DraftChips({
           onChange={(terminal) => onChange({ terminal })}
         />
       )}
-      {!draft.openPr && agentBlocker(probes?.[draft.agentType]) && (
-        <p className="w-full text-xs text-amber-600 dark:text-amber-400">
-          {agentBlocker(probes?.[draft.agentType])}
-          {probes?.[draft.agentType]?.hint
-            ? `: ${probes[draft.agentType].hint}`
-            : ""}
-        </p>
-      )}
     </div>
   );
 }

package/components/Draft/DraftPanel.tsx

@@ -27,6 +27,7 @@ import { useStartAnalystBeside } from "@/components/Analyst/pair";
 import { DraftChips } from "./DraftChips";
 import { DraftHeading } from "./DraftHeading";
 import { ModelUnavailableDialog } from "./ModelUnavailableDialog";
+import { useMachineCatalog } from "@/data/machines";
 import { draftModels } from "./draftModels";
 
 // A new session before its first send: choices on top, a composer below.
@@ -57,6 +58,8 @@ export function DraftPanel({
     draft?.projectId ?? null,
     discovers
   );
+  // On another machine the models are the ones it reports, not this one's.
+  const there = useMachineCatalog(draft?.hostId ?? "local");
   const launch = useLaunchSession();
   const startAnalyst = useStartAnalystBeside();
   const { workspace } = useSelectedWorkspace();
@@ -253,7 +256,13 @@ export function DraftPanel({
           }
           onSend={(text, images, files) => void send(text, images, files)}
           onStop={() => {}}
-          models={draftModels(draft.agentType, found)}
+          models={
+            (draft.hostId !== "local" &&
+              there.data?.catalog?.agents.find(
+                (a) => a.agent === draft.agentType
+              )?.models) ||
+            draftModels(draft.agentType, found)
+          }
           model={draft.model}
           onSetModel={(model) => draftsActions.update(draft.id, { model })}
           access={draft.openPr ? undefined : draft.access}

package/components/Hosts/AccountMachines.tsx

@@ -55,7 +55,9 @@ function MachineRow({
       </div>
       {linked ? (
         <span className="text-xs font-medium text-emerald-600 dark:text-emerald-400">
-          Linked
+          {machine.linkedVia === "tailscale"
+            ? "Linked over Tailscale"
+            : "Linked"}
         </span>
       ) : machine.linkState === "suspended" ? (
         <span

package/components/Hosts/HostRow.tsx

@@ -11,15 +11,20 @@ import {
   PlugZap,
   Loader2,
   Link2,
+  MapPin,
+  Pencil,
   Unlink,
 } from "lucide-react";
 import { Notice } from "@/components/ui/notice";
 import type { Host } from "@/lib/db";
 import { useDeleteHost, useLinkHost, useTestHost } from "@/data/hosts";
+import { useBrowserMachine } from "@/data/machines";
+import { machineDetail, machineLabel } from "@/lib/machines/label";
 import { useUnlinkPeer } from "@/data/peers";
 import { NEEDS_PRO, UPGRADE_URL } from "@/lib/peer/reasons";
 import { cn } from "@/lib/utils";
 import { PeerActivitySheet } from "./PeerActivitySheet";
+import { RenameHost } from "./RenameHost";
 
 function connectLine(host: Host): string {
   if (host.peer_state === "active")
@@ -67,6 +72,9 @@ export function HostRow({ host }: { host: Host }) {
   const unlink = useUnlinkPeer();
   const [activity, setActivity] = useState(false);
   const [confirmUnlink, setConfirmUnlink] = useState(false);
+  const [renaming, setRenaming] = useState(false);
+  const browser = useBrowserMachine();
+  const here = browser.hostId === host.id;
   const isLocal = host.id === "local";
   const viaConnect = host.kind === "connect";
   const pinned =
@@ -80,17 +88,58 @@ export function HostRow({ host }: { host: Host }) {
       <div className="flex items-center gap-3">
         <Icon className="text-muted-foreground h-4 w-4 shrink-0" />
         <div className="min-w-0 flex-1">
-          <p className="truncate text-sm font-medium">{host.name}</p>
+          <p className="truncate text-sm font-medium">
+            {machineLabel(host, browser.hostId)}
+          </p>
           <p className="text-muted-foreground truncate text-xs">
             {isLocal
-              ? "Where agent-os is running"
-              : viaConnect
-                ? connectLine(host)
-                : host.linked
-                  ? `${host.ssh_target} · tasks run on its AgentOS`
-                  : host.ssh_target}
+              ? [machineDetail(host), "serves this dashboard"]
+                  .filter(Boolean)
+                  .join(" · ")
+              : [
+                  machineDetail(host),
+                  viaConnect
+                    ? connectLine(host)
+                    : host.linked
+                      ? `${host.ssh_target} · tasks run on its AgentOS`
+                      : host.ssh_target,
+                ]
+                  .filter(Boolean)
+                  .join(" · ")}
           </p>
         </div>
+        <Button
+          variant="ghost"
+          size="icon-sm"
+          className="h-11 w-11 sm:h-8 sm:w-8"
+          onClick={() => setRenaming(true)}
+          disabled={renaming}
+          aria-label={`Rename ${host.name}`}
+          title="Give it a name of your own"
+        >
+          <Pencil className="h-4 w-4" />
+        </Button>
+        <Button
+          variant="ghost"
+          size="icon-sm"
+          className={cn("h-11 w-11 sm:h-8 sm:w-8", here && "text-primary")}
+          aria-pressed={here}
+          onClick={() => browser.set(here ? null : host.id)}
+          aria-label={
+            here
+              ? `This browser is not on ${host.name}`
+              : `This browser is on ${host.name}`
+          }
+          title={
+            here
+              ? browser.detected
+                ? "Detected from the connection. Tap to say otherwise"
+                : "You said you're here. Tap to undo"
+              : "Say this is the machine you're using now"
+          }
+        >
+          <MapPin className="h-4 w-4" />
+        </Button>
         {!isLocal && (
           <>
             {!viaConnect && (
@@ -171,6 +220,7 @@ export function HostRow({ host }: { host: Host }) {
           </>
         )}
       </div>
+      {renaming && <RenameHost host={host} onDone={() => setRenaming(false)} />}
       {result && (
         <p
           className={cn(