@saadnvd1/agent-os 0.3.698 → 0.3.700

package/lib/bus/targets.ts

@@ -0,0 +1,122 @@
+/**
+ * Which live session a name someone typed reaches, across workspaces.
+ */
+
+import { db, type Session } from "../db";
+import { getProject } from "../projects";
+import { getWorkspace } from "../workspaces";
+import { previousNames } from "../session-names";
+import { sessionWorkspace } from "../schedules/store";
+import { heldTarget } from "./held-reply";
+import { resolveRef, type Candidate } from "./resolve";
+
+export function liveSessions(): Session[] {
+  return db
+    .prepare(
+      `SELECT * FROM session_rows WHERE (task_status IS NULL OR task_status = 'running')
+         AND archived_at IS NULL
+       ORDER BY updated_at DESC`
+    )
+    .all() as Session[];
+}
+
+export function candidates(sessions: Session[]): Candidate[] {
+  const old = previousNames();
+  const workspaces = new Map<string | null, string | null>();
+  const workspaceName = (s: Session) => {
+    const id = sessionWorkspace(s);
+    if (!workspaces.has(id))
+      workspaces.set(id, id ? (getWorkspace(id)?.name ?? null) : null);
+    return workspaces.get(id) ?? null;
+  };
+  return sessions.map((s) => ({
+    id: s.id,
+    name: s.name,
+    projectName: s.project_id ? (getProject(s.project_id)?.name ?? null) : null,
+    tmuxName: s.tmux_name,
+    previousNames: old.get(s.id) ?? [],
+    workspaceName: workspaceName(s),
+    orchestrator: s.role === "orchestrator",
+  }));
+}
+
+export const sessionById = (id: string | null | undefined) =>
+  id
+    ? (db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
+        Session | undefined)
+    : undefined;
+
+// The orchestrator a held caller's ref names, if it names it.
+export function resolveHeldOrchestrator(callerId: string, ref: string) {
+  return heldTarget(sessionById(callerId), ref);
+}
+
+// A live session by name, old name, project/name, id or id prefix. The note
+// says when the name meant something other than its current owner.
+export function resolveTarget(
+  ref: string,
+  callerId?: string | null
+): {
+  session: Session;
+  note?: string;
+} {
+  const found = tryResolveTarget(ref, callerId);
+  if (!found.ok) throw new Error(found.error);
+  return found;
+}
+
+// "orchestrator" / "my orchestrator": the caller's own workspace orchestrator.
+function ownOrchestrator(
+  ref: string,
+  sessions: Session[],
+  callerId?: string | null
+): Session | undefined {
+  if (!/^(my )?orchestrator$/i.test(ref.trim())) return undefined;
+  const workspace = sessionById(callerId)?.workspace_id;
+  if (!workspace) return undefined;
+  return sessions.find(
+    (s) => s.role === "orchestrator" && s.workspace_id === workspace
+  );
+}
+
+export function tryResolveTarget(
+  ref: string,
+  callerId?: string | null
+):
+  | { ok: true; session: Session; note?: string }
+  | { ok: false; none: boolean; error: string } {
+  const sessions = liveSessions();
+  const own = ownOrchestrator(ref, sessions, callerId);
+  if (own) return { ok: true, session: own };
+  const r = resolveRef(ref, candidates(sessions));
+  if (!r.ok) {
+    const orchestrators = /^(my )?orchestrator$/i.test(ref.trim())
+      ? sessions.filter((s) => s.role === "orchestrator")
+      : [];
+    if (orchestrators.length)
+      return {
+        ok: false,
+        none: true,
+        error: `You are in no workspace, so "${ref}" is ambiguous. Use <workspace>/orchestrator: ${orchestrators
+          .map(
+            (s) =>
+              `${getWorkspace(s.workspace_id ?? "")?.name ?? "?"}/orchestrator (${s.name}, id ${s.id.slice(0, 8)})`
+          )
+          .join(", ")}`,
+      };
+    return {
+      ok: false,
+      none: r.reason === "none",
+      error: r.reason === "none" ? `${r.error}. Run: aos peers` : r.error,
+    };
+  }
+  return {
+    ok: true,
+    session: sessions.find((s) => s.id === r.id)!,
+    note: r.note,
+  };
+}
+
+export function resolveSession(ref: string): Session {
+  return resolveTarget(ref).session;
+}

