@saadnvd1/agent-os 0.3.698 → 0.3.700

package/lib/connect/control-api.ts

@@ -214,17 +214,123 @@ export async function requestTunnel(
   return { hostname: hostnameFrom(r), token: tokenFrom(r) };
 }
 
+/** What the account's plan allows; absent from an older Connect service. */
+export interface Entitlements {
+  plan: string;
+  linkMachines: boolean;
+  machineLimit: number;
+}
+
+export interface Beat {
+  enabled: boolean;
+  entitlements?: Entitlements;
+  /** Changes whenever the list `peers` would give changes. */
+  peersEtag?: string;
+}
+
+const ETAG = /^[A-Za-z0-9_-]{1,128}$/;
+
+export function entitlementsFrom(raw: unknown): Entitlements | undefined {
+  const e = (raw ?? null) as Record<string, unknown> | null;
+  if (!e || typeof e !== "object" || typeof e.link_machines !== "boolean")
+    return undefined;
+  return {
+    plan: typeof e.plan === "string" ? clean(e.plan, 32) : "unknown",
+    linkMachines: e.link_machines,
+    machineLimit:
+      typeof e.machine_limit === "number" &&
+      Number.isSafeInteger(e.machine_limit)
+        ? e.machine_limit
+        : 0,
+  };
+}
+
+const etagFrom = (raw: unknown) =>
+  typeof raw === "string" && ETAG.test(raw) ? raw : undefined;
+
 export async function heartbeat(
   config: ConnectConfig,
   privateKey: string,
   version: string
-) {
+): Promise<Beat> {
   const res = await signed(config, privateKey)(
     "POST",
     `/api/v1/machines/${config.machineId}/heartbeat`,
     { version }
   );
-  return (await res.json()) as { enabled: boolean };
+  const r = ((await res.json().catch(() => null)) ?? {}) as Record<
+    string,
+    unknown
+  >;
+  return {
+    enabled: r.enabled !== false,
+    entitlements: entitlementsFrom(r.entitlements),
+    peersEtag: etagFrom(r.peers_etag),
+  };
+}
+
+/** Another machine on this account, as the Connect service introduces it. */
+export interface ListedMachine {
+  id: string;
+  name: string;
+  hostname: string;
+  /** Its Ed25519 key as the service holds it: SPKI PEM. */
+  publicKey: string;
+  lastSeenAt: string | null;
+  version: string | null;
+}
+
+export interface PeerList {
+  entitlements?: Entitlements;
+  peersEtag?: string;
+  peers: ListedMachine[];
+}
+
+const MAX_PEERS = 100;
+
+/**
+ * The account's other machines this one may link to. Only an introduction:
+ * anything malformed is dropped here, and the keys still have to be
+ * confirmed by a person on both machines before either trusts the other.
+ */
+export async function listPeers(
+  config: ConnectConfig,
+  privateKey: string
+): Promise<PeerList> {
+  const res = await signed(config, privateKey)(
+    "GET",
+    `/api/v1/machines/${config.machineId}/peers`
+  );
+  const r = (await res.json().catch(() => null)) as Record<
+    string,
+    unknown
+  > | null;
+  if (!r || !Array.isArray(r.peers))
+    throw new Error("the Connect service sent no machine list");
+  const str = (v: unknown, max: number) =>
+    typeof v === "string" && v.length <= max ? v : null;
+  const peers: ListedMachine[] = [];
+  for (const raw of r.peers.slice(0, MAX_PEERS)) {
+    const m = (raw ?? {}) as Record<string, unknown>;
+    const id = str(m.id, 8);
+    const hostname = str(m.hostname, 253);
+    const publicKey = str(m.public_key, 1024);
+    if (!id || !MACHINE_ID.test(id) || !hostname || !publicKey) continue;
+    if (id === config.machineId) continue;
+    peers.push({
+      id,
+      name: clean(str(m.name, 500) ?? id, 80),
+      hostname,
+      publicKey,
+      lastSeenAt: str(m.last_seen_at, 64),
+      version: str(m.agent_os_version, 64),
+    });
+  }
+  return {
+    entitlements: entitlementsFrom(r.entitlements),
+    peersEtag: etagFrom(r.peers_etag),
+    peers,
+  };
 }
 
 export interface PushRequestBody {

package/lib/connect/heartbeat.ts

@@ -7,12 +7,14 @@
 
 import fs from "fs";
 import path from "path";
-import { ApiError, clean } from "./control-api";
+import { ApiError, clean, type Beat } from "./control-api";
 
 export const HEARTBEAT_MS = 60_000;
 
 export interface HeartbeatOptions {
-  beat: () => Promise<{ enabled: boolean }>;
+  beat: () => Promise<Beat>;
+  /** Every answer, for what it says about the account (plan, peers). */
+  onBeat?: (beat: Beat) => void;
   /** The account disabled this machine: stop the tunnel. */
   onDisabled: () => void;
   /** The service no longer knows this machine. */
@@ -43,9 +45,15 @@ export function startHeartbeat(opts: HeartbeatOptions) {
   const tick = async () => {
     timer = null;
     try {
-      const { enabled } = await opts.beat();
+      const answer = await opts.beat();
+      const { enabled } = answer;
       if (stopped) return;
       failing = false;
+      try {
+        opts.onBeat?.(answer);
+      } catch (err) {
+        log(`connect: ${clean((err as Error)?.message ?? String(err))}`);
+      }
       if (enabled === false) {
         stop();
         log("connect: this machine was disabled in your account; tunnel off");

package/lib/connect/serve.ts

@@ -40,6 +40,7 @@ import {
   type Tunnel,
 } from "./control-api";
 import { appVersion, startHeartbeat } from "./heartbeat";
+import { noteHeartbeat } from "@/lib/peer/account";
 import { ensureCloudflared } from "./cloudflared";
 import {
   reapTunnel,
@@ -331,6 +332,7 @@ export function startConnect(
     const version = appVersion();
     const heartbeat = startHeartbeat({
       beat: () => beat(config, machineKey, version),
+      onBeat: noteHeartbeat,
       log,
       intervalMs: deps.heartbeatMs,
       onDisabled: () => {

package/lib/db/migrations/20261020T1600_bus_waits.ts

@@ -0,0 +1,35 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261020T1600_bus_waits",
+  up: (db) => {
+    // A session waiting on another (lib/bus/waits): for its reply, or for it
+    // to go idle or merge. Closed rows stay as history.
+    db.exec(`CREATE TABLE IF NOT EXISTS bus_waits (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      waiter_id TEXT NOT NULL,
+      target_id TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      message_id INTEGER,
+      request TEXT,
+      deadline INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      seen_busy_at INTEGER,
+      nudged_at INTEGER,
+      closed_at INTEGER,
+      outcome TEXT,
+      reply_id INTEGER
+    )`);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_bus_waits_open ON bus_waits(target_id) WHERE closed_at IS NULL`
+    );
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_bus_waits_waiter ON bus_waits(waiter_id) WHERE closed_at IS NULL`
+    );
+    const cols = db.prepare(`PRAGMA table_info(bus_messages)`).all() as {
+      name: string;
+    }[];
+    if (!cols.some((c) => c.name === "reply_to"))
+      db.exec(`ALTER TABLE bus_messages ADD COLUMN reply_to INTEGER`);
+  },
+} satisfies Migration;

package/lib/db/types.ts

@@ -90,6 +90,10 @@ export interface Session {
   pause_id?: number | null;
   // Why a requested resume hasn't happened yet.
   pause_note?: string | null;
+  // Set only by GET /api/sessions: the sessions it waits on, and who waits on
+  // it, as a short line (lib/bus/waits/store).
+  waiting_on?: string | null;
+  waited_by?: string | null;
   placed_note?: string | null;
   // Set by done: hidden from the sidebar and the orchestrator, never deleted.
   archived_at: string | null;

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

package/lib/peer/cli.ts

@@ -0,0 +1,24 @@
+/** Entry for agent-os link / unlink (lib/peer/link-cli.ts). Argv: port, then the command. */
+
+import { createInterface } from "readline/promises";
+import { runLinkCli } from "./link-cli";
+
+const [port, ...args] = process.argv.slice(2);
+runLinkCli(args, {
+  base: `http://127.0.0.1:${Number(port) || 3011}`,
+  fetch,
+  out: (line) => console.log(line),
+  sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+  ask: async (prompt) => {
+    if (!process.stdin.isTTY) return null;
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    try {
+      return await rl.question(prompt);
+    } finally {
+      rl.close();
+    }
+  },
+}).then((code) => process.exit(code));

package/lib/peer/code.ts

@@ -0,0 +1,3 @@
+/** "482913" as people read it. Pure, for the browser too. */
+export const showCode = (code: string) =>
+  `${code.slice(0, 3)} ${code.slice(3)}`;

package/lib/peer/hello-route.ts

@@ -0,0 +1,32 @@
+/**
+ * The three public pairing routes: a body of at most 4 KiB, JSON, handed to
+ * the pairing code, and the answer never cached.
+ */
+
+import { NextResponse, type NextRequest } from "next/server";
+import { readCapped } from "../security/read-capped";
+import { HELLO_MAX_BYTES } from "./hello";
+import type { Reply } from "./pairing";
+
+export function helloRoute(
+  handle: (body: unknown, request: NextRequest) => Reply | Promise<Reply>
+) {
+  return async (request: NextRequest) => {
+    const raw = await readCapped(request, HELLO_MAX_BYTES);
+    let reply: Reply;
+    if (raw === null) reply = { status: 413, body: { error: "too large" } };
+    else {
+      let body: unknown = null;
+      try {
+        body = JSON.parse(raw);
+      } catch {
+        // parsed as nothing: refused as a bad message
+      }
+      reply = await handle(body, request);
+    }
+    return NextResponse.json(reply.body, {
+      status: reply.status,
+      headers: { "Cache-Control": "no-store" },
+    });
+  };
+}