@saadnvd1/agent-os 0.3.459 → 0.3.461

package/lib/orchestrator/pr-wake.ts

@@ -0,0 +1,385 @@
+/**
+ * Wakes a task's own agent when its PR needs it, so the orchestrator
+ * doesn't have to pass the news on. Runs in the watcher's merge pipeline,
+ * off the PR poll AgentOS already makes (no poller of its own):
+ *
+ * - A failing check on the PR's head: the task hears it once per head,
+ *   with the check's name, the failing step and the log around the error
+ *   (`gh run view --log-failed`, trimmed). Read from the rollup the poll
+ *   already has, so only the log costs a call.
+ * - A review or conversation comment from a collaborator other than the
+ *   account gh runs as (which is the task's own): one GraphQL query per
+ *   repository a minute fingerprints every watched PR, and a PR's reviews
+ *   and comments are read only when its fingerprint moved. Comment-only
+ *   wakes stop at COMMENT_WAKE_CAP a task; changes requested always wake.
+ *
+ * Each event is claimed in task_pr_wakes before its message goes, so it's
+ * sent once across restarts. Messages go through the bus like any other:
+ * a task mid-turn gets it queued, never interrupted. The orchestrator hears
+ * one line per wake. Only open PRs of running tasks are watched: merged,
+ * closed, dropped or done stops it. Off per workspace in Settings.
+ */
+
+import { db, type Session } from "../db";
+import { sendMessage } from "../bus";
+import { getWorkspace } from "../workspaces";
+import { OPEN_TTL_MS } from "../tasks/pr-poll";
+import {
+  failedLog,
+  fingerprints,
+  prActivity,
+  repoOfPR,
+  type FailedLog,
+  type Fingerprint,
+  type PREvent,
+  type Repo,
+} from "../tasks/pr-activity";
+import type { TaskPR } from "../tasks/state";
+import { ciKey, conditionKey } from "./conditions";
+import { markTold, queueEvent } from "./events";
+import type { SessionFacts } from "./facts";
+import { isPaused } from "./pause";
+import { repoOf } from "./repo";
+import { untrusted, UNTRUSTED_RULE } from "./untrusted";
+
+export const COMMENT_WAKE_CAP = 10;
+// A first look at a PR this young takes its whole history as new.
+const YOUNG_PR_MS = 10 * 60_000;
+// Collaborators only: anyone can comment on a public repository's PR.
+const TRUSTED = new Set(["OWNER", "MEMBER", "COLLABORATOR"]);
+const BODY_MAX = 800;
+const NOTE_MAX = 300;
+const NOTES_MAX = 10;
+const SEND_TRIES = 3;
+
+export interface WakeDeps {
+  fingerprints: typeof fingerprints;
+  activity: typeof prActivity;
+  failedLog: typeof failedLog;
+  // Message the task's agent through the bus; throws when it failed.
+  send: (task: Session, body: string) => Promise<unknown>;
+}
+
+// As an AgentOS event, through the bus: queued while the agent is mid-turn.
+export async function sendWake(task: Session, body: string) {
+  const { delivery } = await sendMessage({
+    fromId: null,
+    to: task.id,
+    body,
+    fromLabel: "AgentOS",
+    origin: { kind: "event", label: "AgentOS", body },
+    // A chat agent reads it whole; a terminal's is told to read its inbox.
+    line: task.view === "chat" ? `[AgentOS event] ${body}` : undefined,
+  });
+  if (delivery.state === "failed") throw new Error(delivery.why);
+  return delivery.state;
+}
+
+const defaults: WakeDeps = {
+  fingerprints,
+  activity: prActivity,
+  failedLog,
+  send: sendWake,
+};
+
+const short = (sha: string) => sha.slice(0, 7);
+const clip = (s: string, n: number) => (s.length > n ? `${s.slice(0, n)}…` : s);
+
+// The fingerprint each task's PR was last handled at, and when each
+// repository was last fingerprinted.
+const handled = new Map<string, string>();
+const polled = new Map<string, number>();
+// Sends that failed, per task and key, so a broken one stops retrying.
+const failures = new Map<string, number>();
+
+const sessionRow = (id: string) =>
+  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+    | Session
+    | undefined;
+
+// True when this call took the key; false when it was taken before.
+const claim = (task: string, key: string, kind: string) =>
+  db
+    .prepare(
+      `INSERT OR IGNORE INTO task_pr_wakes (session_id, key, kind) VALUES (?, ?, ?)`
+    )
+    .run(task, key, kind).changes > 0;
+
+const taken = (task: string, key: string) =>
+  !!db
+    .prepare(`SELECT 1 FROM task_pr_wakes WHERE session_id = ? AND key = ?`)
+    .get(task, key);
+
+const unclaim = (task: string, keys: string[]) => {
+  const del = db.prepare(
+    `DELETE FROM task_pr_wakes WHERE session_id = ? AND key = ?`
+  );
+  for (const key of keys) del.run(task, key);
+};
+
+export const commentWakes = (task: string) =>
+  (
+    db
+      .prepare(
+        `SELECT COUNT(*) AS n FROM task_pr_wakes WHERE session_id = ? AND kind = 'comment'`
+      )
+      .get(task) as { n: number }
+  ).n;
+
+interface Watched {
+  task: Session;
+  pr: TaskPR & { head: string };
+  repo: Repo;
+  dir: string;
+}
+
+export async function wakeTasks(
+  workspaceId: string,
+  facts: SessionFacts[],
+  deps: WakeDeps = defaults,
+  now = Date.now()
+): Promise<void> {
+  if (!getWorkspace(workspaceId)?.wake_tasks_on_pr || isPaused(workspaceId))
+    return;
+  const watched: Watched[] = [];
+  for (const f of facts) {
+    const pr = f.task?.pr;
+    const task = pr?.state === "OPEN" && pr.head ? sessionRow(f.id) : null;
+    const repo = pr && repoOfPR(pr.url);
+    if (!task || task.task_status !== "running" || !repo || !pr?.head) {
+      handled.delete(f.id);
+      continue;
+    }
+    let dir: string;
+    try {
+      dir = repoOf(task);
+    } catch {
+      continue;
+    }
+    watched.push({ task, pr: { ...pr, head: pr.head }, repo, dir });
+  }
+
+  for (const w of watched) {
+    if (isPaused(workspaceId)) return;
+    if (w.pr.checks !== "fail" || !w.pr.failing) continue;
+    await wakeOnCheck(workspaceId, w, deps).catch((error) =>
+      console.error(`Waking ${w.task.name} on CI:`, error)
+    );
+  }
+
+  const byRepo = new Map<string, Watched[]>();
+  for (const w of watched) {
+    const slug = `${w.repo.owner}/${w.repo.name}`;
+    byRepo.set(slug, [...(byRepo.get(slug) ?? []), w]);
+  }
+  for (const [slug, group] of byRepo) {
+    if (isPaused(workspaceId)) return;
+    if (now - (polled.get(slug) ?? 0) < OPEN_TTL_MS) continue;
+    polled.set(slug, now);
+    let prints: Map<number, Fingerprint>;
+    try {
+      prints = await deps.fingerprints(
+        group[0].dir,
+        group[0].repo,
+        group.map((w) => w.pr.number)
+      );
+    } catch (error) {
+      console.error(`Fingerprinting PRs in ${slug}:`, error);
+      continue;
+    }
+    for (const w of group) {
+      const print = prints.get(w.pr.number);
+      if (!print || handled.get(w.task.id) === print.print) continue;
+      try {
+        if (await wakeOnReviews(workspaceId, w, print, deps, now))
+          handled.set(w.task.id, print.print);
+      } catch (error) {
+        console.error(`Waking ${w.task.name} on reviews:`, error);
+      }
+    }
+  }
+}
+
+// Whether the task is still to be woken now, after the gh calls since it
+// was read: not paused or turned off, and the task still running.
+const stillWatched = (workspaceId: string, taskId: string) =>
+  !isPaused(workspaceId) &&
+  !!getWorkspace(workspaceId)?.wake_tasks_on_pr &&
+  sessionRow(taskId)?.task_status === "running";
+
+// Sends after claiming `keys`; a failed send gives them back for the next
+// poll, SEND_TRIES times. False when it didn't go.
+async function wake(
+  workspaceId: string,
+  w: Watched,
+  keys: string[],
+  body: string,
+  deps: WakeDeps
+): Promise<boolean> {
+  if (!stillWatched(workspaceId, w.task.id)) {
+    unclaim(w.task.id, keys);
+    return false;
+  }
+  try {
+    await deps.send(w.task, body);
+    return true;
+  } catch (error) {
+    const id = `${w.task.id}\0${keys[0]}`;
+    const n = (failures.get(id) ?? 0) + 1;
+    failures.set(id, n);
+    console.error(`Messaging ${w.task.name} (try ${n}):`, error);
+    if (n < SEND_TRIES) unclaim(w.task.id, keys);
+    return false;
+  }
+}
+
+async function wakeOnCheck(
+  workspaceId: string,
+  w: Watched,
+  deps: WakeDeps
+): Promise<void> {
+  const { task, pr } = w;
+  const key = `check:${pr.head}`;
+  if (taken(task.id, key)) return;
+  const log: FailedLog | null = await deps
+    .failedLog(w.dir, w.repo, pr.failingUrl)
+    .catch((error: unknown) => {
+      console.error(`Reading ${task.name}'s CI log:`, error);
+      return null;
+    });
+  // Claimed only now, next to the send, so a restart while the log is
+  // read doesn't lose the wake.
+  if (!claim(task.id, key, "check")) return;
+  if (!(await wake(workspaceId, w, [key], checkMessage(pr, log), deps))) return;
+  queueEvent(
+    workspaceId,
+    `woke:${task.id}:${key}`,
+    task.id,
+    `task ${task.name} woken: CI ${untrusted("CI", pr.failing!)} failed at ${short(pr.head)}`
+  );
+  // The orchestrator's own "CI failed" line for this head would only
+  // repeat it.
+  markTold(workspaceId, conditionKey(ciKey(pr), task.id), task.id);
+}
+
+export function checkMessage(
+  pr: TaskPR & { head: string },
+  log: FailedLog | null
+): string {
+  const step = log?.step ? ` at step ${untrusted("CI", log.step)}` : "";
+  const tail = log?.tail
+    ? `\n\nThe log around the error:\n${untrusted("CI log", log.tail)}`
+    : pr.failingUrl
+      ? `\n\nIts details: ${untrusted("CI", pr.failingUrl)}`
+      : "";
+  return `CI check ${untrusted("CI", pr.failing ?? "")} failed on your PR #${pr.number} at ${short(pr.head)}${step}.${tail}\n\n${UNTRUSTED_RULE}\n\nFix the root cause (not the check), re-run your checks, push, then run /do-code-review again and update the Reviewed: line in the PR body for the new head.`;
+}
+
+// True once the PR's activity at this fingerprint has been handled.
+async function wakeOnReviews(
+  workspaceId: string,
+  w: Watched,
+  print: Fingerprint,
+  deps: WakeDeps,
+  now: number
+): Promise<boolean> {
+  const { task, pr } = w;
+  const since = Date.parse(watchSince(task, print, now));
+  const activity = await deps.activity(w.dir, w.repo, pr.number);
+  const fresh = activity.events.filter(
+    (e) =>
+      e.author !== activity.viewer &&
+      TRUSTED.has(e.association) &&
+      Date.parse(e.at) >= since &&
+      worthWaking(e) &&
+      !taken(task.id, `event:${e.id}`)
+  );
+  if (!fresh.length) return true;
+  const changes = fresh.some((e) => e.state === "CHANGES_REQUESTED");
+  const kind = changes ? "review" : "comment";
+  const keys = fresh.map((e) => `event:${e.id}`);
+  if (!changes && commentWakes(task.id) >= COMMENT_WAKE_CAP) {
+    for (const key of keys) claim(task.id, key, "event");
+    if (claim(task.id, "capped", "capped"))
+      queueEvent(
+        workspaceId,
+        `woke:${task.id}:capped`,
+        task.id,
+        `task ${task.name}: ${COMMENT_WAKE_CAP} comment wakes on PR #${pr.number} reached; further comments won't wake it`
+      );
+    return true;
+  }
+  const wakeKey = `wake:${fresh[0].id}`;
+  const claimed = [wakeKey, ...keys].filter((key, i) =>
+    claim(task.id, key, i === 0 ? kind : "event")
+  );
+  if (!claimed.includes(wakeKey)) return true;
+  if (!(await wake(workspaceId, w, claimed, reviewMessage(pr, fresh), deps)))
+    return false;
+  const who = [...new Set(fresh.map((e) => e.author))].join(", ");
+  queueEvent(
+    workspaceId,
+    `woke:${task.id}:${wakeKey}`,
+    task.id,
+    `task ${task.name} woken: ${changes ? "changes requested" : fresh.length === 1 ? "a review comment" : `${fresh.length} review comments`} on PR #${pr.number} from ${who}`
+  );
+  return true;
+}
+
+// An approval or a dismissed review with nothing to say asks for nothing.
+const worthWaking = (e: PREvent) =>
+  e.state !== "PENDING" &&
+  e.state !== "DISMISSED" &&
+  (e.state === "CHANGES_REQUESTED" || !!e.body.trim() || e.notes.length > 0);
+
+// When this PR's reviews started being watched, set on the first look:
+// a young PR from its start, an older one from now, so what was said
+// before this watched it isn't news.
+function watchSince(task: Session, print: Fingerprint, now: number): string {
+  if (task.pr_wake_since) return task.pr_wake_since;
+  const created = Date.parse(print.createdAt);
+  const since =
+    Number.isFinite(created) && now - created < YOUNG_PR_MS
+      ? new Date(created).toISOString()
+      : new Date(now).toISOString();
+  db.prepare(`UPDATE sessions SET pr_wake_since = ? WHERE id = ?`).run(
+    since,
+    task.id
+  );
+  task.pr_wake_since = since;
+  return since;
+}
+
+export function reviewMessage(pr: TaskPR, events: PREvent[]): string {
+  const items = events.map((e) => {
+    const what =
+      e.state === "CHANGES_REQUESTED"
+        ? "requested changes"
+        : e.kind === "review"
+          ? "reviewed"
+          : "commented";
+    const body = e.body.trim()
+      ? `: ${untrusted(e.author, clip(e.body.trim(), BODY_MAX))}`
+      : "";
+    const notes = e.notes
+      .slice(0, NOTES_MAX)
+      .map(
+        (n) =>
+          `\n  - ${n.path}${n.line ? `:${n.line}` : ""}: ${untrusted(e.author, clip(n.body.trim(), NOTE_MAX))}`
+      )
+      .join("");
+    const more =
+      e.notes.length > NOTES_MAX
+        ? `\n  - and ${e.notes.length - NOTES_MAX} more on the PR`
+        : "";
+    return `- ${e.author} ${what}${body}${notes}${more}`;
+  });
+  return `New review activity on your PR #${pr.number}:\n${items.join("\n")}\n\n${UNTRUSTED_RULE} Address each point: fix what's right, re-run your checks, push, then run /do-code-review again and update the Reviewed: line for the new head. Where you disagree, reply on the PR (\`gh pr comment ${pr.number}\`) saying why.`;
+}
+
+// Tests only.
+export function resetPRWake(): void {
+  handled.clear();
+  polled.clear();
+  failures.clear();
+}