package/lib/bus/waits/kick.ts

@@ -0,0 +1,12 @@
+// Lets the places where a session ends ask for a look at open waits now,
+// without importing the bus. The watcher registers itself here.
+
+let kick: (() => void) | null = null;
+
+export function onKick(fn: () => void): void {
+  kick = fn;
+}
+
+export function kickWaits(): void {
+  kick?.();
+}

package/lib/bus/waits/lines.ts

@@ -0,0 +1,69 @@
+// Every text an agent reads about a wait. Each starts the way a bus message
+// does, so a line left unsent in a terminal's input is recognised as ours.
+
+import { shortId } from "../format";
+
+const from = "[AgentOS message from AgentOS]";
+const who = (name: string, id: string) => `"${name}" (${shortId(id)})`;
+
+export const minutes = (ms: number) =>
+  ms >= 3_600_000
+    ? `${Math.round(ms / 360_000) / 10}h`
+    : `${Math.max(1, Math.round(ms / 60_000))}m`;
+
+export function nudgeLine(
+  waiter: { id: string; name: string },
+  request: string | null,
+  messageId: number | null
+): string {
+  const reply = messageId ? ` --reply ${messageId}` : "";
+  return `${from} ${who(waiter.name, waiter.id)} is waiting on your reply${request ? ` to: "${request}"` : ""}. Reply with: aos send ${shortId(waiter.id)}${reply} "<message>"`;
+}
+
+export function timeoutLine(
+  target: { id: string; name: string },
+  kind: "reply" | "idle" | "merged",
+  waitedMs: number,
+  request: string | null,
+  targetIs: string
+): string {
+  const what =
+    kind === "reply"
+      ? `No reply from ${who(target.name, target.id)}${request ? ` to: "${request}"` : ""}`
+      : kind === "idle"
+        ? `${who(target.name, target.id)} didn't go idle`
+        : `${who(target.name, target.id)}'s PR didn't merge`;
+  return `${from} ${what} within ${minutes(waitedMs)}. The wait is closed; it is ${targetIs}. See what it did: aos read ${shortId(target.id)}`;
+}
+
+export const satisfiedLine = (
+  target: { id: string; name: string },
+  kind: "idle" | "merged",
+  pr?: number | null
+): string =>
+  `${from} ${
+    kind === "idle"
+      ? `${who(target.name, target.id)} is idle now`
+      : `${who(target.name, target.id)}'s PR${pr ? ` #${pr}` : ""} merged`
+  } (you waited for that). See what it did: aos read ${shortId(target.id)}`;
+
+export const endedLine = (
+  target: { id: string; name: string },
+  how: string,
+  request: string | null
+): string =>
+  `${from} ${who(target.name, target.id)} ended (${how}) with your wait still open${request ? ` on: "${request}"` : ""}. It won't answer.`;
+
+export const closedPrLine = (
+  target: { id: string; name: string },
+  pr: number | null
+): string =>
+  `${from} ${who(target.name, target.id)}'s PR${pr ? ` #${pr}` : ""} was closed without merging. The wait is closed.`;
+
+export const orchestratorTimeoutLine = (
+  waiter: string,
+  target: string,
+  waitedMs: number,
+  request: string | null
+): string =>
+  `session ${waiter} waited ${minutes(waitedMs)} on ${target} with no ${request ? `reply to "${request}"` : "result"}; it has been told`;

package/lib/bus/waits/register.ts

