@saadnvd1/agent-os 0.3.697 → 0.3.700

package/lib/done/archive.ts

@@ -4,6 +4,7 @@
 import fs from "fs";
 import { db, queries, type Session } from "../db";
 import { statusOf } from "../orchestrator/facts";
+import { kickWaits } from "../bus/waits/kick";
 import { peerSessionLink } from "../hosts/peer-actions";
 
 export interface ArchivedView {
@@ -26,6 +27,7 @@ export function archiveSession(id: string): void {
   db.prepare(
     `UPDATE sessions SET archived_at = datetime('now') WHERE id = ? AND archived_at IS NULL`
   ).run(id);
+  kickWaits();
 }
 
 export function unarchiveSession(id: string): Session {

package/lib/hosts/index.ts

@@ -14,6 +14,7 @@ export const LOCAL_HOST: Host = {
   id: LOCAL_HOST_ID,
   name: "This machine",
   ssh_target: "",
+  kind: "ssh",
   sort_order: -1,
   created_at: "",
 };
@@ -25,7 +26,10 @@ export function isRemoteHost(hostId: string | null | undefined): boolean {
 export function listRemoteHosts(): Host[] {
   return getDb()
     .prepare(
-      `SELECT h.*, EXISTS (SELECT 1 FROM host_links l WHERE l.host_id = h.id) AS linked
+      `SELECT h.*, CASE WHEN h.kind = 'connect'
+          THEN EXISTS (SELECT 1 FROM peer_links p WHERE p.host_id = h.id)
+          ELSE EXISTS (SELECT 1 FROM host_links l WHERE l.host_id = h.id)
+        END AS linked
          FROM hosts h ORDER BY sort_order, created_at`
     )
     .all() as Host[];
@@ -54,22 +58,34 @@ export function hostIdNamed(ref: string): string {
   return host.id;
 }
 
-export function createHost(name: string, sshTarget: string): Host {
+function insertHost(
+  name: string,
+  sshTarget: string,
+  kind: "ssh" | "connect"
+): Host {
   if (!name.trim()) throw new Error("Name is required");
-  if (!isValidSshTarget(sshTarget)) {
-    throw new Error("ssh target must look like user@host or an ssh alias");
-  }
   const db = getDb();
   const id = randomUUID();
   const { max } = db
     .prepare(`SELECT COALESCE(MAX(sort_order), 0) AS max FROM hosts`)
     .get() as { max: number };
   db.prepare(
-    `INSERT INTO hosts (id, name, ssh_target, sort_order) VALUES (?, ?, ?, ?)`
-  ).run(id, name.trim(), sshTarget, max + 1);
+    `INSERT INTO hosts (id, name, ssh_target, sort_order, kind) VALUES (?, ?, ?, ?, ?)`
+  ).run(id, name.trim(), sshTarget, max + 1, kind);
   return getHost(id)!;
 }
 
+export function createHost(name: string, sshTarget: string): Host {
+  if (!isValidSshTarget(sshTarget)) {
+    throw new Error("ssh target must look like user@host or an ssh alias");
+  }
+  return insertHost(name, sshTarget, "ssh");
+}
+
+/** A machine reached only through Connect; its keys are pinned separately. */
+export const createConnectHost = (name: string): Host =>
+  insertHost(name, "", "connect");
+
 export function deleteHost(hostId: string): void {
   if (!isRemoteHost(hostId)) throw new Error("Cannot remove this machine");
   const db = getDb();
@@ -83,6 +99,7 @@ export function deleteHost(hostId: string): void {
     throw new Error("Move or delete its projects and sessions first");
   }
   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 hosts WHERE id = ?`).run(hostId);
 }
 
@@ -90,6 +107,10 @@ export function sshTargetFor(hostId: string | null | undefined): string | null {
   if (!isRemoteHost(hostId)) return null;
   const host = getHost(hostId);
   if (!host) throw new Error(`Unknown host: ${hostId}`);
+  if (host.kind === "connect")
+    throw new Error(
+      `${host.name} is linked through Connect: this needs a Tailscale/ssh link`
+    );
   return host.ssh_target;
 }
 

package/lib/hosts/peer-socket.ts

@@ -7,7 +7,7 @@
  */
 
 import { WebSocket } from "ws";
-import type { HostLink } from "./remote-api";
+import { requireTokenLink, type HostLink } from "./remote-api";
 
 export const PEER_HANDSHAKE_MS = 10_000;
 // A long chat's (paged) snapshot is one message.
@@ -30,6 +30,8 @@ export function openPeerSocket(
   query: Record<string, string> = {},
   maxPayload = PEER_MAX_PAYLOAD
 ): WebSocket {
+  // A Connect link has no token, and sockets don't ride the envelope yet.
+  requireTokenLink(link);
   return new WebSocket(peerSocketUrl(link, path, query), {
     headers: { Authorization: `Bearer ${link.token}` },
     handshakeTimeout: PEER_HANDSHAKE_MS,

package/lib/hosts/read-capped-bytes.ts

@@ -0,0 +1,23 @@
+/** A response body, read no further than max bytes whatever it claims. */
+export async function readCappedBytes(
+  res: Response,
+  max: number
+): Promise<Buffer> {
+  if (Number(res.headers.get("content-length")) > max)
+    throw new Error("its answer is too large");
+  const reader = res.body?.getReader();
+  if (!reader) return Buffer.alloc(0);
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > max) {
+      await reader.cancel().catch(() => undefined);
+      throw new Error("its answer is too large");
+    }
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks);
+}

package/lib/hosts/remote-api.ts

@@ -4,38 +4,112 @@
  */
 
 import { getDb } from "../db";
+import { PeerCallError, peerCall } from "../peer/client";
+import type { PinState } from "../peer/links";
 import { getHost, isRemoteHost } from "./index";
+import { readCappedBytes } from "./read-capped-bytes";
 
+/** A machine linked through Connect: its pinned keys (lib/peer). */
+export interface ConnectPeer {
+  machineId: string;
+  hostname: string;
+  signPub: string;
+  boxPub: string;
+  state: PinState;
+  suspendedReason: string | null;
+}
+
+/**
+ * `token` (the default): a device token over Tailscale or ssh-reached URLs.
+ * `connect`: signed, encrypted envelopes to the pinned keys; url and token
+ * are unused (token is always empty).
+ */
 export interface HostLink {
   hostId: string;
   hostName: string;
   url: string;
   token: string;
+  transport?: "token" | "connect";
+  connect?: ConnectPeer;
+}
+
+interface LinkRow {
+  host_id: string;
+  name: string;
+  kind: string;
+  url: string | null;
+  token: string | null;
+  machine_id: string | null;
+  hostname: string | null;
+  sign_pub: string | null;
+  box_pub: string | null;
+  state: string | null;
+  suspended_reason: string | null;
 }
 
 export function hostLink(hostId: string | null | undefined): HostLink | null {
   if (!isRemoteHost(hostId)) return null;
   const row = getDb()
     .prepare(
-      `SELECT l.host_id, l.url, l.token, h.name FROM host_links l
-         JOIN hosts h ON h.id = l.host_id WHERE l.host_id = ?`
+      `SELECT h.id AS host_id, h.name, h.kind, l.url, l.token, p.machine_id,
+              p.hostname, p.sign_pub, p.box_pub, p.state, p.suspended_reason
+         FROM hosts h
+         LEFT JOIN host_links l ON l.host_id = h.id
+         LEFT JOIN peer_links p ON p.host_id = h.id
+        WHERE h.id = ?`
     )
-    .get(hostId) as
-    { host_id: string; url: string; token: string; name: string } | undefined;
-  return row
+    .get(hostId) as LinkRow | undefined;
+  if (!row) return null;
+  if (row.kind === "connect") {
+    if (!row.machine_id || !row.hostname || !row.sign_pub || !row.box_pub)
+      return null;
+    return {
+      hostId: row.host_id,
+      hostName: row.name,
+      url: `https://${row.hostname}`,
+      token: "",
+      transport: "connect",
+      connect: {
+        machineId: row.machine_id,
+        hostname: row.hostname,
+        signPub: row.sign_pub,
+        boxPub: row.box_pub,
+        state: row.state === "active" ? "active" : "suspended",
+        suspendedReason: row.suspended_reason,
+      },
+    };
+  }
+  return row.url && row.token
     ? {
         hostId: row.host_id,
         hostName: row.name,
         url: row.url,
         token: row.token,
+        transport: "token",
       }
     : null;
 }
 
+export const isConnectLink = (link: HostLink) => link.transport === "connect";
+
+/** For the calls that only work with a token link (sockets, raw fetches). */
+export function requireTokenLink(link: HostLink): HostLink {
+  if (isConnectLink(link))
+    throw new Error(
+      `${link.hostName} is linked through Connect: this needs a Tailscale/ssh link for now`
+    );
+  return link;
+}
+
 export function linkedHostIds(): Set<string> {
-  const rows = getDb().prepare(`SELECT host_id FROM host_links`).all() as {
-    host_id: string;
-  }[];
+  const rows = getDb()
+    .prepare(
+      `SELECT host_id FROM host_links
+         WHERE host_id NOT IN (SELECT id FROM hosts WHERE kind = 'connect')
+       UNION SELECT p.host_id FROM peer_links p JOIN hosts h ON h.id = p.host_id
+         WHERE h.kind = 'connect'`
+    )
+    .all() as { host_id: string }[];
   return new Set(rows.map((r) => r.host_id));
 }
 
@@ -103,23 +177,7 @@ export async function readCapped(
   res: Response,
   max = MAX_RESPONSE_BYTES
 ): Promise<string> {
-  if (Number(res.headers.get("content-length")) > max)
-    throw new Error("its answer is too large");
-  const reader = res.body?.getReader();
-  if (!reader) return "";
-  const chunks: Uint8Array[] = [];
-  let total = 0;
-  for (;;) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    total += value.byteLength;
-    if (total > max) {
-      await reader.cancel().catch(() => undefined);
-      throw new Error("its answer is too large");
-    }
-    chunks.push(value);
-  }
-  return Buffer.concat(chunks).toString("utf8");
+  return (await readCappedBytes(res, max)).toString("utf8");
 }
 
 /** A JSON call to the other machine's AgentOS; its error text on failure. */
@@ -133,21 +191,34 @@ export async function hostApi<T>(
       `Can't reach AgentOS on ${link.hostName}: ${cleanRemoteText(err instanceof Error ? err.message : err)}`,
       false
     );
-  let res: Response;
+  let status: number;
   let text: string;
   try {
-    res = await fetch(`${link.url}${path}`, {
-      method: opts.method ?? (opts.body === undefined ? "GET" : "POST"),
-      headers: {
-        Authorization: `Bearer ${link.token}`,
-        ...(opts.body !== undefined && { "Content-Type": "application/json" }),
-      },
-      body: opts.body === undefined ? undefined : JSON.stringify(opts.body),
-      signal: AbortSignal.timeout(opts.timeout ?? 15000),
-      redirect: "error",
-    });
-    text = await readCapped(res);
+    if (isConnectLink(link)) {
+      ({ status, text } = await peerCall(link, path, opts));
+    } else {
+      const res = await fetch(`${link.url}${path}`, {
+        method: opts.method ?? (opts.body === undefined ? "GET" : "POST"),
+        headers: {
+          Authorization: `Bearer ${link.token}`,
+          ...(opts.body !== undefined && {
+            "Content-Type": "application/json",
+          }),
+        },
+        body: opts.body === undefined ? undefined : JSON.stringify(opts.body),
+        signal: AbortSignal.timeout(opts.timeout ?? 15000),
+        redirect: "error",
+      });
+      status = res.status;
+      text = await readCapped(res);
+    }
   } catch (err) {
+    if (err instanceof PeerCallError && err.refused)
+      throw new HostApiError(
+        `${link.hostName}: ${cleanRemoteText(err.message)}`,
+        true,
+        err.status
+      );
     throw unknown(err);
   }
   let data: { error?: unknown } | null = null;
@@ -156,13 +227,13 @@ export async function hostApi<T>(
   } catch {
     data = null;
   }
-  if (!res.ok) {
+  if (status < 200 || status > 299) {
     // Only AgentOS's own refusal (a 4xx with its error) means nothing happened.
-    const refused = res.status >= 400 && res.status < 500 && !!data?.error;
+    const refused = status >= 400 && status < 500 && !!data?.error;
     throw new HostApiError(
-      `${link.hostName}: ${cleanRemoteText(data?.error) || `HTTP ${res.status}`}`,
+      `${link.hostName}: ${cleanRemoteText(data?.error) || `HTTP ${status}`}`,
       refused,
-      res.status
+      status
     );
   }
   if (!data) throw unknown(new Error("its answer wasn't JSON"));

package/lib/orchestrator/describe.ts

@@ -41,6 +41,19 @@ function sessionLine(f: SessionFacts): string {
     parts.push(
       `${f.plan.awaiting ? "plan ready, awaiting your approve_plan" : f.plan.planned ? "planned" : "no plan"}${f.plan.reason ? `: ${untrusted(f.name, f.plan.reason)}` : ""}`
     );
+  if (f.waits?.on.length)
+    parts.push(
+      `waiting on ${f.waits.on
+        .map(
+          (w) =>
+            `${untrusted(f.name, w.name)} (${w.kind === "reply" ? "reply" : w.kind === "idle" ? "to go idle" : "to merge"}, ${Math.max(1, Math.round(w.leftMs / 60_000))}m left)`
+        )
+        .join(", ")}`
+    );
+  if (f.waits?.by.length)
+    parts.push(
+      `${f.waits.by.map((n) => untrusted(f.name, n)).join(", ")} waiting on it`
+    );
   if (f.stack) {
     const card = f.stack.ticket ? ` ${f.stack.ticket}` : "";
     parts.push(

package/lib/orchestrator/facts.ts

@@ -20,6 +20,7 @@ import { prFor, storedPR } from "../tasks/session";
 import { lastActiveOf } from "../tasks/last-active";
 import * as taskClient from "../tasks/contract/client";
 import { deriveTaskState } from "../tasks";
+import { waitBadges } from "../bus/waits/store";
 import { waitingState } from "./task-state";
 import { commitTime, repoOf } from "./repo";
 import { CHECKLESS_MS, checklessFor, ciSettleIn } from "./task-state";
@@ -44,6 +45,11 @@ export interface SessionFacts {
   compacting?: boolean;
   // Last sign of life, in ms.
   lastActive: number;
+  // Open waits (aos send --await, aos wait): who it waits on, and who waits on it.
+  waits?: {
+    on: { name: string; kind: string; leftMs: number }[];
+    by: string[];
+  } | null;
   // Work that should end in a PR: a task, or a session on its own branch.
   branch: string | null;
   // A quick change the orchestrator makes itself (quick.ts): no agent.
@@ -301,6 +307,7 @@ export async function sessionFacts(
   workspaceId: string
 ): Promise<SessionFacts[]> {
   await statusDetector.refreshCache();
+  const badges = waitBadges();
   return Promise.all(
     workspaceSessions(workspaceId).map(async (s) => {
       const [{ status, activity, needsInput }, task] = await Promise.all([
@@ -315,6 +322,16 @@ export async function sessionFacts(
         status,
         activity,
         needsInput,
+        waits: badges.has(s.id)
+          ? {
+              on: badges.get(s.id)!.on.map((w) => ({
+                name: w.name,
+                kind: w.kind,
+                leftMs: Math.max(0, w.deadline - Date.now()),
+              })),
+              by: badges.get(s.id)!.by.map((w) => w.name),
+            }
+          : null,
         stalled:
           s.view === "chat" && !hostLink(s.host_id) ? chatStall(s.id) : null,
         compacting:

package/lib/peer/account.ts

@@ -0,0 +1,198 @@
+/**
+ * The other machines on this machine's Connect account, and whether its plan
+ * includes linking. Connect only introduces: a listed key is who may ask to
+ * pair, never who is trusted (that takes the code typed on the target).
+ *
+ * Kept in memory, shared through globalThis by the server and the routes.
+ * The list is fetched when it's older than a minute and someone needs it,
+ * and marked stale when the heartbeat's peers_etag changes; fetches are
+ * shared and spaced, so a flood of hellos can't hammer the service.
+ */
+
+import crypto from "crypto";
+import { readConnect } from "../connect/config";
+import {
+  listPeers,
+  type Beat,
+  type Entitlements,
+  type PeerList,
+} from "../connect/control-api";
+import { peerHostAllowed } from "./client";
+import { rawPublic } from "./keys";
+
+export interface AccountPeer {
+  id: string;
+  name: string;
+  hostname: string;
+  /** Its Ed25519 public key, base64url of the raw 32 bytes. */
+  signPub: string;
+  lastSeenAt: string | null;
+  version: string | null;
+}
+
+export interface AccountView {
+  enrolled: boolean;
+  entitlements: Entitlements | null;
+  peers: AccountPeer[];
+  /** When the list was last fetched, 0 if never. */
+  fetchedAt: number;
+  error: string | null;
+}
+
+export const LIST_MAX_AGE_MS = 60_000;
+// Never more often than this, whoever asks.
+const MIN_GAP_MS = 5_000;
+
+interface State {
+  entitlements: Entitlements | null;
+  etag: string | null;
+  peers: AccountPeer[];
+  fetchedAt: number;
+  triedAt: number;
+  stale: boolean;
+  error: string | null;
+  inflight: Promise<void> | null;
+}
+
+export type Fetcher = () => Promise<PeerList | null>;
+
+const g = globalThis as unknown as {
+  __agentosPeerAccount?: State;
+  __agentosPeerFetcher?: Fetcher;
+};
+
+const fresh = (): State => ({
+  entitlements: null,
+  etag: null,
+  peers: [],
+  fetchedAt: 0,
+  triedAt: 0,
+  stale: false,
+  error: null,
+  inflight: null,
+});
+
+const state = () => (g.__agentosPeerAccount ??= fresh());
+
+/** The signed call, or null when this machine isn't enrolled. */
+const realFetcher: Fetcher = async () => {
+  const read = readConnect();
+  if (!read.ok) return null;
+  return listPeers(read.files.config, read.files.machineKey);
+};
+
+/** Tests: a fake Connect service, and a clean slate. */
+export function setAccountFetcher(f: Fetcher | null) {
+  g.__agentosPeerFetcher = f ?? undefined;
+  g.__agentosPeerAccount = fresh();
+}
+
+/** Control's SPKI PEM as the raw key the pins use, or null. */
+export function rawFromSpki(pem: string): string | null {
+  try {
+    const key = crypto.createPublicKey(pem);
+    return key.asymmetricKeyType === "ed25519" ? rawPublic(key) : null;
+  } catch {
+    return null;
+  }
+}
+
+function adopt(list: PeerList) {
+  const s = state();
+  const peers: AccountPeer[] = [];
+  for (const m of list.peers) {
+    const signPub = rawFromSpki(m.publicKey);
+    // Only a Connect machine's own name: a lying list can't aim this
+    // machine anywhere else.
+    if (!signPub || !peerHostAllowed(m.hostname)) continue;
+    peers.push({
+      id: m.id,
+      name: m.name,
+      hostname: m.hostname,
+      signPub,
+      lastSeenAt: m.lastSeenAt,
+      version: m.version,
+    });
+  }
+  s.peers = peers;
+  if (list.entitlements) s.entitlements = list.entitlements;
+  if (list.peersEtag) s.etag = list.peersEtag;
+  s.fetchedAt = Date.now();
+  s.stale = false;
+  s.error = null;
+}
+
+async function refresh(): Promise<void> {
+  const s = state();
+  if (s.inflight) return s.inflight;
+  if (Date.now() - s.triedAt < MIN_GAP_MS) return;
+  s.triedAt = Date.now();
+  s.inflight = (async () => {
+    try {
+      const list = await (g.__agentosPeerFetcher ?? realFetcher)();
+      if (list) adopt(list);
+      else {
+        s.peers = [];
+        s.error = "This machine isn't connected to AgentOS Connect.";
+      }
+    } catch (err) {
+      // The last list stays; only its age says it's old.
+      s.error = `Can't reach your AgentOS account: ${
+        err instanceof Error ? err.message : String(err)
+      }`.slice(0, 300);
+    } finally {
+      s.inflight = null;
+    }
+  })();
+  return s.inflight;
+}
+
+const enrolled = () =>
+  g.__agentosPeerFetcher ? true : readConnect().ok === true;
+
+/** The account's machines, fetched first if the list is older than maxAgeMs. */
+export async function accountView(
+  maxAgeMs = LIST_MAX_AGE_MS
+): Promise<AccountView> {
+  if (!enrolled())
+    return {
+      enrolled: false,
+      entitlements: null,
+      peers: [],
+      fetchedAt: 0,
+      error: null,
+    };
+  const s = state();
+  if (s.stale || Date.now() - s.fetchedAt > maxAgeMs) await refresh();
+  return {
+    enrolled: true,
+    entitlements: s.entitlements,
+    peers: s.peers,
+    fetchedAt: s.fetchedAt,
+    error: s.error,
+  };
+}
+
+/** The machine as the account lists it now, or null when it isn't listed. */
+export async function listedPeer(
+  machineId: string
+): Promise<AccountPeer | null> {
+  const view = await accountView();
+  return view.peers.find((p) => p.id === machineId) ?? null;
+}
+
+/** Whether the plan includes linking: null until the service has said. */
+export async function linkingAllowed(): Promise<boolean | null> {
+  const { entitlements } = await accountView();
+  return entitlements ? entitlements.linkMachines : null;
+}
+
+/** What a heartbeat says: the plan now, and whether the list changed. */
+export function noteHeartbeat(beat: Beat) {
+  const s = state();
+  if (beat.entitlements) s.entitlements = beat.entitlements;
+  if (beat.peersEtag && beat.peersEtag !== s.etag) {
+    s.etag = beat.peersEtag;
+    s.stale = true;
+  }
+}