package/lib/orchestrator/watcher.ts

@@ -17,6 +17,8 @@ import { settleStaleAsks } from "./ask-settle";
 import { brakesOn, liftBrake } from "./brakes";
 import { anyArmed, mergeArmed } from "./armed";
 import { rebaseConflicting } from "./rebase";
+import { wakeTasks } from "./pr-wake";
+import { awayTick } from "../away/run";
 
 // Asks that stopped needing Saad: their task or PR finished some other
 // way, or brakes lifted with nothing trying to start.
@@ -61,8 +63,8 @@ export async function diffWorkspace(
   return nextDiffAt(now, facts, working);
 }
 
-// Rebases what conflicts with its base, then merges what's armed and
-// passes. In the background, one run per workspace at a time, so a git
+// Wakes tasks whose PRs failed CI or got reviews, rebases what conflicts
+// with its base, then merges what's armed and passes. In the background, one run per workspace at a time, so a git
 // fetch or a merge never holds up event delivery.
 const piping = new Set<string>();
 
@@ -70,6 +72,9 @@ function mergePipeline(workspaceId: string, facts: SessionFacts[]): void {
   if (piping.has(workspaceId)) return;
   piping.add(workspaceId);
   void (async () => {
+    await wakeTasks(workspaceId, facts).catch((error) =>
+      console.error(`Waking tasks in ${workspaceId}:`, error)
+    );
     await rebaseConflicting(workspaceId, facts);
     await mergeArmed(workspaceId, facts);
   })()
@@ -97,6 +102,11 @@ async function tick(): Promise<void> {
   if (busy) return;
   busy = true;
   try {
+    try {
+      awayTick();
+    } catch (error) {
+      console.error("Away mode:", error);
+    }
     for (const orch of listOrchestrators()) {
       const workspaceId = orch.workspace_id;
       if (!workspaceId || !getWorkspace(workspaceId)) continue;

package/lib/project-config/agentos.schema.json

@@ -73,6 +73,30 @@
       },
       "additionalProperties": false
     },
+    "deploy": {
+      "type": "object",
+      "properties": {
+        "deployed": {
+          "type": "string",
+          "minLength": 1
+        },
+        "failed": {
+          "type": "string",
+          "minLength": 1
+        },
+        "health": {
+          "type": "string",
+          "minLength": 1
+        },
+        "within_minutes": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 1440
+        }
+      },
+      "required": ["deployed"],
+      "additionalProperties": false
+    },
     "test": {
       "type": "string",
       "minLength": 1

package/lib/project-config/schema.ts

@@ -38,6 +38,22 @@ const ready = z.strictObject({
   contains: z.string().optional(),
 });
 
+// How Away mode checks a merge went live (lib/away/deploy.ts): a file the
+// deploy writes the deployed commit to, one it writes a commit whose deploy
+// failed to, and a URL that answers 2xx when the server is healthy (a path
+// alone is this AgentOS server's own).
+const deploy = z.strictObject({
+  deployed: z.string().min(1),
+  failed: z.string().min(1).optional(),
+  health: z.string().min(1).optional(),
+  within_minutes: z
+    .number()
+    .int()
+    .min(1)
+    .max(24 * 60)
+    .optional(),
+});
+
 const browse = z.strictObject({
   login: z.string().min(1).optional(),
   map: projectPath.optional(),
@@ -89,6 +105,7 @@ const shape = {
   clone: z.array(projectPath).optional(),
   dev: z.string().min(1).optional(),
   ready: ready.optional(),
+  deploy: deploy.optional(),
   test: z.string().min(1).optional(),
   notes: notes.optional(),
   browse: browse.optional(),

package/lib/tasks/gh.ts

@@ -6,6 +6,7 @@ import { assertGhAllowed, noteGhFailure, noteGhSuccess } from "./gh-limit";
 import {
   checksVerdict,
   failingCheck,
+  failingUrl,
   rerunsToLookUp,
   settleReruns,
   type ActionsRun,
@@ -106,6 +107,7 @@ export async function toTaskPR(repoDir: string, pr: ListedPR): Promise<TaskPR> {
     checks: checksVerdict(rollup),
     head: pr.headRefOid,
     failing: failingCheck(rollup),
+    failingUrl: failingUrl(rollup),
     checkCount: (pr.statusCheckRollup ?? []).length,
     codeReview: pr.body === undefined ? undefined : parseCodeReview(pr.body),
     scopeChange: parseScopeChange(pr.body),