@saadnvd1/agent-os 0.3.509 → 0.3.512

package/lib/start-options.ts

@@ -0,0 +1,93 @@
+/**
+ * What the start form needs in one request: the agents and their models, the
+ * models a task can run on, the machines, the default branch and whether a
+ * task plans first. Built from the helpers the web form already uses; never
+ * a provider's address or key reference, nor a machine's ssh target.
+ */
+
+import { AGENT_OPTIONS } from "./agent-options";
+import { probeAgents } from "./agents/probe";
+import { gitCheck } from "./git";
+import { listHosts } from "./hosts";
+import { projectMachines } from "./hosts/project-machines";
+import { getModelOptions, getDefaultModelForAgent } from "./model-catalog";
+import { effectiveModels } from "./models/config";
+import { modelChoices } from "./models/choices";
+import { resolveRole } from "./models/resolve";
+import { getProject } from "./projects";
+import { expandHome } from "./tasks/session";
+import { taskRouting } from "./tasks";
+import type { StartOptions } from "./tasks/loop-types";
+
+const BRANCHES_MAX = 50;
+
+export class UnknownProjectError extends Error {}
+
+export async function startOptions(
+  projectId: string | null
+): Promise<StartOptions> {
+  const project = projectId ? getProject(projectId) : undefined;
+  if (projectId && (!project || project.is_uncategorized))
+    throw new UnknownProjectError("Project not found");
+  const here = !project || (project.host_id || "local") === "local";
+  const models = effectiveModels();
+
+  let planDefault = false;
+  let planError: string | null = null;
+  const roles = { plan: "", implement: "" };
+  try {
+    const opts = { workspaceId: project?.workspace_id ?? null };
+    roles.plan = resolveRole("plan", opts, models).ref;
+    roles.implement = resolveRole("implement", opts, models).ref;
+    planDefault = taskRouting(opts.workspaceId, "chat", undefined).plan;
+  } catch (error) {
+    planError = error instanceof Error ? error.message : String(error);
+  }
+
+  const [probes, git, machines] = await Promise.all([
+    here ? probeAgents() : Promise.resolve(null),
+    project && here
+      ? gitCheck(expandHome(project.working_directory))
+      : Promise.resolve(null),
+    project
+      ? projectMachines(project)
+      : Promise.resolve<Record<string, string | null>>({}),
+  ]);
+
+  return {
+    project: project
+      ? {
+          id: project.id,
+          name: project.name,
+          agentType: project.agent_type,
+          defaultModel: project.default_model,
+          hostId: project.host_id || "local",
+        }
+      : null,
+    agents: AGENT_OPTIONS.map((a) => ({
+      value: a.value,
+      label: a.label,
+      installed: probes?.[a.value]?.installed ?? null,
+      auth: probes?.[a.value]?.auth ?? null,
+      hint: probes?.[a.value]?.hint ?? null,
+      models: getModelOptions(a.value),
+      defaultModel: getDefaultModelForAgent(a.value),
+    })),
+    taskModels: modelChoices(models),
+    roles,
+    planDefault,
+    planError,
+    hosts: listHosts().map((h) => ({
+      id: h.id,
+      name: h.name,
+      linked: h.id === "local" || Boolean(h.linked),
+      unavailable: machines[h.id] ?? null,
+    })),
+    git: git && {
+      isGitRepo: git.isGitRepo,
+      defaultBranch: git.defaultBranch,
+      currentBranch: git.currentBranch,
+      branches: git.branches.slice(0, BRANCHES_MAX),
+    },
+  };
+}

package/lib/tasks/checks-view.ts

