@saadnvd1/agent-os 0.3.735 → 0.3.737

package/lib/machines/label.ts

@@ -0,0 +1,36 @@
+/** How a machine is named on every screen, so they all agree. */
+
+export interface Nameable {
+  id: string;
+  name: string;
+}
+
+export const LOCAL_ID = "local";
+
+/**
+ * "spark-54423f (host)" for the machine serving this dashboard, the plain name
+ * for the others; " · you're here" when the browser is on it.
+ */
+export function machineLabel(host: Nameable, browserHostId?: string | null) {
+  const base = host.id === LOCAL_ID ? `${host.name} (host)` : host.name;
+  return browserHostId && browserHostId === host.id
+    ? `${base} · you're here`
+    : base;
+}
+
+/** What a machine reports about itself, as one line. */
+export function machineDetail(h: {
+  name?: string;
+  hostname?: string | null;
+  os?: string | null;
+  arch?: string | null;
+}): string {
+  // Its hostname is only news when the name isn't already it.
+  const hostname =
+    h.hostname && h.hostname.toLowerCase() !== h.name?.toLowerCase()
+      ? h.hostname
+      : null;
+  return [hostname, [h.os, h.arch].filter(Boolean).join(" ")]
+    .filter(Boolean)
+    .join(" · ");
+}

package/lib/machines/ollama.ts

