@saadnvd1/agent-os 0.3.736 → 0.3.738

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/Chat/ChatPanel.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import type { StepCounts } from "@/lib/chat/tool-outcome";
 import {
   memo,
   useCallback,
@@ -99,7 +100,15 @@ interface ItemActions {
   onQuote?: (text: string) => void;
 }
 
-function Item({ item, actions }: { item: ChatItem; actions: ItemActions }) {
+function Item({
+  item,
+  actions,
+  steps,
+}: {
+  item: ChatItem;
+  actions: ItemActions;
+  steps?: StepCounts;
+}) {
   switch (item.kind) {
     case "user":
       return (
@@ -119,7 +128,7 @@ function Item({ item, actions }: { item: ChatItem; actions: ItemActions }) {
     case "todos":
       return <Todos item={item} />;
     case "turn_end":
-      return <TurnEnd item={item} />;
+      return <TurnEnd item={item} steps={steps} />;
     case "error":
       return <ErrorMessage item={item} />;
     case "command_output":
@@ -209,7 +218,7 @@ const Block = memo(
       </UndoneBlock>
     ) : (
       <div data-item={b.item.id}>
-        <Item item={b.item} actions={actions} />
+        <Item item={b.item} actions={actions} steps={b.steps} />
       </div>
     );
   },

package/components/Chat/Messages.test.ts

@@ -1,7 +1,7 @@
 import { createElement } from "react";
 import { renderToStaticMarkup } from "react-dom/server";
 import { describe, expect, it, vi } from "vitest";
-import { AssistantMessage, UserMessage } from "./Messages";
+import { AssistantMessage, TurnEnd, UserMessage } from "./Messages";
 
 const item = {
   id: "a1",
@@ -119,3 +119,15 @@ describe("UserMessage code blocks", () => {
     }
   });
 });
+
+describe("TurnEnd steps", () => {
+  it("says what a stopped turn got through", () => {
+    const html = renderToStaticMarkup(
+      createElement(TurnEnd, {
+        item: { id: "e", kind: "turn_end", interrupted: true } as never,
+        steps: { total: 5, ok: 3, failed: 1, stopped: 1, running: 0 },
+      })
+    );
+    expect(html).toContain("Stopped · 4 of 5 steps done, 1 failed, 1 not run");
+  });
+});

package/components/Chat/Messages.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import type { StepCounts } from "@/lib/chat/tool-outcome";
 import { memo } from "react";
 import { useSnapshot } from "valtio";
 import {
@@ -378,7 +379,23 @@ export function Todos({ item }: { item: Of<"todos"> }) {
   );
 }
 
-export function TurnEnd({ item }: { item: Of<"turn_end"> }) {
+// What a stopped or failed turn got through.
+export function stepsLabel(s: StepCounts): string {
+  const done = s.ok + s.failed;
+  const parts = [`${done} of ${s.total} steps done`];
+  if (s.failed) parts.push(`${s.failed} failed`);
+  const unfinished = s.stopped + s.running;
+  if (unfinished) parts.push(`${unfinished} not run`);
+  return parts.join(", ");
+}
+
+export function TurnEnd({
+  item,
+  steps,
+}: {
+  item: Of<"turn_end">;
+  steps?: StepCounts;
+}) {
   const secs = item.durationMs ? Math.round(item.durationMs / 1000) : null;
   const early = !item.interrupted && item.ended;
   const label = item.interrupted
@@ -407,7 +424,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}
+        {steps ? `${label} · ${stepsLabel(steps)}` : label}
         <TurnCopy turnEndId={item.id} />
         <TurnBookmark turnEndId={item.id} />
         <span className="bg-foreground/[0.06] h-px flex-1" />

package/components/Chat/StepOutcomes.tsx

@@ -0,0 +1,66 @@
+"use client";
+
+import type { ToolItem } from "@/lib/chat/group";
+import { toolOutcome } from "@/lib/chat/tool-outcome";
+import { cn } from "@/lib/utils";
+import { StatusIcon } from "./Tools";
+
+export const MAX_CHIPS = 24;
+
+const WORD = {
+  running: "running",
+  done: "ok",
+  error: "failed",
+  stopped: "not run",
+} as const;
+
+// One line per collapsed group: how each step ended, so the results aren't
+// lost behind the fold.
+export function StepOutcomes({
+  tools,
+  onOpen,
+}: {
+  tools: ToolItem[];
+  onOpen: () => void;
+}) {
+  const shown = tools.slice(0, MAX_CHIPS);
+  return (
+    <button
+      type="button"
+      onClick={onOpen}
+      aria-label="Show steps"
+      className="flex min-h-11 w-full flex-wrap items-center gap-x-3 gap-y-1 px-2 pb-1.5 text-left md:min-h-0"
+    >
+      {shown.map((t) => {
+        const code = toolOutcome(t);
+        return (
+          <span
+            key={t.id}
+            title={`${t.title}: ${WORD[t.status]}${code ? `, ${code}` : ""}`}
+            aria-label={`${t.title}: ${WORD[t.status]}${code ? `, ${code}` : ""}`}
+            className="flex min-w-0 items-center gap-1"
+          >
+            <StatusIcon status={t.status} />
+            {code && (
+              <span
+                className={cn(
+                  "font-mono text-[11px]",
+                  t.status === "error"
+                    ? "text-destructive"
+                    : "text-muted-foreground"
+                )}
+              >
+                {code}
+              </span>
+            )}
+          </span>
+        );
+      })}
+      {tools.length > shown.length && (
+        <span className="text-muted-foreground/70 font-mono text-[11px]">
+          +{tools.length - shown.length} more
+        </span>
+      )}
+    </button>
+  );
+}

package/components/Chat/Tools.test.ts

@@ -0,0 +1,52 @@
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, it } from "vitest";
+import type { ToolItem } from "@/lib/chat/group";
+import { MAX_CHIPS } from "./StepOutcomes";
+import { ToolGroup } from "./Tools";
+
+const tool = (id: string, over: Partial<ToolItem> = {}): ToolItem => ({
+  id,
+  kind: "tool",
+  name: "Bash",
+  title: `check ${id}`,
+  input: {},
+  status: "done",
+  createdAt: 0,
+  ...over,
+});
+
+const render = (tools: ToolItem[]) =>
+  renderToStaticMarkup(createElement(ToolGroup, { tools }));
+
+describe("collapsed ToolGroup", () => {
+  it("keeps each step's outcome in view", () => {
+    const html = render([
+      tool("a", { output: "HTTP/2 200 \n" }),
+      tool("b", { status: "error", output: "Exit code 7" }),
+      tool("c", { status: "error", deferred: true, outcome: "HTTP 404" }),
+      tool("d", { status: "stopped" }),
+    ]);
+    expect(html).toContain("4 steps");
+    expect(html).toContain("1 ok");
+    expect(html).toContain("2 failed");
+    expect(html).toContain("1 not run");
+    expect(html).toContain("check a: ok, HTTP 200");
+    expect(html).toContain("check b: failed, exit 7");
+    expect(html).toContain("check c: failed, HTTP 404");
+    expect(html).toContain("check d: not run");
+  });
+
+  it("shows no strip while a step runs", () => {
+    expect(render([tool("a", { status: "running" })])).not.toContain(
+      "Show steps"
+    );
+  });
+
+  it("caps the strip", () => {
+    const tools = Array.from({ length: MAX_CHIPS + 3 }, (_, i) =>
+      tool(`x${i}`)
+    );
+    expect(render(tools)).toContain("+3 more");
+  });
+});

package/components/Chat/Tools.tsx

@@ -8,6 +8,8 @@ import { lineDiff, shortPath, type DiffLine } from "@/lib/chat/diff";
 import { needsBody } from "@/lib/chat/bodyCache";
 import { cn } from "@/lib/utils";
 import { formatElapsed } from "@/lib/chat/elapsed";
+import { stepCounts, toolOutcome } from "@/lib/chat/tool-outcome";
+import { StepOutcomes } from "./StepOutcomes";
 import { Highlighted } from "./Code";
 import { BackgroundButton, BackgroundState, useBackground } from "./background";
 import { useNow } from "./useNow";
@@ -163,6 +165,18 @@ function ToolRow({ tool }: { tool: ToolItem }) {
           <span className="min-w-0 flex-1 truncate font-mono text-xs">
             {tool.title}
           </span>
+          {toolOutcome(tool) && (
+            <span
+              className={cn(
+                "shrink-0 font-mono text-[11px]",
+                tool.status === "error"
+                  ? "text-destructive"
+                  : "text-muted-foreground"
+              )}
+            >
+              {toolOutcome(tool)}
+            </span>
+          )}
           {tool.backgroundTaskId ? (
             <BackgroundState tool={tool} />
           ) : (
@@ -180,8 +194,7 @@ function ToolRow({ tool }: { tool: ToolItem }) {
 // A run of tool calls: one quiet line, expandable to every step.
 export function ToolGroup({ tools }: { tools: ToolItem[] }) {
   const running = tools.some((t) => t.status === "running");
-  const failed = tools.filter((t) => t.status === "error").length;
-  const stopped = tools.filter((t) => t.status === "stopped").length;
+  const { ok, failed, stopped } = stepCounts(tools);
   const edits = tools.filter((t) => t.diff || t.hasDiff).length;
   const moved = tools.filter((t) => t.backgroundTaskId).length;
   const [open, setOpen] = useRowState(`steps:${tools[0].id}`, false);
@@ -211,13 +224,14 @@ export function ToolGroup({ tools }: { tools: ToolItem[] }) {
             {!running &&
               edits > 0 &&
               ` · ${edits} edit${edits === 1 ? "" : "s"}`}
+            {!running && (failed > 0 || stopped > 0) && ` · ${ok} ok`}
           </span>
           {running && <Elapsed tool={latest} />}
           {failed > 0 && (
             <span className="text-destructive">{failed} failed</span>
           )}
-          {stopped > 0 && failed === 0 && (
-            <span className="text-muted-foreground/70">stopped</span>
+          {stopped > 0 && (
+            <span className="text-muted-foreground/70">{stopped} not run</span>
           )}
           {!running && moved > 0 && (
             <span className="text-muted-foreground/70">
@@ -227,6 +241,9 @@ export function ToolGroup({ tools }: { tools: ToolItem[] }) {
         </button>
         {running && <BackgroundButton tool={latest} />}
       </div>
+      {!open && !running && (
+        <StepOutcomes tools={tools} onOpen={() => setOpen(true)} />
+      )}
       {open && (
         <div className="pb-1">
           {tools.map((t) => (

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>
+      )}
+    </>
+  );
+}