@@ -0,0 +1,192 @@
+/**
+ * A task's PR checks for the phone: each check's name, state, link and
+ * duration, the tail of a failing Actions job's log (the same one AgentOS
+ * sends a task when its CI fails), and the review gate's verdict on the head.
+ * Log and verdict text is untrusted: displayed, never run.
+ */
+
+import { getCheck } from "../orchestrator/checks";
+import { restackedOf } from "../orchestrator/signoff";
+import { run, settledRollup } from "./gh";
+import { failedLog, repoOfPR, type FailedLog } from "./pr-activity";
+import { prFor, projectPathFor, storedPR } from "./session";
+import type { RollupEntry } from "./state";
+import {
+  CHECK_LOGS_MAX,
+  CHECK_LOG_MAX_BYTES,
+  parseReviewDetail,
+  type CheckState,
+  type TaskCheck,
+  type TaskChecks,
+  type TaskReviewVerdict,
+} from "./loop-types";
+import type { Session } from "../db";
+
+const outcome = (c: RollupEntry) =>
+  (c.conclusion || c.state || c.status || "").toUpperCase();
+
+export function checkState(c: RollupEntry): CheckState {
+  switch (outcome(c)) {
+    case "SUCCESS":
+      return "pass";
+    case "FAILURE":
+    case "ERROR":
+    case "TIMED_OUT":
+    case "ACTION_REQUIRED":
+      return "fail";
+    case "SKIPPED":
+      return "skipped";
+    case "CANCELLED":
+      return "cancelled";
+    case "NEUTRAL":
+    case "STALE":
+      return "neutral";
+    default:
+      return "pending";
+  }
+}
+
+// gh gives a run not finished yet a zero completedAt (0001-01-01).
+const time = (t?: string | null) => {
+  const ms = Date.parse(t || "");
+  return ms > 0 ? ms : null;
+};
+const iso = (t?: string | null) => {
+  const ms = time(t);
+  return ms === null ? null : new Date(ms).toISOString();
+};
+
+// A status context can carry any URL; only a web one is a link.
+const httpsUrl = (u?: string | null) =>
+  u && /^https:\/\/[^\s]+$/.test(u) ? u : null;
+
+export function toTaskChecks(rollup: RollupEntry[]): TaskCheck[] {
+  return rollup.map((c) => {
+    const start = time(c.startedAt);
+    const end = time(c.completedAt);
+    return {
+      name: c.name ?? c.context ?? "(unnamed)",
+      workflow: c.workflowName || null,
+      state: checkState(c),
+      conclusion: (c.conclusion || c.state || null)?.toLowerCase() ?? null,
+      url: httpsUrl(c.detailsUrl),
+      startedAt: iso(c.startedAt),
+      completedAt: iso(c.completedAt),
+      durationSec:
+        start !== null && end !== null && end >= start
+          ? Math.round((end - start) / 1000)
+          : null,
+    };
+  });
+}
+
+// A finished job's log never changes.
+const logCache = new Map<string, FailedLog | null>();
+const LOG_CACHE_MAX = 200;
+export const resetLogCache = () => logCache.clear();
+
+export interface ChecksDeps {
+  failedLog: typeof failedLog;
+}
+
+export async function taskChecks(
+  session: Session,
+  opts: { logs?: boolean; deps?: ChecksDeps } = {}
+): Promise<TaskChecks> {
+  const deps = opts.deps ?? { failedLog };
+  const dir = projectPathFor(session);
+  const live = session.task_status === "running";
+  const pr = dir
+    ? live
+      ? await prFor(session).catch(() => null)
+      : storedPR(session)
+    : null;
+  if (!pr || !dir) return { pr: null, checks: [], review: null };
+  const head = pr.head ?? null;
+
+  let checks: TaskCheck[] = [];
+  let rollup: RollupEntry[] = [];
+  try {
+    const out = JSON.parse(
+      await run(
+        "gh",
+        [
+          "pr",
+          "view",
+          String(pr.number),
+          "--json",
+          "headRefOid,statusCheckRollup",
+        ],
+        dir,
+        20000
+      )
+    ) as { headRefOid?: string; statusCheckRollup?: RollupEntry[] | null };
+    rollup = out.statusCheckRollup ?? [];
+    if (pr.state === "OPEN")
+      rollup = await settledRollup(dir, pr.url, out.headRefOid, rollup);
+    checks = toTaskChecks(rollup);
+  } catch (error) {
+    console.error(`Reading ${session.name}'s checks:`, error);
+  }
+
+  const repo = repoOfPR(pr.url);
+  if (opts.logs !== false && repo) {
+    const failing = checks
+      .map((c, i) => ({ c, url: c.state === "fail" ? c.url : null, i }))
+      .filter((x) => x.url)
+      .slice(0, CHECK_LOGS_MAX);
+    await Promise.all(
+      failing.map(async ({ c, url }) => {
+        let log = logCache.get(url!);
+        if (log === undefined) {
+          log = await deps.failedLog(dir, repo, url).catch((error) => {
+            console.error(`Reading ${session.name}'s CI log:`, error);
+            return null;
+          });
+          if (log) {
+            if (logCache.size >= LOG_CACHE_MAX) logCache.clear();
+            logCache.set(url!, log);
+          }
+        }
+        if (log) {
+          const tail = log.tail.slice(-CHECK_LOG_MAX_BYTES);
+          c.log = {
+            step: log.step,
+            tail,
+            truncated: tail.length < log.tail.length,
+          };
+        }
+      })
+    );
+  }
+
+  return {
+    pr: { number: pr.number, url: pr.url, state: pr.state, head },
+    checks,
+    review: head ? reviewVerdict(session, head) : null,
+  };
+}
+
+// The review covering the head: its own, or the one of the head the task
+// pushed while the head is exactly the one AgentOS restacked it to.
+export function reviewVerdict(
+  session: Session,
+  head: string
+): TaskReviewVerdict | null {
+  const restacked = restackedOf(session);
+  const row =
+    getCheck(session.id, head, "review") ??
+    (restacked?.to === head && restacked.from
+      ? getCheck(session.id, restacked.from, "review")
+      : null);
+  if (!row) return null;
+  const { summary, findings, truncated } = parseReviewDetail(row.detail);
+  return {
+    sha: row.sha,
+    status: row.status,
+    summary,
+    findings,
+    at: row.created_at,
+    truncated,
+  };
+}

