@saadnvd1/agent-os 0.3.698 → 0.3.715

package/lib/peer/links.ts

@@ -64,16 +64,18 @@ export const pinForHost = (hostId: string): PeerPin | null =>
 
 /** Pins a peer's keys to a Connect host. Pairing (S2) is the only caller. */
 export function savePin(pin: Omit<PeerPin, "state" | "suspendedReason">) {
-  getDb()
-    .prepare(
-      `INSERT INTO peer_links (host_id, machine_id, hostname, sign_pub, box_pub)
+  const db = getDb();
+  db.prepare(`DELETE FROM peer_unlinked WHERE machine_id = ?`).run(
+    pin.machineId
+  );
+  db.prepare(
+    `INSERT INTO peer_links (host_id, machine_id, hostname, sign_pub, box_pub)
        VALUES (?, ?, ?, ?, ?)
        ON CONFLICT(host_id) DO UPDATE SET machine_id = excluded.machine_id,
          hostname = excluded.hostname, sign_pub = excluded.sign_pub,
          box_pub = excluded.box_pub, state = 'active', suspended_reason = NULL,
          paired_at = datetime('now'), last_error = NULL`
-    )
-    .run(pin.hostId, pin.machineId, pin.hostname, pin.signPub, pin.boxPub);
+  ).run(pin.hostId, pin.machineId, pin.hostname, pin.signPub, pin.boxPub);
 }
 
 export function suspendPin(hostId: string, reason: string) {
@@ -84,6 +86,112 @@ export function suspendPin(hostId: string, reason: string) {
     .run(reason, hostId);
 }
 
+export function resumePin(hostId: string) {
+  getDb()
+    .prepare(
+      `UPDATE peer_links SET state = 'active', suspended_reason = NULL WHERE host_id = ?`
+    )
+    .run(hostId);
+}
+
+/** Every pin, for checking them against the account (revoke.ts). */
+export const allPins = (): PeerPin[] =>
+  (getDb().prepare(SELECT).all() as Row[]).map((r) => toPin(r)!);
+
+/** How long an unlinked machine is still answered "unknown peer", signed. */
+export const UNLINKED_KEEP_MS = 30 * 24 * 3_600_000;
+
+export interface Unlinked {
+  machineId: string;
+  hostId: string | null;
+  signPub: string;
+  /** The other machine unlinked it, rather than a person here. */
+  byPeer: boolean;
+  reason: string;
+  at: number;
+}
+
+interface UnlinkedRow {
+  machine_id: string;
+  host_id: string | null;
+  sign_pub: string;
+  by_peer: number;
+  reason: string;
+  at: number;
+}
+
+const toUnlinked = (r: UnlinkedRow | undefined): Unlinked | null =>
+  r
+    ? {
+        machineId: r.machine_id,
+        hostId: r.host_id,
+        signPub: r.sign_pub,
+        byPeer: r.by_peer === 1,
+        reason: r.reason,
+        at: r.at,
+      }
+    : null;
+
+/** A machine unlinked here within the last 30 days, by its Connect id. */
+export const unlinkedMachine = (
+  machineId: string,
+  now = Date.now()
+): Unlinked | null =>
+  toUnlinked(
+    getDb()
+      .prepare(`SELECT * FROM peer_unlinked WHERE machine_id = ? AND at > ?`)
+      .get(machineId, now - UNLINKED_KEEP_MS) as UnlinkedRow | undefined
+  );
+
+export const unlinkedHost = (hostId: string): Unlinked | null =>
+  toUnlinked(
+    getDb()
+      .prepare(
+        `SELECT * FROM peer_unlinked WHERE host_id = ? ORDER BY at DESC LIMIT 1`
+      )
+      .get(hostId) as UnlinkedRow | undefined
+  );
+
+export const hasRecentUnlinked = (now = Date.now()): boolean =>
+  getDb()
+    .prepare(`SELECT 1 FROM peer_unlinked WHERE at > ? LIMIT 1`)
+    .get(now - UNLINKED_KEEP_MS) !== undefined;
+
+/**
+ * Removes a pin, keeping its signing key as unlinked (see the migration).
+ * The host stays: it may still hold sessions, and it says who unlinked it.
+ */
+export function dropPin(
+  hostId: string,
+  o: { byPeer: boolean; reason: string },
+  now = Date.now()
+): PeerPin | null {
+  const pin = pinForHost(hostId);
+  if (!pin) return null;
+  const db = getDb();
+  db.transaction(() => {
+    db.prepare(`DELETE FROM peer_unlinked WHERE at <= ?`).run(
+      now - UNLINKED_KEEP_MS
+    );
+    db.prepare(
+      `INSERT INTO peer_unlinked (machine_id, host_id, sign_pub, by_peer, reason, at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(machine_id) DO UPDATE SET host_id = excluded.host_id,
+         sign_pub = excluded.sign_pub, by_peer = excluded.by_peer,
+         reason = excluded.reason, at = excluded.at`
+    ).run(
+      pin.machineId,
+      hostId,
+      pin.signPub,
+      o.byPeer ? 1 : 0,
+      o.reason.slice(0, 200),
+      now
+    );
+    db.prepare(`DELETE FROM peer_links WHERE host_id = ?`).run(hostId);
+  })();
+  return pin;
+}
+
 /** Last outcome of a call to that peer, for Machines. */
 export function notePinResult(hostId: string, error: string | null) {
   getDb()
@@ -94,3 +202,7 @@ export function notePinResult(hostId: string, error: string | null) {
     )
     .run(...(error ? [error.slice(0, 300), hostId] : [hostId]));
 }
+
+/** The other machine, `name`, unlinked this one: its signed call or refusal. */
+export const unlinkedByPeer = (hostId: string, name: string): boolean =>
+  dropPin(hostId, { byPeer: true, reason: `Unlinked by ${name}` }) !== null;

package/lib/peer/machines.ts

@@ -0,0 +1,84 @@
+/**
+ * What Machines shows under "On your AgentOS account": the account's other
+ * machines, each with whether it's linked here, and the plan.
+ */
+
+import { getDb } from "../db";
+import { accountView } from "./account";
+import type { Entitlements } from "../connect/control-api";
+
+export interface AccountMachine {
+  id: string;
+  name: string;
+  hostname: string;
+  online: boolean;
+  lastSeenAt: string | null;
+  version: string | null;
+  /** The Machines host it's linked as, when it is. */
+  hostId: string | null;
+  linkState: "active" | "suspended" | null;
+  suspendedReason: string | null;
+}
+
+export interface AccountMachines {
+  enrolled: boolean;
+  entitlements: Entitlements | null;
+  fetchedAt: number;
+  error: string | null;
+  /** Set when the service hasn't answered for a day: since when. */
+  uncheckedSince: number | null;
+  machines: AccountMachine[];
+}
+
+// The service shows a machine online for three missed beats.
+const ONLINE_MS = 3 * 60_000;
+
+export async function accountMachines(
+  refresh = false,
+  now = Date.now()
+): Promise<AccountMachines> {
+  const view = await accountView(refresh ? 0 : undefined);
+  const pins = new Map(
+    (
+      getDb()
+        .prepare(
+          `SELECT p.machine_id, p.host_id, p.state, p.suspended_reason
+           FROM peer_links p
+           JOIN hosts h ON h.id = p.host_id WHERE h.kind = 'connect'`
+        )
+        .all() as {
+        machine_id: string;
+        host_id: string;
+        state: string;
+        suspended_reason: string | null;
+      }[]
+    ).map((r) => [r.machine_id, r])
+  );
+  return {
+    enrolled: view.enrolled,
+    entitlements: view.entitlements,
+    fetchedAt: view.fetchedAt,
+    error: view.error,
+    uncheckedSince: view.uncheckedSince,
+    machines: view.peers.map((p) => {
+      const pin = pins.get(p.id);
+      const seen = p.lastSeenAt ? Date.parse(p.lastSeenAt) : NaN;
+      return {
+        id: p.id,
+        name: p.name,
+        hostname: p.hostname,
+        online: Number.isFinite(seen) && now - seen < ONLINE_MS,
+        lastSeenAt: p.lastSeenAt,
+        version: p.version,
+        hostId: pin?.host_id ?? null,
+        linkState: pin
+          ? pin.state === "active"
+            ? "active"
+            : "suspended"
+          : null,
+        suspendedReason:
+          pin && pin.state !== "active" ? pin.suspended_reason : null,
+      };
+    }),
+  };
+}

package/lib/peer/name.ts

@@ -0,0 +1,32 @@
+/**
+ * A machine's name as the Connect service tells it, made safe to show next
+ * to a pairing code: plain text on one line, no direction overrides, short,
+ * and with no digits at all once it holds 4 or more, so a lying service
+ * can't name a machine "type 482, 913" and have the person type that
+ * instead. Separators can't be enumerated ("482 and 913"), so the count is
+ * over the whole name.
+ */
+
+export const NAME_MAX = 48;
+
+// C0/C1 controls, zero-width and joiner characters, bidi embeddings,
+// overrides and isolates, the byte-order mark.
+const INVISIBLE = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu;
+// Digits, any script.
+const DIGIT = /\p{Nd}/gu;
+const MAX_DIGITS = 3;
+
+export const UNNAMED = "Unnamed machine";
+
+export function cleanMachineName(raw: unknown): string {
+  if (typeof raw !== "string") return UNNAMED;
+  let s = raw
+    .normalize("NFKC")
+    .replace(/\s+/g, " ")
+    .replace(INVISIBLE, "")
+    .trim();
+  if ((s.match(DIGIT) ?? []).length > MAX_DIGITS) s = s.replace(DIGIT, "#");
+  if ([...s].length > NAME_MAX)
+    s = `${[...s].slice(0, NAME_MAX - 1).join("")}…`;
+  return s || UNNAMED;
+}

package/lib/peer/notify.ts

@@ -0,0 +1,32 @@
+/**
+ * What pairing tells the person: a request waiting for its code here, and a
+ * machine linked. Pushed to paired phones (or Telegram); never throws.
+ */
+
+import { notifyPhone } from "../notify";
+
+const short = (name: string) => name.replace(/\s+/g, " ").slice(0, 60);
+
+export function notifyLinkRequest(name: string) {
+  notifyPhone(
+    "peer-link",
+    `${short(name)} wants to link to this machine. Type the code it shows in Machines to allow it.`,
+    {
+      category: "system",
+      key: `peer-link:${Date.now()}`,
+      collapse: "peer-link",
+    }
+  );
+}
+
+export function notifyLinked(name: string) {
+  notifyPhone(
+    "peer-link",
+    `New machine linked: ${short(name)}. It can start agents and run code here; unlink it in Machines.`,
+    {
+      category: "system",
+      key: `peer-linked:${Date.now()}`,
+      collapse: "peer-link",
+    }
+  );
+}

package/lib/peer/pairing-out.ts

@@ -0,0 +1,382 @@
+/**
+ * Pairing, on the machine that asks (A): send the hello to the machine the
+ * account lists, check its answer is signed by the key the account lists
+ * for it, reveal, show the code, then ask every couple of seconds until a
+ * person on the other machine has typed it. B then shows a second code, and
+ * only that code typed here pins B: the account list alone never does, so a
+ * control plane that lists a key of its own for B can't get itself pinned.
+ */
+
+import { readCappedBytes } from "../hosts/read-capped-bytes";
+import { peerHostAllowed } from "./client";
+import { linkingAllowed, listedPeer, type AccountPeer } from "./account";
+import {
+  HELLO_MAX_BYTES,
+  commitTo,
+  deriveCode,
+  parseAck,
+  parseAnswer,
+  randomNonce,
+  sameCode,
+  signHello,
+  signReveal,
+  signStatusAsk,
+  typedCode,
+  verifyAck,
+  verifyAnswer,
+  type LinkState,
+} from "./hello";
+import { currentIdentity, loadBoxKey, type Identity } from "./keys";
+import { notifyLinked } from "./notify";
+import { MAX_WRONG, REQUEST_TTL_MS } from "./pairing";
+import { KEY_CHANGED, keysChanged, pinPeer } from "./pin";
+
+/** `confirm`: B took the code and shows its own, to be typed here. */
+export type OutState = LinkState | "confirm" | "failed";
+
+export interface Outgoing {
+  id: string;
+  machineId: string;
+  name: string;
+  code: string;
+  state: OutState;
+  error: string | null;
+  hostId: string | null;
+  attemptsLeft: number;
+  startedAt: number;
+  expiresAt: number;
+}
+
+interface Live extends Outgoing {
+  peer: AccountPeer;
+  requestId: string;
+  bBox: string;
+  confirmCode: string;
+  timer: NodeJS.Timeout | null;
+}
+
+export type Post = (
+  hostname: string,
+  path: string,
+  body: object
+) => Promise<{ status: number; json: unknown }>;
+
+export interface OutDeps {
+  identity: () => Identity | null;
+  boxPub: () => string;
+  listed: (machineId: string) => Promise<AccountPeer | null>;
+  allowed: () => Promise<boolean | null>;
+  post: Post;
+  pin: typeof pinPeer;
+  onLinked: (name: string) => void;
+  now: () => number;
+  pollMs: number;
+}
+
+/** POSTs JSON to the other machine's Connect name: no redirects, small answers. */
+export const httpsPost: Post = async (hostname, path, body) => {
+  if (!peerHostAllowed(hostname))
+    throw new Error("its address isn't a Connect machine's");
+  const res = await fetch(`https://${hostname}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    redirect: "error",
+    signal: AbortSignal.timeout(15_000),
+  });
+  const raw = await readCappedBytes(res, HELLO_MAX_BYTES);
+  let json: unknown = null;
+  try {
+    json = JSON.parse(raw.toString("utf8"));
+  } catch {
+    // not JSON: only the status says anything
+  }
+  return { status: res.status, json };
+};
+
+let box: string | null = null;
+export const realOutDeps = (): OutDeps => ({
+  identity: () => currentIdentity(),
+  boxPub: () => (box ??= loadBoxKey().publicRaw),
+  listed: listedPeer,
+  allowed: linkingAllowed,
+  post: httpsPost,
+  pin: pinPeer,
+  onLinked: notifyLinked,
+  now: Date.now,
+  pollMs: 2000,
+});
+
+const g = globalThis as unknown as { __agentosPairingOut?: Map<string, Live> };
+const links = () => (g.__agentosPairingOut ??= new Map());
+
+export const resetOutgoing = () => {
+  for (const l of links().values()) if (l.timer) clearTimeout(l.timer);
+  g.__agentosPairingOut = undefined;
+};
+
+const view = (l: Live): Outgoing => ({
+  id: l.id,
+  machineId: l.machineId,
+  name: l.name,
+  code: l.code,
+  state: l.state,
+  error: l.error,
+  hostId: l.hostId,
+  attemptsLeft: l.attemptsLeft,
+  startedAt: l.startedAt,
+  expiresAt: l.expiresAt,
+});
+
+export class LinkError extends Error {
+  constructor(
+    message: string,
+    readonly status = 400
+  ) {
+    super(message);
+  }
+}
+
+const theirError = (json: unknown, status: number) => {
+  const e = (json as { error?: unknown } | null)?.error;
+  return typeof e === "string"
+    ? e.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").slice(0, 200)
+    : `HTTP ${status}`;
+};
+
+/** Starts a link to an account machine; the answer carries the code to show. */
+export async function startLink(
+  machineId: string,
+  deps: OutDeps = realOutDeps()
+): Promise<Outgoing> {
+  const self = deps.identity();
+  if (!self)
+    throw new LinkError(
+      "This machine isn't connected to AgentOS Connect.",
+      409
+    );
+  if ((await deps.allowed()) !== true)
+    throw new LinkError("Linking machines needs AgentOS Connect Pro.", 402);
+  const peer = await deps.listed(machineId);
+  if (!peer)
+    throw new LinkError("That machine isn't on your AgentOS account.", 404);
+  if (!peerHostAllowed(peer.hostname))
+    throw new LinkError("Its address isn't a Connect machine's.", 502);
+  if (keysChanged(peer.id, peer)) throw new LinkError(KEY_CHANGED, 409);
+  for (const l of links().values())
+    if (l.machineId === machineId && open(l))
+      stop(l, "declined", "replaced by a new request");
+
+  const aNonce = randomNonce(32);
+  const aBox = deps.boxPub();
+  const hello = signHello(self.signKey, {
+    from: self.machineId,
+    to: peer.id,
+    ts: deps.now(),
+    nonce: randomNonce(16),
+    sign_pub: self.signPub,
+    box_pub: aBox,
+    commit: commitTo(aBox, self.signPub, aNonce),
+  });
+  const send = async (path: string, body: object) => {
+    try {
+      return await deps.post(peer.hostname, path, body);
+    } catch (err) {
+      throw new LinkError(
+        `Can't reach ${peer.name}: ${err instanceof Error ? err.message : String(err)}`,
+        502
+      );
+    }
+  };
+  const helloRes = await send("/api/peer/hello", hello);
+  if (helloRes.status !== 200)
+    throw new LinkError(
+      `${peer.name} said no: ${theirError(helloRes.json, helloRes.status)}`,
+      helloRes.status === 402 ? 402 : 502
+    );
+  const ack = parseAck(helloRes.json);
+  // Signed by the key the account lists for it, answering this hello.
+  if (!ack || !verifyAck(ack, hello, peer.signPub))
+    throw new LinkError(`${peer.name} answered with the wrong key.`, 502);
+  if (keysChanged(peer.id, { signPub: ack.sign_pub, boxPub: ack.box_pub }))
+    throw new LinkError(KEY_CHANGED, 409);
+
+  const reveal = signReveal(self.signKey, {
+    from: self.machineId,
+    to: peer.id,
+    ts: deps.now(),
+    nonce: randomNonce(16),
+    request_id: ack.request_id,
+    a_nonce: aNonce,
+  });
+  const revealRes = await send("/api/peer/hello/reveal", reveal);
+  const answer = parseAnswer(revealRes.json);
+  if (
+    revealRes.status !== 200 ||
+    !answer ||
+    !verifyAnswer(answer, reveal, peer.signPub) ||
+    answer.state !== "pending"
+  )
+    throw new LinkError(
+      `${peer.name} didn't take the request: ${theirError(revealRes.json, revealRes.status)}`,
+      502
+    );
+
+  const now = deps.now();
+  const transcript = {
+    from: self.machineId,
+    to: peer.id,
+    aSign: self.signPub,
+    aBox,
+    bSign: ack.sign_pub,
+    bBox: ack.box_pub,
+    aNonce,
+    bNonce: ack.b_nonce,
+  };
+  const live: Live = {
+    id: randomNonce(16),
+    machineId: peer.id,
+    name: peer.name,
+    code: deriveCode(transcript),
+    state: "pending",
+    error: null,
+    hostId: null,
+    attemptsLeft: MAX_WRONG,
+    startedAt: now,
+    expiresAt: now + REQUEST_TTL_MS,
+    peer,
+    requestId: ack.request_id,
+    bBox: ack.box_pub,
+    confirmCode: deriveCode(transcript, "confirm"),
+    timer: null,
+  };
+  links().set(live.id, live);
+  schedule(live, self, deps);
+  return view(live);
+}
+
+const open = (l: Live) => l.state === "pending" || l.state === "confirm";
+
+function stop(l: Live, state: OutState, error: string | null = null) {
+  if (l.timer) clearTimeout(l.timer);
+  l.timer = null;
+  l.state = state;
+  l.error = error;
+}
+
+function schedule(l: Live, self: Identity, deps: OutDeps) {
+  l.timer = setTimeout(() => void poll(l, self, deps), deps.pollMs);
+  l.timer.unref?.();
+}
+
+/** One status call; exported for tests that drive the clock. */
+export async function poll(l: Live, self: Identity, deps: OutDeps) {
+  l.timer = null;
+  if (l.state !== "pending") return;
+  if (deps.now() > l.expiresAt) return stop(l, "expired");
+  const ask = signStatusAsk(self.signKey, {
+    from: self.machineId,
+    to: l.machineId,
+    ts: deps.now(),
+    nonce: randomNonce(16),
+    request_id: l.requestId,
+  });
+  let answer = null;
+  try {
+    const res = await deps.post(l.peer.hostname, "/api/peer/hello/status", ask);
+    if (res.status === 404) return stop(l, "expired");
+    const a = parseAnswer(res.json);
+    if (res.status === 200 && a && verifyAnswer(a, ask, l.peer.signPub))
+      answer = a;
+    else l.error = `unexpected answer (HTTP ${res.status})`;
+  } catch (err) {
+    // Offline for a moment: keep asking until the request expires.
+    l.error = err instanceof Error ? err.message : String(err);
+  }
+  if (l.state !== "pending") return;
+  if (answer?.state === "accepted") {
+    // Nothing is pinned yet: B's say-so is only as good as its key, and the
+    // key came from the account list. The person types B's code here next.
+    stop(l, "confirm");
+    l.expiresAt = deps.now() + REQUEST_TTL_MS;
+    return;
+  }
+  if (answer && answer.state !== "pending") return stop(l, answer.state);
+  if (answer) l.error = null;
+  schedule(l, self, deps);
+}
+
+export function outgoingLink(id: string): Outgoing | null {
+  const l = links().get(id);
+  return l ? view(l) : null;
+}
+
+export type ConfirmResult =
+  | { ok: true; link: Outgoing }
+  | { ok: false; status: number; error: string; attemptsLeft?: number };
+
+/** The code the other machine shows once it took ours, typed here. */
+export function confirmLink(
+  id: string,
+  input: unknown,
+  deps: OutDeps = realOutDeps()
+): ConfirmResult {
+  const l = links().get(id);
+  if (l?.state === "confirm" && deps.now() > l.expiresAt) stop(l, "expired");
+  if (!l || l.state !== "confirm")
+    return {
+      ok: false,
+      status: 404,
+      error: "That request has ended. Start again.",
+    };
+  const code = typedCode(input);
+  if (!code)
+    return {
+      ok: false,
+      status: 400,
+      error: `Type the 6 digits ${l.name} shows.`,
+    };
+  if (!sameCode(code, l.confirmCode)) {
+    l.attemptsLeft -= 1;
+    if (l.attemptsLeft <= 0) {
+      stop(l, "failed", "wrong code 3 times");
+      return {
+        ok: false,
+        status: 403,
+        error: "Wrong code 3 times: nothing was linked here. Start again.",
+        attemptsLeft: 0,
+      };
+    }
+    return {
+      ok: false,
+      status: 403,
+      error: "That code doesn't match.",
+      attemptsLeft: l.attemptsLeft,
+    };
+  }
+  try {
+    l.hostId = deps.pin({
+      id: l.peer.id,
+      name: l.peer.name,
+      hostname: l.peer.hostname,
+      signPub: l.peer.signPub,
+      boxPub: l.bBox,
+    });
+  } catch (err) {
+    stop(l, "failed", err instanceof Error ? err.message : String(err));
+    return { ok: false, status: 409, error: l.error! };
+  }
+  stop(l, "accepted");
+  deps.onLinked(l.name);
+  return { ok: true, link: view(l) };
+}
+
+export function cancelLink(id: string): boolean {
+  const l = links().get(id);
+  if (!l || !open(l)) return false;
+  stop(l, "declined", "cancelled here");
+  return true;
+}
+
+/** Tests: the live record behind a view, to drive poll() by hand. */
+export const _live = (id: string) => links().get(id) ?? null;