@saadnvd1/agent-os 0.3.736 → 0.3.738

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/package.json

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

package/scripts/screenshots/chat-verify.ts

@@ -0,0 +1,68 @@
+import type { ChatItem } from "../../lib/chat/events";
+
+const step = (
+  n: number,
+  start: number,
+  title: string,
+  status: "done" | "error" | "stopped",
+  output?: string
+): ChatItem => ({
+  id: `tool-${n}`,
+  createdAt: start + n * 4000,
+  kind: "tool",
+  name: "Bash",
+  title,
+  input: { command: title },
+  status,
+  output,
+  endedAt: start + n * 4000 + 1500,
+});
+
+// A reachability check cut short: some steps answered, one failed, two
+// never ran.
+export function verifyConversation(start: number): ChatItem[] {
+  return [
+    {
+      id: "user-1",
+      createdAt: start,
+      kind: "user",
+      text: "Which services can you reach from here before you scope the sync job?",
+    },
+    {
+      id: "assistant-1",
+      createdAt: start + 2000,
+      kind: "assistant",
+      text: "Here's what I can verify is reachable from this box, before I scope:",
+    },
+    step(
+      1,
+      start,
+      "curl -sI https://api.example.test/health",
+      "done",
+      "HTTP/2 200 \ncontent-type: application/json"
+    ),
+    step(
+      2,
+      start,
+      "curl -sI https://billing.example.test/v1",
+      "done",
+      "HTTP/2 401 \nwww-authenticate: Bearer"
+    ),
+    step(
+      3,
+      start,
+      "pg_isready -h db.internal",
+      "error",
+      "db.internal:5432 - no response\nExit code 2"
+    ),
+    step(4, start, "curl -sI https://search.example.test", "stopped"),
+    step(5, start, "redis-cli -h cache.internal ping", "stopped"),
+    {
+      id: "turn-1",
+      createdAt: start + 40000,
+      kind: "turn_end",
+      durationMs: 40000,
+      interrupted: true,
+    },
+  ];
+}

package/scripts/screenshots/seed.ts

@@ -5,6 +5,7 @@
  *
  *     npx tsx scripts/screenshots/seed.ts
  */
+import { verifyConversation } from "./chat-verify";
 import fs from "fs";
 import path from "path";
 import { randomUUID } from "crypto";
@@ -148,6 +149,14 @@ const SESSIONS: SessionSeed[] = [
     minutesAgo: 60 * 5,
     chat: docsConversation,
   },
+  {
+    key: "verify",
+    name: "sync-reachability",
+    project: "ml-pipeline",
+    view: "chat",
+    minutesAgo: 60 * 8,
+    chat: verifyConversation,
+  },
   {
     key: "backfill",
     name: "feature-backfill",

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;
+  },
+};