package/lib/tasks/diff.ts

@@ -0,0 +1,259 @@
+/**
+ * A task's whole change, base branch to head (merge-base), for the phone to
+ * review: a file list with status and line counts, then one file's patch.
+ * Read from the task's worktree when it's there, else from its PR on GitHub.
+ * Sizes are capped and say so; a file is only ever one the change lists.
+ */
+
+import { git, isGitError, resolveRef } from "../git-exec";
+import { getDefaultBranch, isGitRepo, isBranchName } from "../git";
+import { existingRef } from "../orchestrator/repo";
+import { run } from "./gh";
+import { repoOfPR } from "./pr-activity";
+import { localWorktree, projectPathFor } from "./session";
+import { LoopError } from "./loop-error";
+import {
+  DIFF_MAX_FILES,
+  DIFF_PATCH_MAX_BYTES,
+  type TaskDiffFile,
+  type TaskDiffList,
+  type TaskDiffPatch,
+} from "./loop-types";
+import type { Session } from "../db";
+
+export interface DiffCaps {
+  files: number;
+  patchBytes: number;
+}
+const CAPS: DiffCaps = {
+  files: DIFF_MAX_FILES,
+  patchBytes: DIFF_PATCH_MAX_BYTES,
+};
+
+const MAX_PATH_BYTES = 1024;
+
+/** A path the change could list: relative, inside the repo, no tricks. */
+export function validDiffPath(file: unknown): file is string {
+  if (typeof file !== "string" || !file) return false;
+  if (Buffer.byteLength(file) > MAX_PATH_BYTES) return false;
+  if (file.includes("\0") || file.includes("\\")) return false;
+  if (file.startsWith("/") || file.startsWith("-")) return false;
+  return !file.split("/").some((part) => part === ".." || part === "");
+}
+
+const STATUS_OF_GITHUB: Record<string, string> = {
+  added: "A",
+  removed: "D",
+  modified: "M",
+  changed: "M",
+  renamed: "R",
+  copied: "C",
+};
+
+interface Source {
+  kind: "worktree" | "pr";
+  base: string;
+  head: string;
+  list: () => Promise<TaskDiffFile[]>;
+  patch: (file: string) => Promise<{ patch: string | null; tooLarge: boolean }>;
+}
+
+// `git diff --numstat -z` and `--name-status -z`, joined by path.
+function parseGit(numstat: string, nameStatus: string): TaskDiffFile[] {
+  const status = new Map<string, string>();
+  const parts = nameStatus.split("\0");
+  for (let i = 0; i + 1 < parts.length; i += 2)
+    status.set(parts[i + 1], parts[i][0] || "M");
+  const files: TaskDiffFile[] = [];
+  for (const row of numstat.split("\0")) {
+    const m = /^(\d+|-)\t(\d+|-)\t([\s\S]+)$/.exec(row);
+    if (!m) continue;
+    const binary = m[1] === "-";
+    files.push({
+      path: m[3],
+      status: status.get(m[3]) ?? "M",
+      additions: binary ? null : Number(m[1]),
+      deletions: binary ? null : Number(m[2]),
+      binary,
+    });
+  }
+  return files;
+}
+
+async function worktreeSource(
+  session: Session,
+  dir: string,
+  caps: DiffCaps
+): Promise<Source> {
+  if (!(await isGitRepo(dir))) throw new LoopError("No repository", 404);
+  const recorded = session.base_branch || (await getDefaultBranch(dir));
+  if (!isBranchName(recorded)) throw new LoopError("Unknown base branch", 404);
+  const base = await existingRef(dir, recorded);
+  if (!base) throw new LoopError("The base branch isn't here", 404);
+  const head = (await resolveRef(dir, "HEAD")) ?? "";
+  const range = `${base}...HEAD`;
+  const flags = ["--no-renames", "--no-ext-diff", "--no-textconv"];
+  return {
+    kind: "worktree",
+    base: recorded,
+    head,
+    list: async () => {
+      const [numstat, names] = await Promise.all([
+        git(dir, ["diff", "--numstat", "-z", ...flags, range, "--"]),
+        git(dir, ["diff", "--name-status", "-z", ...flags, range, "--"]),
+      ]);
+      return parseGit(numstat, names);
+    },
+    patch: async (file) => {
+      try {
+        const out = await git(
+          dir,
+          ["diff", "--no-color", ...flags, range, "--", file],
+          { literalPathspecs: true, maxBuffer: caps.patchBytes * 4 }
+        );
+        return { patch: out, tooLarge: false };
+      } catch (error) {
+        if (
+          isGitError(error) &&
+          error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER"
+        )
+          return { patch: null, tooLarge: true };
+        throw error;
+      }
+    },
+  };
+}
+
+interface GithubFile {
+  filename?: string;
+  status?: string;
+  additions?: number;
+  deletions?: number;
+  patch?: string;
+}
+
+async function prSource(session: Session): Promise<Source> {
+  const repo = session.pr_url ? repoOfPR(session.pr_url) : null;
+  const dir = projectPathFor(session);
+  if (!repo || !session.pr_number || !dir)
+    throw new LoopError("The task has no worktree and no pull request", 404);
+  const slug = `${repo.owner}/${repo.name}`;
+  const meta = JSON.parse(
+    await run(
+      "gh",
+      [
+        "pr",
+        "view",
+        String(session.pr_number),
+        "--repo",
+        slug,
+        "--json",
+        "baseRefName,headRefOid",
+      ],
+      dir,
+      15000
+    )
+  ) as { baseRefName?: string; headRefOid?: string };
+  const pages = async (): Promise<GithubFile[]> => {
+    const all: GithubFile[] = [];
+    for (let page = 1; page <= 3; page++) {
+      const rows = JSON.parse(
+        await run(
+          "gh",
+          [
+            "api",
+            `repos/${slug}/pulls/${session.pr_number}/files?per_page=100&page=${page}`,
+          ],
+          dir,
+          30000
+        )
+      ) as GithubFile[];
+      all.push(...rows);
+      if (rows.length < 100) break;
+    }
+    return all;
+  };
+  let cached: GithubFile[] | null = null;
+  const rows = async () => (cached ??= await pages());
+  return {
+    kind: "pr",
+    base: meta.baseRefName ?? "",
+    head: meta.headRefOid ?? "",
+    list: async () =>
+      (await rows())
+        .filter((f) => typeof f.filename === "string")
+        .map((f) => ({
+          path: f.filename!,
+          status: STATUS_OF_GITHUB[f.status ?? ""] ?? "M",
+          additions: f.additions ?? 0,
+          deletions: f.deletions ?? 0,
+          binary: false,
+        })),
+    patch: async (file) => {
+      const hit = (await rows()).find((f) => f.filename === file);
+      return typeof hit?.patch === "string"
+        ? { patch: hit.patch, tooLarge: false }
+        : { patch: null, tooLarge: true };
+    },
+  };
+}
+
+async function sourceFor(session: Session, caps: DiffCaps): Promise<Source> {
+  const dir = localWorktree(session);
+  if (dir) return worktreeSource(session, dir, caps);
+  return prSource(session);
+}
+
+// Cut at a line break at or before `max` bytes.
+export function capPatch(
+  patch: string,
+  max: number
+): { patch: string; truncated: boolean } {
+  if (Buffer.byteLength(patch) <= max) return { patch, truncated: false };
+  const cut = Buffer.from(patch).subarray(0, max).toString("utf8");
+  const nl = cut.lastIndexOf("\n");
+  return { patch: nl > 0 ? cut.slice(0, nl) : cut, truncated: true };
+}
+
+/** The file list, or with `file` that one file's patch. */
+export async function taskDiff(
+  session: Session,
+  file?: string | null,
+  caps: DiffCaps = CAPS
+): Promise<TaskDiffList | TaskDiffPatch> {
+  if (file != null && !validDiffPath(file))
+    throw new LoopError("Not a path in the change", 400);
+  const source = await sourceFor(session, caps);
+  const all = await source.list();
+  if (file != null) {
+    if (!all.some((f) => f.path === file))
+      throw new LoopError("That file isn't in the change", 404);
+    const { patch, tooLarge } = await source.patch(file);
+    if (patch === null)
+      return {
+        source: source.kind,
+        path: file,
+        patch: null,
+        truncated: true,
+        tooLarge: true,
+      };
+    const capped = capPatch(patch, caps.patchBytes);
+    return {
+      source: source.kind,
+      path: file,
+      patch: capped.patch,
+      truncated: capped.truncated,
+      tooLarge,
+    };
+  }
+  return {
+    source: source.kind,
+    base: source.base,
+    head: source.head,
+    files: all.slice(0, caps.files),
+    totalFiles: all.length,
+    additions: all.reduce((n, f) => n + (f.additions ?? 0), 0),
+    deletions: all.reduce((n, f) => n + (f.deletions ?? 0), 0),
+    truncated: all.length > caps.files,
+  };
+}