@@ -0,0 +1,83 @@
+// Registering a wait: `aos send --await` (in sendMessage) and `aos wait`.
+
+import { statusDetector } from "../../status-detector";
+import { statusOf } from "../../orchestrator/facts";
+import { duration } from "../../schedules/when";
+import { sessionById, tryResolveTarget } from "../targets";
+import {
+  DEFAULT_TIMEOUT_MS,
+  MAX_TIMEOUT_MS,
+  MIN_TIMEOUT_MS,
+  cantWaitOn,
+  openWait,
+  type WaitKind,
+} from "./store";
+
+// "30m", "2h", "1h30m"; empty is the default.
+export function parseTimeout(text: string | null | undefined): number {
+  const t = String(text ?? "").trim();
+  if (!t) return DEFAULT_TIMEOUT_MS;
+  const ms = duration(t.toLowerCase().replace(/([a-z])(?=\d)/g, "$1 "));
+  if (ms === null)
+    throw new Error(`Can't read the timeout "${t}": try 30m, 2h or 1h30m`);
+  if (ms < MIN_TIMEOUT_MS || ms > MAX_TIMEOUT_MS)
+    throw new Error("The timeout is between 1m and 24h");
+  return ms;
+}
+
+export const UNTILS = ["idle", "merged", "reply"] as const;
+export type Until = (typeof UNTILS)[number];
+
+export async function registerWait(opts: {
+  fromId: string;
+  to: string;
+  until: string;
+  timeout?: string | null;
+}): Promise<{
+  id?: number;
+  deadline?: number;
+  already?: string;
+  target: string;
+}> {
+  if (!(UNTILS as readonly string[]).includes(opts.until))
+    throw new Error("--until is idle, merged or reply");
+  const kind: WaitKind = opts.until as Until;
+  const timeoutMs = parseTimeout(opts.timeout);
+  const from = sessionById(opts.fromId);
+  if (!from) throw new Error("Unknown sender session");
+  const found = tryResolveTarget(opts.to, opts.fromId);
+  if (!found.ok) throw new Error(found.error);
+  const target = found.session;
+  if (target.id === from.id) throw new Error("A session can't wait on itself");
+  const why = cantWaitOn(target);
+  if (why) throw new Error(`Can't wait on ${target.name}: ${why}`);
+
+  if (kind === "merged") {
+    if (target.pr_status === "merged" || target.task_status === "merged")
+      return {
+        already: `${target.name}'s PR is already merged`,
+        target: target.name,
+      };
+    if (target.pr_status === "closed")
+      throw new Error(`${target.name}'s PR was closed without merging`);
+    if (!target.task_status && !target.pr_number && !target.branch_name)
+      throw new Error(
+        `${target.name} isn't a task and has no PR, so there is nothing to merge`
+      );
+  }
+  if (kind === "idle") {
+    await statusDetector.refreshCache();
+    if ((await statusOf(target)).status === "idle")
+      return { already: `${target.name} is idle now`, target: target.name };
+  }
+  const now = Date.now();
+  const deadline = now + timeoutMs;
+  const id = openWait({
+    waiterId: from.id,
+    targetId: target.id,
+    kind,
+    deadline,
+    now,
+  });
+  return { id, deadline, target: target.name };
+}

package/lib/bus/waits/store.ts

