@saadnvd1/agent-os 0.3.735 → 0.3.737

package/components/Hosts/RenameHost.tsx

@@ -0,0 +1,59 @@
+"use client";
+
+import { useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import type { Host } from "@/lib/db";
+import { useRenameHost } from "@/data/hosts";
+
+/** A name of the person's own for a machine, shown on every screen. */
+export function RenameHost({
+  host,
+  onDone,
+}: {
+  host: Host;
+  onDone: () => void;
+}) {
+  const rename = useRenameHost();
+  const [name, setName] = useState(host.name);
+  const save = () =>
+    rename.mutate({ id: host.id, name }, { onSuccess: onDone });
+  return (
+    <form
+      className="mt-2 flex flex-wrap items-center gap-2"
+      onSubmit={(e) => {
+        e.preventDefault();
+        save();
+      }}
+    >
+      <Input
+        value={name}
+        onChange={(e) => setName(e.target.value)}
+        aria-label={`Name for ${host.name}`}
+        maxLength={60}
+        autoFocus
+        className="h-11 min-w-0 flex-1 sm:h-9"
+      />
+      <Button
+        type="submit"
+        className="min-h-11 sm:min-h-9"
+        disabled={rename.isPending || !name.trim()}
+      >
+        Save
+      </Button>
+      <Button
+        type="button"
+        variant="ghost"
+        className="min-h-11 sm:min-h-9"
+        onClick={onDone}
+      >
+        Cancel
+      </Button>
+      {rename.error && (
+        <p className="text-destructive w-full text-xs">
+          {rename.error.message}
+        </p>
+      )}
+    </form>
+  );
+}

package/components/SessionList/MachineSwitcher.tsx

@@ -0,0 +1,67 @@
+"use client";
+
+import { useEffect } from "react";
+import { useSnapshot } from "valtio";
+import { Check, ChevronDown, Monitor } from "lucide-react";
+import * as DM from "@/components/ui/dropdown-menu";
+import { useHostsQuery } from "@/data/hosts";
+import { useBrowserMachine } from "@/data/machines";
+import { machineLabel } from "@/lib/machines/label";
+import { machinesUi, machinesUiActions } from "@/stores/machines";
+import { cn } from "@/lib/utils";
+
+// A quick way between the machines linked here: narrows the sidebar to one
+// machine's sessions and starts new chats there. Hidden until one is linked.
+export function MachineSwitcher() {
+  const { data: hosts = [], isSuccess } = useHostsQuery();
+  const { scopeHostId } = useSnapshot(machinesUi);
+  const browser = useBrowserMachine();
+  const machines = hosts.filter((h) => h.id === "local" || h.linked);
+  const current = machines.find((h) => h.id === scopeHostId) ?? null;
+
+  // A machine that was unlinked since goes back to all of them.
+  useEffect(() => {
+    if (isSuccess && scopeHostId && !current) machinesUiActions.setScope(null);
+  }, [isSuccess, scopeHostId, current]);
+
+  if (machines.length < 2) return null;
+  return (
+    <DM.DropdownMenu>
+      <DM.DropdownMenuTrigger asChild>
+        <button
+          type="button"
+          aria-label={`Machine: ${current ? machineLabel(current) : "All machines"}`}
+          className={cn(
+            "border-border/70 text-muted-foreground hover:text-foreground hover:bg-foreground/[0.04] flex h-11 max-w-full min-w-0 items-center gap-1.5 rounded-lg border px-2.5 text-xs md:h-8",
+            current && "border-primary/40 bg-primary/10 text-primary"
+          )}
+        >
+          <Monitor className="h-3.5 w-3.5 shrink-0" />
+          <span className="truncate">
+            {current ? machineLabel(current) : "All machines"}
+          </span>
+          <ChevronDown className="h-3 w-3 shrink-0" />
+        </button>
+      </DM.DropdownMenuTrigger>
+      <DM.DropdownMenuContent align="start" className="max-w-80">
+        <DM.DropdownMenuLabel className="text-muted-foreground text-xs font-normal">
+          Machine
+        </DM.DropdownMenuLabel>
+        {[null, ...machines].map((h) => (
+          <DM.DropdownMenuItem
+            key={h?.id ?? "all"}
+            className="min-h-11 md:min-h-8"
+            onClick={() => machinesUiActions.setScope(h?.id ?? null)}
+          >
+            <span className="flex-1 truncate">
+              {h ? machineLabel(h, browser.hostId) : "All machines"}
+            </span>
+            {(current?.id ?? null) === (h?.id ?? null) && (
+              <Check className="text-primary h-3.5 w-3.5" />
+            )}
+          </DM.DropdownMenuItem>
+        ))}
+      </DM.DropdownMenuContent>
+    </DM.DropdownMenu>
+  );
+}

package/components/SessionList/SidebarHeader.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { MachineSwitcher } from "./MachineSwitcher";
 import {
   Archive,
   Star,
@@ -189,6 +190,9 @@ export function SidebarHeader(props: SidebarHeaderProps) {
           ]}
         />
       </div>
+      <div className="w-full empty:hidden">
+        <MachineSwitcher />
+      </div>
     </div>
   );
 }