package/lib/tasks/gh.ts

@@ -133,7 +133,7 @@ const RUN_CACHE_MAX = 2000;
 // The rollup with stale reruns dropped. Only a check that ran more than once
 // costs an API call, one per workflow run attempt. A run outside the PR's
 // repo, or one the API can't describe, leaves its check unsettled.
-async function settledRollup(
+export async function settledRollup(
   repoDir: string,
   prUrl: string,
   head: string | undefined,

package/lib/tasks/index.ts

@@ -47,6 +47,8 @@ import { expandHome, prFor, storedPR, taskSessions } from "./session";
 import { InProgressError } from "./move-bundle";
 import { nameFor } from "../session-titles";
 import { taskSetupOf, type TaskSetup } from "./setup";
+import { taskPlan } from "./plan-view";
+import type { TaskPlan } from "./loop-types";
 import { finishTaskStart } from "./start";
 import { isRemoteHost } from "../hosts";
 import { DEFAULT_START_VIEW, type StartView } from "../sessions/launch";
@@ -98,7 +100,8 @@ export interface TaskView {
   model?: string;
   planning?: boolean;
   // What its starter decided about a plan step, and why; null if unstated.
-  plan?: { planned: boolean; reason: string | null } | null;
+  // Its plan: ready to read or approve, with a title and capped text.
+  plan?: TaskPlan | null;
   // A quick change: the orchestrator session that makes it (no agent).
   quickOf?: string | null;
   // What it has cost so far in weighted tokens (lib/usage/weights).
@@ -389,13 +392,7 @@ export async function taskView(session: Session): Promise<TaskView> {
     armed: !!session.merge_armed_at,
     model: sessionModelRef(session),
     planning: session.plan_phase === "planning",
-    plan:
-      session.plan_decided == null
-        ? null
-        : {
-            planned: !!session.plan_decided,
-            reason: session.plan_reason ?? null,
-          },
+    plan: taskPlan(session),
     quickOf: session.quick_of ?? null,
   };
 }
@@ -413,7 +410,7 @@ export function movedTasks(): { id: string; movedTo: string | null }[] {
 
 // Archived tasks aren't listed.
 export async function listTasks(): Promise<TaskView[]> {
-  const sessions = taskSessions().filter((s) => !s.archived_at);
+  const sessions = taskSessions(false);
   const [local, remote] = await Promise.all([
     Promise.all(sessions.filter((s) => !isMirror(s)).map(taskView)),
     remoteTaskViews(sessions.filter(isMirror)),

package/lib/tasks/loop-error.ts

@@ -0,0 +1,21 @@
+// A refusal the loop routes turn into a status code.
+export class LoopError extends Error {
+  constructor(
+    message: string,
+    readonly status: 400 | 404 | 409
+  ) {
+    super(message);
+    this.name = "LoopError";
+  }
+}
+
+/** The task a route names: unknown, not a task, or another machine's. */
+export function localTask<T extends { task_status?: string | null }>(
+  session: T | undefined,
+  mirror: (s: T) => boolean
+): T {
+  if (!session?.task_status) throw new LoopError("Task not found", 404);
+  if (mirror(session))
+    throw new LoopError("That task runs on another machine", 409);
+  return session;
+}