@@ -0,0 +1,32 @@
+/** The models a local Ollama serves, asked of its own API. */
+
+const DEFAULT_URL = "http://127.0.0.1:11434";
+const TIMEOUT_MS = 1500;
+
+export function ollamaBase(
+  env: Record<string, string | undefined> = process.env
+): string {
+  const raw = env.OLLAMA_HOST?.trim();
+  if (!raw) return DEFAULT_URL;
+  const url = /^https?:\/\//.test(raw) ? raw : `http://${raw}`;
+  return url.replace(/\/+$/, "");
+}
+
+/** Model tags, or none when Ollama isn't running or doesn't answer in time. */
+export async function ollamaModels(
+  fetchImpl: typeof fetch = fetch,
+  base = ollamaBase()
+): Promise<string[]> {
+  try {
+    const res = await fetchImpl(`${base}/api/tags`, {
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+    if (!res.ok) return [];
+    const body = (await res.json()) as { models?: { name?: unknown }[] };
+    return (body.models ?? [])
+      .map((m) => (typeof m.name === "string" ? m.name : ""))
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}

package/lib/machines/remote.ts

@@ -0,0 +1,179 @@
+/**
+ * What a linked machine says about itself. The identity is kept in
+ * host_info so its name, OS and addresses show while it is offline; the
+ * catalog (agents and models) is only held in memory for a minute.
+ */
+
+import { getDb } from "../db";
+import { hostApi, hostLink, linkedHostIds } from "../hosts/remote-api";
+import { isRemoteHost } from "../hosts";
+import type { HostCatalogResponse, MachineReport } from "./types";
+
+const CATALOG_TTL_MS = 60_000;
+const INFO_TTL_MS = 5 * 60_000;
+
+interface Cached {
+  at: number;
+  report: MachineReport;
+}
+const cache = new Map<string, Cached>();
+const running = new Map<string, Promise<MachineReport>>();
+const tried = new Map<string, number>();
+
+export interface HostInfo {
+  hostId: string;
+  name: string | null;
+  hostname: string | null;
+  os: string | null;
+  arch: string | null;
+  connectMachineId: string | null;
+  addresses: string[];
+  fetchedAt: number;
+}
+
+interface InfoRow {
+  host_id: string;
+  name: string | null;
+  hostname: string | null;
+  os: string | null;
+  arch: string | null;
+  connect_machine_id: string | null;
+  addresses: string;
+  fetched_at: number;
+}
+
+const parseAddresses = (raw: string): string[] => {
+  try {
+    const v = JSON.parse(raw);
+    return Array.isArray(v) ? v.filter((a) => typeof a === "string") : [];
+  } catch {
+    return [];
+  }
+};
+
+export function allHostInfo(): HostInfo[] {
+  return (getDb().prepare(`SELECT * FROM host_info`).all() as InfoRow[]).map(
+    (r) => ({
+      hostId: r.host_id,
+      name: r.name,
+      hostname: r.hostname,
+      os: r.os,
+      arch: r.arch,
+      connectMachineId: r.connect_machine_id,
+      addresses: parseAddresses(r.addresses),
+      fetchedAt: r.fetched_at,
+    })
+  );
+}
+
+export const hostInfo = (hostId: string): HostInfo | null =>
+  allHostInfo().find((i) => i.hostId === hostId) ?? null;
+
+function save(hostId: string, report: MachineReport, now: number): void {
+  const i = report.identity;
+  getDb()
+    .prepare(
+      `INSERT INTO host_info (host_id, name, hostname, os, arch, connect_machine_id, addresses, fetched_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(host_id) DO UPDATE SET name = excluded.name,
+         hostname = excluded.hostname, os = excluded.os, arch = excluded.arch,
+         connect_machine_id = excluded.connect_machine_id,
+         addresses = excluded.addresses, fetched_at = excluded.fetched_at`
+    )
+    .run(
+      hostId,
+      i.name,
+      i.hostname,
+      i.os,
+      i.arch,
+      i.connectMachineId,
+      JSON.stringify(i.addresses),
+      now
+    );
+}
+
+const text = (v: unknown, max = 120) =>
+  typeof v === "string" ? v.slice(0, max) : "";
+
+/** A peer's report, trimmed to the shape we use; anything else is refused. */
+export function parseReport(body: unknown): MachineReport | null {
+  const b = body as Partial<MachineReport> | null;
+  if (!b?.identity || !b.catalog || !Array.isArray(b.catalog.agents))
+    return null;
+  const i = b.identity;
+  return {
+    identity: {
+      name: text(i.name, 60),
+      hostname: text(i.hostname),
+      os: text(i.os, 30),
+      arch: text(i.arch, 30),
+      connectMachineId: text(i.connectMachineId) || null,
+      addresses: (Array.isArray(i.addresses) ? i.addresses : [])
+        .filter((a): a is string => typeof a === "string")
+        .slice(0, 16)
+        .map((a) => a.slice(0, 64)),
+    },
+    catalog: {
+      agents: b.catalog.agents.slice(0, 40),
+      ollama: Array.isArray(b.catalog.ollama)
+        ? b.catalog.ollama.slice(0, 200)
+        : [],
+    },
+  };
+}
+
+export async function fetchHostMachine(
+  hostId: string,
+  now = Date.now()
+): Promise<MachineReport> {
+  const hit = cache.get(hostId);
+  if (hit && now - hit.at < CATALOG_TTL_MS) return hit.report;
+  const link = hostLink(hostId);
+  if (!link) throw new Error("This machine isn't linked");
+  const wait = running.get(hostId);
+  if (wait) return wait;
+  const p = hostApi<unknown>(link, "/api/machine", { timeout: 12_000 })
+    .then((body) => {
+      const report = parseReport(body);
+      if (!report)
+        throw new Error("Its AgentOS answered in a format we can't read");
+      cache.set(hostId, { at: now, report });
+      save(hostId, report, now);
+      return report;
+    })
+    .finally(() => running.delete(hostId));
+  running.set(hostId, p);
+  return p;
+}
+
+/** The agents of a linked machine, or why they can't be listed. */
+export async function hostCatalog(
+  hostId: string
+): Promise<HostCatalogResponse> {
+  if (!isRemoteHost(hostId))
+    return { catalog: null, error: "Not a linked machine" };
+  try {
+    return { catalog: (await fetchHostMachine(hostId)).catalog, error: null };
+  } catch (e) {
+    const old = /404|not found|forbidden|not allowed/i.test(String(e));
+    return {
+      catalog: null,
+      error: old
+        ? "Update AgentOS on that machine to see its agents and models"
+        : e instanceof Error
+          ? e.message
+          : String(e),
+    };
+  }
+}
+
+/** Read every linked machine whose identity is old; failures are ignored. */
+export function refreshHostInfo(now = Date.now()): void {
+  const have = new Map(allHostInfo().map((i) => [i.hostId, i.fetchedAt]));
+  for (const hostId of linkedHostIds()) {
+    if (now - (have.get(hostId) ?? 0) < INFO_TTL_MS) continue;
+    if (now - (tried.get(hostId) ?? 0) < INFO_TTL_MS) continue;
+    tried.set(hostId, now);
+    fetchHostMachine(hostId, now).catch(() => undefined);
+  }
+}

package/lib/machines/report.ts

@@ -0,0 +1,8 @@
+import { thisMachine } from "./identity";
+import { machineCatalog } from "./catalog";
+import type { MachineReport } from "./types";
+
+/** What GET /api/machine answers: this machine's identity and agents. */
+export async function thisMachineReport(): Promise<MachineReport> {
+  return { identity: thisMachine(), catalog: await machineCatalog() };
+}

package/lib/machines/types.ts

@@ -0,0 +1,55 @@
+/** What a machine reports about itself, shared by the server and the UI. */
+
+import type { AgentType } from "../providers";
+import type { AgentAuth } from "../agents/probe";
+
+export interface CatalogModel {
+  value: string;
+  label: string;
+  description?: string;
+}
+
+export interface CatalogAgent {
+  agent: AgentType;
+  label: string;
+  installed: boolean;
+  auth: AgentAuth;
+  hint: string | null;
+  models: CatalogModel[];
+  defaultModel: string;
+  /** Why it can't run a task on a linked machine; null when it can. */
+  taskBlocked: string | null;
+  /** Set when asking the agent for its models failed. */
+  modelsError: string | null;
+}
+
+export interface OllamaEntry {
+  /** The tag Ollama calls it, e.g. "qwen3:27b". */
+  name: string;
+  /** The agent and model value that runs it here; null when none can. */
+  runsWith: { agent: AgentType; model: string } | null;
+}
+
+export interface MachineCatalog {
+  agents: CatalogAgent[];
+  ollama: OllamaEntry[];
+}
+
+export interface MachineReport {
+  identity: {
+    name: string;
+    hostname: string;
+    os: string;
+    arch: string;
+    connectMachineId: string | null;
+    addresses: string[];
+  };
+  catalog: MachineCatalog;
+}
+
+/** One machine's agents as the new-session form asks for them. */
+export interface HostCatalogResponse {
+  catalog: MachineCatalog | null;
+  /** Why there is no catalog (unlinked, unreachable, older AgentOS). */
+  error: string | null;
+}

package/lib/peer/allowlist.ts

@@ -58,6 +58,8 @@ export const PEER_ROUTES: readonly PeerRoute[] = [
   { method: "GET", pattern: "/api/projects" },
   { method: "POST", pattern: "/api/projects/availability" },
   { method: "GET", pattern: "/api/tmux/discover" },
+  // Its name, OS, addresses, agents and models, for the new-session form.
+  { method: "GET", pattern: "/api/machine" },
   { method: "GET", pattern: "/api/load" },
 
   { method: "GET", pattern: "/api/worktree-sweep" },

package/lib/peer/machines.ts

@@ -17,6 +17,8 @@ export interface AccountMachine {
   /** The Machines host it's linked as, when it is. */
   hostId: string | null;
   linkState: "active" | "suspended" | null;
+  /** How it's linked: Connect, or the Tailscale/ssh link in Machines. */
+  linkedVia: "connect" | "tailscale" | null;
   suspendedReason: string | null;
 }
 
@@ -54,6 +56,28 @@ export async function accountMachines(
       }[]
     ).map((r) => [r.machine_id, r])
   );
+  // Machines linked the other way: AgentOS to AgentOS over Tailscale or ssh.
+  const tokenLinked = (
+    getDb()
+      .prepare(
+        `SELECT h.id, h.name, i.name AS reported, i.connect_machine_id AS machine_id
+         FROM host_links l JOIN hosts h ON h.id = l.host_id
+         LEFT JOIN host_info i ON i.host_id = h.id WHERE h.kind != 'connect'`
+      )
+      .all() as {
+      id: string;
+      name: string;
+      reported: string | null;
+      machine_id: string | null;
+    }[]
+  ).map((r) => ({ ...r, names: [r.name, r.reported] }));
+  const sameMachine = (id: string, name: string) =>
+    tokenLinked.find(
+      (t) =>
+        t.machine_id === id ||
+        (!t.machine_id &&
+          t.names.some((n) => n && n.toLowerCase() === name.toLowerCase()))
+    );
   return {
     enrolled: view.enrolled,
     entitlements: view.entitlements,
@@ -62,6 +86,7 @@ export async function accountMachines(
     uncheckedSince: view.uncheckedSince,
     machines: view.peers.map((p) => {
       const pin = pins.get(p.id);
+      const other = pin ? undefined : sameMachine(p.id, p.name);
       const seen = p.lastSeenAt ? Date.parse(p.lastSeenAt) : NaN;
       return {
         id: p.id,
@@ -70,12 +95,15 @@ export async function accountMachines(
         online: Number.isFinite(seen) && now - seen < ONLINE_MS,
         lastSeenAt: p.lastSeenAt,
         version: p.version,
-        hostId: pin?.host_id ?? null,
+        hostId: pin?.host_id ?? other?.id ?? null,
         linkState: pin
           ? pin.state === "active"
             ? "active"
             : "suspended"
-          : null,
+          : other
+            ? "active"
+            : null,
+        linkedVia: pin ? "connect" : other ? "tailscale" : null,
         suspendedReason:
           pin && pin.state !== "active" ? pin.suspended_reason : null,
       };

package/lib/sidebar/machines.ts

@@ -54,3 +54,13 @@ export function machineGroups(
     .filter((g) => g.rows.length > 0)
     .sort((a, b) => a.name.localeCompare(b.name));
 }
+
+/** Whether a session belongs to the machine the sidebar is narrowed to. */
+export function inMachineScope(
+  session: Pick<Session, "host_id">,
+  scope: string | null
+): boolean {
+  if (!scope) return true;
+  const host = session.host_id || "local";
+  return host === scope;
+}

package/lib/start-options.ts

@@ -10,6 +10,7 @@ import { getProviderDefinition } from "./providers/registry";
 import { probeAgents } from "./agents/probe";
 import { gitCheck } from "./git";
 import { listHosts } from "./hosts";
+import { hostCatalog } from "./machines/remote";
 import { projectMachines } from "./hosts/project-machines";
 import { getModelOptions, getDefaultModelForAgent } from "./model-catalog";
 import { effectiveModels } from "./models/config";
@@ -52,6 +53,10 @@ export async function startOptions(
     planError = error instanceof Error ? error.message : String(error);
   }
 
+  // A project on another machine shows that machine's agents, as it reports them.
+  const there = here
+    ? null
+    : (await hostCatalog(project?.host_id ?? "")).catalog;
   const [probes, git, machines] = await Promise.all([
     here ? probeAgents() : Promise.resolve(null),
     project && here
@@ -78,10 +83,21 @@ export async function startOptions(
     ).map((a) => ({
       value: a.value,
       label: a.label,
-      installed: probes?.[a.value]?.installed ?? null,
-      auth: probes?.[a.value]?.auth ?? null,
-      hint: probes?.[a.value]?.hint ?? null,
-      models: getModelOptions(a.value),
+      installed:
+        probes?.[a.value]?.installed ??
+        there?.agents.find((t) => t.agent === a.value)?.installed ??
+        null,
+      auth:
+        probes?.[a.value]?.auth ??
+        there?.agents.find((t) => t.agent === a.value)?.auth ??
+        null,
+      hint:
+        probes?.[a.value]?.hint ??
+        there?.agents.find((t) => t.agent === a.value)?.hint ??
+        null,
+      models:
+        there?.agents.find((t) => t.agent === a.value)?.models ??
+        getModelOptions(a.value),
       defaultModel: getDefaultModelForAgent(a.value),
     })),
     taskModels: modelChoices(models),

package/lib/worktree-deps/install.ts

@@ -7,6 +7,7 @@
 
 import * as fs from "fs";
 import * as path from "path";
+import { sessionPath } from "../agents/tool-path";
 
 export interface PackageManager {
   name: "bun" | "pnpm" | "yarn" | "npm";
@@ -67,12 +68,14 @@ export function shellCommand(command: string): string {
 }
 
 // What setup commands run under: the server's environment without the
-// settings that make an install skip devDependencies.
+// settings that make an install skip devDependencies, on the PATH a session
+// gets (version managers' shims first), so `bundle` isn't the system Ruby's.
 export function setupEnv(
   base: NodeJS.ProcessEnv,
   extra: Record<string, string> = {}
 ): NodeJS.ProcessEnv {
   const env: NodeJS.ProcessEnv = { ...base, ...extra };
+  if (!extra.PATH) env.PATH = sessionPath(base.PATH);
   for (const key of Object.keys(env)) {
     const k = key.toLowerCase();
     if (

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.735",
+  "version": "0.3.737",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/stores/machines.ts

@@ -0,0 +1,51 @@
+import { proxy, subscribe } from "valtio";
+
+const KEY = "agentOS-machines-v1";
+
+// What this browser remembers about machines: which one it is on (when the
+// server couldn't tell) and which machine the sidebar is narrowed to.
+interface Remembered {
+  browserHostId: string | null;
+  scopeHostId: string | null;
+}
+
+export const machinesUi = proxy<Remembered & { hydrated: boolean }>({
+  browserHostId: null,
+  scopeHostId: null,
+  hydrated: false,
+});
+
+export const machinesUiActions = {
+  hydrate: () => {
+    if (machinesUi.hydrated || typeof window === "undefined") return;
+    try {
+      const saved = JSON.parse(
+        localStorage.getItem(KEY) ?? "{}"
+      ) as Partial<Remembered>;
+      machinesUi.browserHostId = saved.browserHostId ?? null;
+      machinesUi.scopeHostId = saved.scopeHostId ?? null;
+    } catch {
+      // A bad entry is the same as none.
+    }
+    machinesUi.hydrated = true;
+    subscribe(machinesUi, () => {
+      try {
+        localStorage.setItem(
+          KEY,
+          JSON.stringify({
+            browserHostId: machinesUi.browserHostId,
+            scopeHostId: machinesUi.scopeHostId,
+          })
+        );
+      } catch {
+        // Private mode: it just won't be remembered.
+      }
+    });
+  },
+  setBrowserHost: (hostId: string | null) => {
+    machinesUi.browserHostId = hostId;
+  },
+  setScope: (hostId: string | null) => {
+    machinesUi.scopeHostId = hostId;
+  },
+};