package/components/SessionList/useSidebarData.ts

@@ -1,6 +1,6 @@
 "use client";
 
-import { useCallback, useMemo } from "react";
+import { useCallback, useEffect, useMemo } from "react";
 import { useSnapshot } from "valtio";
 import type { Session } from "@/lib/db";
 import type { SessionGroup } from "@/lib/sidebar/shelves";
@@ -11,7 +11,11 @@ import {
   projectsInWorkspace,
 } from "@/lib/sidebar/shelves";
 import type { TaskState } from "@/lib/tasks/state";
-import { machineGroups, onMachineOnly } from "@/lib/sidebar/machines";
+import {
+  inMachineScope,
+  machineGroups,
+  onMachineOnly,
+} from "@/lib/sidebar/machines";
 import { orchestratorsToStart } from "@/lib/sidebar/orchestrator-row";
 import { useSessionsQuery } from "@/data/sessions";
 import { useLinkedHostNames } from "@/data/hosts";
@@ -23,6 +27,7 @@ import { useSelectedWorkspace } from "@/hooks/useSelectedWorkspace";
 import { useOrchestratorsQuery } from "@/data/orchestrators";
 import { useClock } from "@/hooks/useMinuteTick";
 import { sidebarUi } from "@/stores/sidebarUi";
+import { machinesUi, machinesUiActions } from "@/stores/machines";
 import type { SessionStatus } from "./SessionList.types";
 
 // One empty list for queries still loading, so memos below hold.