@@ -0,0 +1,196 @@
+/**
+ * Waits: session A waiting on session B, kept in `bus_waits`. A change of
+ * state is claimed with a conditional UPDATE and acted on only by the caller
+ * whose update changed a row, so overlapping sweeps and restarts never
+ * wake anyone twice.
+ */
+
+import { db, type Session } from "../../db";
+import { isHeldRemote } from "../../tasks/contract/held-calls";
+import { notifySessionsChanged } from "../../status/hub";
+
+export type WaitKind = "reply" | "idle" | "merged";
+export type WaitOutcome =
+  "replied" | "idle" | "merged" | "timeout" | "ended" | "cancelled";
+
+export interface WaitRow {
+  id: number;
+  waiter_id: string;
+  target_id: string;
+  kind: WaitKind;
+  message_id: number | null;
+  request: string | null;
+  deadline: number;
+  created_at: number;
+  seen_busy_at: number | null;
+  nudged_at: number | null;
+  closed_at: number | null;
+  outcome: WaitOutcome | null;
+  reply_id: number | null;
+}
+
+export const MAX_OPEN_WAITS = 10;
+export const DEFAULT_TIMEOUT_MS = 30 * 60_000;
+export const MIN_TIMEOUT_MS = 60_000;
+export const MAX_TIMEOUT_MS = 24 * 60 * 60_000;
+
+// A request shown in a line: one line, cut.
+export function excerpt(body: string, max = 100): string {
+  const one = body.replace(/\s+/g, " ").trim().replace(/"/g, "'");
+  return one.length <= max ? one : `${one.slice(0, max - 1)}…`;
+}
+
+export function openWait(w: {
+  waiterId: string;
+  targetId: string;
+  kind: WaitKind;
+  messageId?: number | null;
+  request?: string | null;
+  deadline: number;
+  now?: number;
+}): number {
+  const now = w.now ?? Date.now();
+  const open = db
+    .prepare(
+      `SELECT id FROM bus_waits WHERE waiter_id = ? AND target_id = ? AND kind = ? AND closed_at IS NULL`
+    )
+    .get(w.waiterId, w.targetId, w.kind) as { id: number } | undefined;
+  let id: number;
+  if (open) {
+    // The same wait again: the newer request and deadline stand.
+    db.prepare(
+      `UPDATE bus_waits SET message_id = ?, request = ?, deadline = ?, nudged_at = NULL WHERE id = ?`
+    ).run(w.messageId ?? null, w.request ?? null, w.deadline, open.id);
+    id = open.id;
+  } else {
+    const count = (
+      db
+        .prepare(
+          `SELECT COUNT(*) AS n FROM bus_waits WHERE waiter_id = ? AND closed_at IS NULL`
+        )
+        .get(w.waiterId) as { n: number }
+    ).n;
+    if (count >= MAX_OPEN_WAITS)
+      throw new Error(
+        `You already have ${MAX_OPEN_WAITS} waits open; wait for one to finish`
+      );
+    id = Number(
+      db
+        .prepare(
+          `INSERT INTO bus_waits (waiter_id, target_id, kind, message_id, request, deadline, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)`
+        )
+        .run(
+          w.waiterId,
+          w.targetId,
+          w.kind,
+          w.messageId ?? null,
+          w.request ?? null,
+          w.deadline,
+          now
+        ).lastInsertRowid
+    );
+  }
+  notifySessionsChanged();
+  return id;
+}
+
+// True for the one caller that closed it.
+export function claimClose(
+  id: number,
+  outcome: WaitOutcome,
+  replyId: number | null = null,
+  now = Date.now()
+): boolean {
+  const changed =
+    db
+      .prepare(
+        `UPDATE bus_waits SET closed_at = ?, outcome = ?, reply_id = ? WHERE id = ? AND closed_at IS NULL`
+      )
+      .run(now, outcome, replyId, id).changes === 1;
+  if (changed) notifySessionsChanged();
+  return changed;
+}
+
+export const claimNudge = (id: number, now = Date.now()): boolean =>
+  db
+    .prepare(
+      `UPDATE bus_waits SET nudged_at = ? WHERE id = ? AND closed_at IS NULL AND nudged_at IS NULL`
+    )
+    .run(now, id).changes === 1;
+
+export function markSeenBusy(id: number, now = Date.now()): void {
+  db.prepare(
+    `UPDATE bus_waits SET seen_busy_at = ? WHERE id = ? AND seen_busy_at IS NULL`
+  ).run(now, id);
+}
+
+export const openWaits = (): WaitRow[] =>
+  db
+    .prepare(`SELECT * FROM bus_waits WHERE closed_at IS NULL ORDER BY id`)
+    .all() as WaitRow[];
+
+// A reply from `targetId` to `waiterId` settles these.
+export const replyWaitsFor = (waiterId: string, targetId: string): WaitRow[] =>
+  db
+    .prepare(
+      `SELECT * FROM bus_waits WHERE waiter_id = ? AND target_id = ? AND kind = 'reply' AND closed_at IS NULL ORDER BY id`
+    )
+    .all(waiterId, targetId) as WaitRow[];
+
+export interface WaitBadges {
+  on: { id: string; name: string; kind: WaitKind; deadline: number }[];
+  by: { id: string; name: string }[];
+}
+
+// Who each session waits on, and who waits on it, for the open waits.
+export function waitBadges(): Map<string, WaitBadges> {
+  const rows = db
+    .prepare(
+      `SELECT w.waiter_id, w.target_id, w.kind, w.deadline,
+              COALESCE(a.name, 'a session') AS waiter_name,
+              COALESCE(b.name, 'a session') AS target_name
+       FROM bus_waits w
+       LEFT JOIN sessions a ON a.id = w.waiter_id
+       LEFT JOIN sessions b ON b.id = w.target_id
+       WHERE w.closed_at IS NULL ORDER BY w.id`
+    )
+    .all() as {
+    waiter_id: string;
+    target_id: string;
+    kind: WaitKind;
+    deadline: number;
+    waiter_name: string;
+    target_name: string;
+  }[];
+  const out = new Map<string, WaitBadges>();
+  const get = (id: string) => {
+    let b = out.get(id);
+    if (!b) out.set(id, (b = { on: [], by: [] }));
+    return b;
+  };
+  for (const r of rows) {
+    get(r.waiter_id).on.push({
+      id: r.target_id,
+      name: r.target_name,
+      kind: r.kind,
+      deadline: r.deadline,
+    });
+    get(r.target_id).by.push({ id: r.waiter_id, name: r.waiter_name });
+  }
+  return out;
+}
+
+// "B", "B and C", "B, C +2": for a sidebar chip.
+export function namesLine(names: string[]): string {
+  const unique = [...new Set(names)];
+  if (unique.length <= 2) return unique.join(" and ");
+  return `${unique.slice(0, 2).join(", ")} +${unique.length - 2}`;
+}
+
+// Why a wait on this session can't be kept, or null.
+export function cantWaitOn(to: Session): string | null {
+  if (isHeldRemote(to) || (to.peer_mirror && !to.task_prompt))
+    return "it runs on a linked machine, which can't tell this one when it answers";
+  return null;
+}

package/lib/bus/waits/tick.ts

@@ -0,0 +1,192 @@
+/**
+ * Settles open waits: nudges a target that went idle without answering,
+ * wakes a waiter whose condition holds, whose deadline passed or whose
+ * target ended. Replies settle in sendMessage; this covers the rest. It
+ * reads status through statusOf, the same idle test the orchestrator uses.
+ */
+
+import type { Session } from "../../db";
+import { db } from "../../db";
+import { statusDetector } from "../../status-detector";
+import { statusOf } from "../../orchestrator/facts";
+import { queueEventOnce } from "../../orchestrator/events";
+import { sessionWorkspace } from "../../schedules/store";
+import { sendMessage } from "../index";
+import { onKick } from "./kick";
+import {
+  claimClose,
+  claimNudge,
+  markSeenBusy,
+  openWaits,
+  type WaitRow,
+} from "./store";
+import {
+  closedPrLine,
+  endedLine,
+  nudgeLine,
+  orchestratorTimeoutLine,
+  satisfiedLine,
+  timeoutLine,
+} from "./lines";
+
+// A target that was never seen working is idle only this long after the
+// wait opened: a chat turn can start and end between two looks, and a
+// message may not have been picked up yet.
+export const IDLE_GRACE_MS = 20_000;
+// A terminal reads dead for a moment when tmux hiccups: twice in a row is gone.
+const DEAD_LOOKS = 2;
+const EVERY_MS = 5000;
+
+const dead = new Map<string, number>();
+
+const row = (id: string) =>
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
+    Session | undefined;
+
+// Why this session can no longer act on a wait, or null.
+function endedHow(s: Session | undefined): string | null {
+  if (!s) return "deleted";
+  if (s.archived_at) return "archived";
+  if (s.task_status === "moved" || s.task_status === "moving") return "moved";
+  if (s.task_status && s.task_status !== "running") return s.task_status;
+  return null;
+}
+
+async function tell(to: Session, line: string): Promise<void> {
+  try {
+    await sendMessage({
+      fromId: null,
+      fromLabel: "AgentOS",
+      to: to.id,
+      body: line,
+      line,
+    });
+  } catch (error) {
+    console.error(`[waits] couldn't tell ${to.name}:`, error);
+  }
+}
+
+async function settle(w: WaitRow, waiter: Session, now: number): Promise<void> {
+  const target = row(w.target_id);
+  const end = endedHow(target);
+  const prMerged =
+    target?.pr_status === "merged" || target?.task_status === "merged";
+
+  if (w.kind === "merged" && prMerged) {
+    if (claimClose(w.id, "merged", null, now))
+      await tell(waiter, satisfiedLine(target!, "merged", target!.pr_number));
+    return;
+  }
+  if (w.kind === "merged" && target?.pr_status === "closed") {
+    if (claimClose(w.id, "ended", null, now))
+      await tell(waiter, closedPrLine(target, target.pr_number));
+    return;
+  }
+  if (end || !target) {
+    if (claimClose(w.id, "ended", null, now))
+      await tell(
+        waiter,
+        endedLine(
+          target ?? { id: w.target_id, name: "the session" },
+          end ?? "deleted",
+          w.request
+        )
+      );
+    return;
+  }
+
+  const { status } = await statusOf(target);
+  if (status === "dead") {
+    const n = (dead.get(target.id) ?? 0) + 1;
+    dead.set(target.id, n);
+    if (n >= DEAD_LOOKS) {
+      if (claimClose(w.id, "ended", null, now))
+        await tell(
+          waiter,
+          endedLine(target, "its terminal is gone", w.request)
+        );
+      return;
+    }
+  } else dead.delete(target.id);
+
+  if (status === "running") markSeenBusy(w.id, now);
+  const idle =
+    status === "idle" &&
+    (w.seen_busy_at != null || now - w.created_at >= IDLE_GRACE_MS);
+
+  if (w.kind === "idle" && idle) {
+    if (claimClose(w.id, "idle", null, now))
+      await tell(waiter, satisfiedLine(target, "idle"));
+    return;
+  }
+
+  if (now >= w.deadline) {
+    if (!claimClose(w.id, "timeout", null, now)) return;
+    const is = status === "running" ? "still working" : status;
+    await tell(
+      waiter,
+      timeoutLine(target, w.kind, w.deadline - w.created_at, w.request, is)
+    );
+    const workspace = sessionWorkspace(waiter);
+    if (workspace && waiter.role !== "orchestrator")
+      queueEventOnce(
+        workspace,
+        `wait-timeout:${w.id}`,
+        waiter.id,
+        orchestratorTimeoutLine(
+          waiter.name,
+          target.name,
+          w.deadline - w.created_at,
+          w.request
+        )
+      );
+    return;
+  }
+
+  if (w.kind === "reply" && idle && !w.nudged_at && claimNudge(w.id, now))
+    await tell(target, nudgeLine(waiter, w.request, w.message_id));
+}
+
+let running = false;
+
+export async function waitsTick(now = Date.now()): Promise<void> {
+  if (running) return;
+  running = true;
+  try {
+    const waits = openWaits();
+    if (!waits.length) return;
+    await statusDetector.refreshCache();
+    for (const w of waits) {
+      try {
+        const waiter = row(w.waiter_id);
+        // A waiter that is gone has no one to tell.
+        if (!waiter || endedHow(waiter)) {
+          claimClose(w.id, "cancelled", null, now);
+          continue;
+        }
+        await settle(w, waiter, now);
+      } catch (error) {
+        console.error(`[waits] wait ${w.id}:`, error);
+      }
+    }
+  } finally {
+    running = false;
+  }
+}
+
+let timer: NodeJS.Timeout | null = null;
+let kicked = false;
+
+export function startWaitWatcher(): void {
+  if (timer) return;
+  timer = setInterval(() => void waitsTick(), EVERY_MS);
+  timer.unref();
+  onKick(() => {
+    if (kicked) return;
+    kicked = true;
+    setImmediate(() => {
+      kicked = false;
+      void waitsTick();
+    });
+  });
+}