@@ -35,6 +40,10 @@ export function useSidebarData(
   sessionStatuses: Record<string, SessionStatus> | undefined
 ) {
   const ui = useSnapshot(sidebarUi);
+  const scope = useSnapshot(machinesUi).scopeHostId;
+  useEffect(() => {
+    machinesUiActions.hydrate();
+  }, []);
   // Wakes and 3-day settles are read from the clock.
   const now = useClock();
 
@@ -98,6 +107,7 @@ export function useSidebarData(
       sessions: sessions.filter(
         (s) =>
           !onMachineOnly(s, linked) &&
+          inMachineScope(s, scope) &&
           inWorkspace(
             s,
             (id) => byId.get(id)?.workspace_id,
@@ -122,7 +132,14 @@ export function useSidebarData(
       machines:
         project || ui.orchestratorId
           ? []
-          : machineGroups({ ...common, sessions }, linked),
+          : machineGroups(
+              { ...common, sessions },
+              scope
+                ? Object.fromEntries(
+                    Object.entries(linked).filter(([id]) => id === scope)
+                  )
+                : linked
+            ),
     };
   }, [
     now,
@@ -138,6 +155,7 @@ export function useSidebarData(
     project,
     ui.query,
     ui.orchestratorId,
+    scope,
   ]);
 
   // Per workspace, how many of its project sessions are working: the

package/data/hosts/queries.ts

@@ -61,6 +61,23 @@ export function useDeleteHost() {
   });
 }
 
+/** Rename a machine; "local" renames this one. */
+export function useRenameHost() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ id, name }: { id: string; name: string }) =>
+      json<{ name: string }>(
+        await fetch(`/api/hosts/${encodeURIComponent(id)}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ name }),
+        })
+      ),
+    // The name is on the claims, the sidebar and the chips too.
+    onSuccess: () => queryClient.invalidateQueries(),
+  });
+}
+
 export interface HostTestResult {
   ok: boolean;
   hostname?: string;

package/data/machines/index.ts

@@ -0,0 +1,54 @@
+import { useEffect } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { useSnapshot } from "valtio";
+import { machinesUi, machinesUiActions } from "@/stores/machines";
+import type { HostCatalogResponse } from "@/lib/machines/types";
+import type { BrowserMachine } from "@/lib/machines/browser";
+import { machineKeys } from "./keys";
+
+/** The agents and models a machine reports, for the new-session form. */
+export function useMachineCatalog(hostId: string) {
+  return useQuery({
+    queryKey: machineKeys.agents(hostId),
+    queryFn: async () => {
+      const res = await fetch(
+        `/api/hosts/${encodeURIComponent(hostId)}/agents`
+      );
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok) throw new Error(data.error || "Couldn't list its agents");
+      return data as HostCatalogResponse;
+    },
+    staleTime: 60_000,
+    retry: false,
+  });
+}
+
+/**
+ * The machine this browser is on: what the person set, else what the server
+ * could tell from the connection, else unknown.
+ */
+export function useBrowserMachine(): {
+  hostId: string | null;
+  detected: BrowserMachine["how"];
+  set: (hostId: string | null) => void;
+} {
+  const snap = useSnapshot(machinesUi);
+  useEffect(() => {
+    machinesUiActions.hydrate();
+  }, []);
+  const { data } = useQuery({
+    queryKey: machineKeys.browser(),
+    queryFn: async () => {
+      const res = await fetch("/api/machine/browser");
+      if (!res.ok) throw new Error("Couldn't tell");
+      return (await res.json()) as BrowserMachine;
+    },
+    staleTime: Infinity,
+    retry: false,
+  });
+  return {
+    hostId: snap.browserHostId ?? data?.hostId ?? null,
+    detected: data?.how ?? null,
+    set: machinesUiActions.setBrowserHost,
+  };
+}

package/data/machines/keys.ts

@@ -0,0 +1,5 @@
+export const machineKeys = {
+  all: ["machines"] as const,
+  agents: (hostId: string) => [...machineKeys.all, "agents", hostId] as const,
+  browser: () => [...machineKeys.all, "browser"] as const,
+};

package/hooks/useDraftRequests.ts

@@ -1,5 +1,6 @@
 "use client";
 
+import { machinesUi } from "@/stores/machines";
 import { useEffect, useRef } from "react";
 import { subscribe } from "valtio";
 import { FolderGit2 } from "lucide-react";
@@ -64,7 +65,11 @@ export function useDraftRequests(options: Options) {
           ? { agentType: s.agent_type, model: s.model, access: s.chat_access }
           : {};
       const project = projects.find((p) => p.id === projectId) ?? null;
-      const draft = makeDraft(uuid(), project, carry, { openPr, workspaceId });
+      const draft = makeDraft(uuid(), project, carry, {
+        openPr,
+        workspaceId,
+        hostId: openPr ? null : machinesUi.scopeHostId,
+      });
       draftsActions.put(draft);
       show(draft.id);
     };

package/lib/db/migrations/20261023T1200_host_info.ts

@@ -0,0 +1,20 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261023T1200_host_info",
+  up: (db) => {
+    // What a linked machine says about itself (GET /api/machine), kept so its
+    // name, OS and addresses show while it is offline. Foreign keys aren't
+    // enforced here, so deleteHost removes the row.
+    db.exec(`CREATE TABLE IF NOT EXISTS host_info (
+      host_id TEXT PRIMARY KEY REFERENCES hosts(id) ON DELETE CASCADE,
+      name TEXT,
+      hostname TEXT,
+      os TEXT,
+      arch TEXT,
+      connect_machine_id TEXT,
+      addresses TEXT NOT NULL DEFAULT '[]',
+      fetched_at INTEGER NOT NULL DEFAULT 0
+    )`);
+  },
+} satisfies Migration;

package/lib/db/types.ts

@@ -325,4 +325,8 @@ export interface Host {
   // who unlinked it.
   peer_state?: "active" | "suspended" | "unlinked" | null;
   peer_note?: string | null;
+  // What the machine reported about itself (host_info), when it has.
+  hostname?: string | null;
+  os?: string | null;
+  arch?: string | null;
 }

package/lib/drafts.ts

@@ -63,7 +63,13 @@ export function newDraft(
   id: string,
   project: DraftProject | null,
   carry: Carry,
-  opts: { openPr?: boolean; now?: number; workspaceId?: string | null } = {}
+  opts: {
+    openPr?: boolean;
+    now?: number;
+    workspaceId?: string | null;
+    // Where a scratch chat starts: the machine the sidebar is narrowed to.
+    hostId?: string | null;
+  } = {}
 ): Draft {
   const real = project && !project.is_uncategorized ? project : null;
   const agentType = real?.agent_type ?? carry.agentType ?? "claude";
@@ -71,7 +77,7 @@ export function newDraft(
     id,
     projectId: real?.id ?? null,
     workspaceId: real ? null : (opts.workspaceId ?? null),
-    hostId: real?.host_id || "local",
+    hostId: real?.host_id || opts.hostId || "local",
     agentType,
     model: resolveModelForAgent(
       agentType,

package/lib/hosts/index.ts

@@ -1,5 +1,7 @@
 import { randomUUID } from "crypto";
 import { getDb, type Host } from "../db";
+import { machineName } from "../claims/machine";
+import { setThisMachineName, thisMachine } from "../machines/identity";
 import {
   LOCAL_HOST_ID,
   isValidSshTarget,
@@ -19,6 +21,18 @@ export const LOCAL_HOST: Host = {
   created_at: "",
 };
 
+/** This machine as a host row, under its real (or user-set) name. */
+export function localHost(): Host {
+  const me = thisMachine();
+  return {
+    ...LOCAL_HOST,
+    name: me.name,
+    hostname: me.hostname,
+    os: me.os,
+    arch: me.arch,
+  };
+}
+
 export function isRemoteHost(hostId: string | null | undefined): boolean {
   return !!hostId && hostId !== LOCAL_HOST_ID;
 }
@@ -38,18 +52,20 @@ export function listRemoteHosts(): Host[] {
           (SELECT p.suspended_reason FROM peer_links p WHERE p.host_id = h.id),
           (SELECT u.reason FROM peer_unlinked u WHERE u.host_id = h.id
             ORDER BY u.at DESC LIMIT 1))
-        END AS peer_note
-         FROM hosts h ORDER BY sort_order, created_at`
+        END AS peer_note,
+        i.hostname AS hostname, i.os AS os, i.arch AS arch
+         FROM hosts h LEFT JOIN host_info i ON i.host_id = h.id
+         ORDER BY h.sort_order, h.created_at`
     )
     .all() as Host[];
 }
 
 export function listHosts(): Host[] {
-  return [LOCAL_HOST, ...listRemoteHosts()];
+  return [localHost(), ...listRemoteHosts()];
 }
 
 export function getHost(hostId: string | null | undefined): Host | null {
-  if (!isRemoteHost(hostId)) return LOCAL_HOST;
+  if (!isRemoteHost(hostId)) return localHost();
   return (
     (getDb().prepare(`SELECT * FROM hosts WHERE id = ?`).get(hostId) as
       Host | undefined) ?? null
@@ -59,7 +75,11 @@ export function getHost(hostId: string | null | undefined): Host | null {
 /** A machine by its name (any case) or id. */
 export function hostIdNamed(ref: string): string {
   const want = ref.trim().toLowerCase();
-  if (["local", "here", "this machine"].includes(want)) return LOCAL_HOST_ID;
+  if (
+    ["local", "here", "this machine"].includes(want) ||
+    machineName().toLowerCase() === want
+  )
+    return LOCAL_HOST_ID;
   const host = listRemoteHosts().find(
     (h) => h.id === ref || h.name.toLowerCase() === want
   );
@@ -109,6 +129,7 @@ export function deleteHost(hostId: string): void {
   }
   db.prepare(`DELETE FROM host_links WHERE host_id = ?`).run(hostId);
   db.prepare(`DELETE FROM peer_links WHERE host_id = ?`).run(hostId);
+  db.prepare(`DELETE FROM host_info WHERE host_id = ?`).run(hostId);
   db.prepare(`DELETE FROM hosts WHERE id = ?`).run(hostId);
 }
 
@@ -139,3 +160,20 @@ export function hostExecFile(
 ): Promise<ExecResult> {
   return runFileOnTarget(sshTargetFor(hostId), file, args, timeout);
 }
+
+/** Rename a machine; this one's name is the one Work across machines shows. */
+export function renameHost(hostId: string, raw: string): string {
+  if (!isRemoteHost(hostId)) return setThisMachineName(raw);
+  const name = raw.trim().slice(0, 60);
+  if (!name) throw new Error("Name is required");
+  const db = getDb();
+  if (!db.prepare(`SELECT 1 FROM hosts WHERE id = ?`).get(hostId))
+    throw new Error("Unknown host");
+  const clash = db
+    .prepare(`SELECT 1 FROM hosts WHERE lower(name) = lower(?) AND id != ?`)
+    .get(name, hostId);
+  if (clash || name.toLowerCase() === machineName().toLowerCase())
+    throw new Error(`Another machine is already called "${name}"`);
+  db.prepare(`UPDATE hosts SET name = ? WHERE id = ?`).run(name, hostId);
+  return name;
+}

package/lib/machines/browser.ts

@@ -0,0 +1,37 @@
+/**
+ * Which machine the browser is on, when the request says. Only what the
+ * server itself saw counts: the gate's trust verdict (loopback means an
+ * unproxied request from this machine) and the socket's remote address.
+ * Through Connect or a proxy the address is the tunnel's, so nothing is
+ * claimed and the person says so once per browser instead.
+ */
+
+import { plainAddress } from "../security/auth";
+
+export interface BrowserMachine {
+  /** "local", a host id, or null when it can't be told. */
+  hostId: string | null;
+  how: "loopback" | "address" | null;
+}
+
+export interface KnownMachine {
+  hostId: string;
+  addresses: string[];
+}
+
+export function browserMachine(
+  trust: string | null,
+  remote: string | null,
+  own: string[],
+  others: KnownMachine[]
+): BrowserMachine {
+  if (trust === "loopback") return { hostId: "local", how: "loopback" };
+  const addr = plainAddress(remote ?? "");
+  if (!addr || ["connect", "peer", "unknown"].includes(addr))
+    return { hostId: null, how: null };
+  if (own.includes(addr)) return { hostId: "local", how: "address" };
+  const hit = others.find((m) => m.addresses.includes(addr));
+  return hit
+    ? { hostId: hit.hostId, how: "address" }
+    : { hostId: null, how: null };
+}

package/lib/machines/catalog.ts

@@ -0,0 +1,97 @@
+/**
+ * The agents this machine can run and the models each offers, plus the
+ * Ollama models it serves and which agent runs each. The new-session form
+ * shows exactly this for the machine picked; a linked machine reports its
+ * own through GET /api/machine.
+ */
+
+import { AGENT_OPTIONS } from "../agent-options";
+import { getProviderDefinition } from "../providers/registry";
+import { probeAgents } from "../agents/probe";
+import { discoveredModels } from "../chat/discovered-models";
+import {
+  discoversModels,
+  getDefaultModelForAgent,
+  getModelOptions,
+} from "../model-catalog";
+import type { ChatModel } from "../chat/events";
+import { ollamaModels } from "./ollama";
+import type { CatalogAgent, MachineCatalog, OllamaEntry } from "./types";
+
+const DISCOVER_MS = 6000;
+// Agents that can run a model served by Ollama, in the order to prefer them.
+const LOCAL_RUNNERS = ["opencode", "pi", "omp"] as const;
+
+export const TASK_REMOTE_REASON =
+  "Tasks on another machine run Claude Code only";
+
+const lastSegment = (v: string) => v.slice(v.lastIndexOf("/") + 1);
+
+/** The runner that lists this Ollama tag among its models, if any. */
+export function ollamaRunner(
+  tag: string,
+  byAgent: Record<string, ChatModel[]>
+): OllamaEntry["runsWith"] {
+  for (const agent of LOCAL_RUNNERS) {
+    const models = byAgent[agent] ?? [];
+    const hit =
+      models.find((m) => m.value === `ollama/${tag}`) ??
+      models.find(
+        (m) =>
+          lastSegment(m.value) === tag &&
+          /ollama/i.test(`${m.value} ${m.description ?? ""}`)
+      );
+    if (hit) return { agent, model: hit.value };
+  }
+  return null;
+}
+
+async function discover(agent: string): Promise<ChatModel[]> {
+  return Promise.race([
+    discoveredModels(agent, null),
+    new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error("timed out")), DISCOVER_MS).unref?.()
+    ),
+  ]);
+}
+
+export async function machineCatalog(): Promise<MachineCatalog> {
+  const [probes, tags] = await Promise.all([probeAgents(), ollamaModels()]);
+  const found: Record<string, ChatModel[]> = {};
+  const errors: Record<string, string> = {};
+  const wanted = AGENT_OPTIONS.filter(
+    (a) =>
+      probes[a.value]?.installed &&
+      (discoversModels(a.value) || LOCAL_RUNNERS.some((r) => r === a.value))
+  );
+  await Promise.all(
+    wanted.map(async (a) => {
+      if (!discoversModels(a.value)) return;
+      try {
+        found[a.value] = await discover(a.value);
+      } catch (e) {
+        errors[a.value] = e instanceof Error ? e.message : String(e);
+      }
+    })
+  );
+  const agents: CatalogAgent[] = AGENT_OPTIONS.filter(
+    (a) => !getProviderDefinition(a.value)?.legacy || probes[a.value]?.installed
+  ).map((a) => {
+    const base = getModelOptions(a.value);
+    return {
+      agent: a.value,
+      label: a.label,
+      installed: probes[a.value]?.installed ?? false,
+      auth: probes[a.value]?.auth ?? "unknown",
+      hint: probes[a.value]?.hint ?? null,
+      models: [...base, ...(found[a.value] ?? [])],
+      defaultModel: getDefaultModelForAgent(a.value),
+      taskBlocked: a.value === "claude" ? null : TASK_REMOTE_REASON,
+      modelsError: errors[a.value] ?? null,
+    };
+  });
+  return {
+    agents,
+    ollama: tags.map((name) => ({ name, runsWith: ollamaRunner(name, found) })),
+  };
+}

package/lib/machines/identity.ts

@@ -0,0 +1,52 @@
+/**
+ * This machine as it names itself: the one name every surface shows (the
+ * Machines dialog, the new-session chip, Work across machines), its OS and
+ * the addresses another device could reach it at.
+ */
+
+import os from "os";
+import { machineName } from "../claims/machine";
+import { putSetting } from "../settings-store";
+import { currentIdentity } from "../peer/keys";
+import { lanAddresses, tailscaleAddresses } from "../security/net";
+
+export interface MachineIdentity {
+  name: string;
+  hostname: string;
+  os: string;
+  arch: string;
+  connectMachineId: string | null;
+  addresses: string[];
+}
+
+const OS_LABEL: Record<string, string> = {
+  darwin: "macOS",
+  linux: "Linux",
+  win32: "Windows",
+};
+
+export const osLabel = (platform: string = os.platform()) =>
+  OS_LABEL[platform] ?? platform;
+
+export function thisMachine(): MachineIdentity {
+  return {
+    name: machineName(),
+    hostname: os.hostname().split(".")[0] || "machine",
+    os: osLabel(),
+    arch: os.arch(),
+    connectMachineId: currentIdentity()?.machineId ?? null,
+    addresses: [...new Set([...tailscaleAddresses(), ...lanAddresses()])],
+  };
+}
+
+/** A user-set name for this machine; the same one Work across machines shows. */
+export function setThisMachineName(raw: string): string {
+  const name = raw
+    .replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 60);
+  if (!name) throw new Error("Name is required");
+  putSetting("claims.machine_name", name);
+  return name;
+}