@saadnvd1/agent-os 0.3.723 → 0.3.731

package/lib/ports/whoHolds.ts

@@ -0,0 +1,155 @@
+import fs from "fs";
+import { db } from "@/lib/db";
+import { parsePorts } from "./allocatePorts";
+import type {
+  DevServerPortRow,
+  Holder,
+  Listener,
+  PortCheck,
+  SessionPortRow,
+} from "./types";
+
+const inside = (cwd: string, dir: string) =>
+  cwd === dir || cwd.startsWith(dir.endsWith("/") ? dir : `${dir}/`);
+
+const holdsPort = (s: SessionPortRow, port: number) =>
+  s.devServerPort === port || Object.values(s.ports ?? {}).includes(port);
+
+const asSession = (
+  s: SessionPortRow,
+  pid: number | null,
+  listening: boolean
+): Holder => ({
+  kind: "session",
+  sessionId: s.id,
+  name: s.name,
+  project: s.project,
+  pid,
+  listening,
+});
+
+/**
+ * Who holds a port: the session whose worktree the listener runs in, the
+ * Dev Servers panel's server, a Windows process, or a process outside
+ * AgentOS. A listener whose cwd can't be read falls to the session that
+ * holds the port, if any. With nothing listening, a session or panel server
+ * that holds the port still has it. Null when it's free.
+ */
+export function whoHolds(
+  port: number,
+  listeners: Listener[],
+  sessions: SessionPortRow[],
+  devServers: DevServerPortRow[]
+): Holder | null {
+  const l = listeners.find((x) => x.port === port);
+  const reserving = sessions.find((s) => holdsPort(s, port));
+  const panel = devServers.find((d) => d.ports.includes(port));
+  if (l) {
+    if (l.cwd) {
+      const s = sessions.find((x) => x.worktree && inside(l.cwd!, x.worktree));
+      if (s) return asSession(s, l.pid, true);
+    }
+    const byPid = devServers.find((d) => d.pid !== null && d.pid === l.pid);
+    if (byPid)
+      return { kind: "dev-server", id: byPid.id, name: byPid.name, pid: l.pid };
+    if (l.windows) return { kind: "windows", pid: l.pid };
+    if (!l.cwd && reserving) return asSession(reserving, l.pid, true);
+    return { kind: "outside", pid: l.pid, command: l.command, cwd: l.cwd };
+  }
+  if (reserving) return asSession(reserving, null, false);
+  if (panel)
+    return {
+      kind: "dev-server",
+      id: panel.id,
+      name: panel.name,
+      pid: panel.pid,
+    };
+  return null;
+}
+
+export function judgePort(
+  askerId: string,
+  name: string | null,
+  port: number,
+  listeners: Listener[] | null,
+  sessions: SessionPortRow[],
+  devServers: DevServerPortRow[]
+): PortCheck {
+  const holder = whoHolds(port, listeners ?? [], sessions, devServers);
+  const mine = holder?.kind === "session" && holder.sessionId === askerId;
+  const free =
+    holder === null
+      ? listeners === null
+        ? null
+        : true
+      : mine && !holder.listening;
+  return { name, port, free, holder, mine };
+}
+
+const real = (p: string) => {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return p;
+  }
+};
+
+// This machine's sessions that run in a worktree or hold ports.
+export function localPortRows(): {
+  sessions: SessionPortRow[];
+  devServers: DevServerPortRow[];
+} {
+  const rows = db
+    .prepare(
+      `SELECT s.id, s.name, p.name AS project, s.worktree_path, s.ports, s.dev_server_port
+       FROM sessions s LEFT JOIN projects p ON p.id = s.project_id
+       WHERE (s.host_id IS NULL OR s.host_id = 'local')
+         AND ((s.worktree_path IS NOT NULL AND s.archived_at IS NULL)
+              OR s.ports IS NOT NULL OR s.dev_server_port IS NOT NULL)`
+    )
+    .all() as {
+    id: string;
+    name: string;
+    project: string | null;
+    worktree_path: string | null;
+    ports: string | null;
+    dev_server_port: number | null;
+  }[];
+  const servers = db
+    .prepare(
+      `SELECT id, name, pid, ports FROM dev_servers WHERE status IN ('running', 'starting')`
+    )
+    .all() as { id: string; name: string; pid: number | null; ports: string }[];
+  return {
+    sessions: rows.map((r) => ({
+      id: r.id,
+      name: r.name,
+      project: r.project,
+      worktree: r.worktree_path ? real(r.worktree_path) : null,
+      ports: parsePorts(r.ports),
+      devServerPort: r.dev_server_port,
+    })),
+    devServers: servers.map((d) => {
+      let ports: number[] = [];
+      try {
+        const parsed = JSON.parse(d.ports) as unknown;
+        if (Array.isArray(parsed))
+          ports = parsed.filter((p): p is number => Number.isInteger(p));
+      } catch {}
+      return { id: d.id, name: d.name, pid: d.pid, ports };
+    }),
+  };
+}
+
+export function describeHolder(h: Holder): string {
+  switch (h.kind) {
+    case "session":
+      return `session "${h.name}"${h.project ? ` (project ${h.project})` : ""}${h.pid ? `, pid ${h.pid}` : ""}${h.listening ? "" : ", which holds it but isn't listening yet"}`;
+    case "dev-server":
+      return `the Dev Servers panel's "${h.name}"${h.pid ? `, pid ${h.pid}` : ""}`;
+    case "windows":
+      return `a Windows process${h.pid ? ` (pid ${h.pid})` : ""}`;
+    case "outside":
+      return `${h.pid ? `pid ${h.pid}` : "a process"}${h.command ? ` (${h.command})` : ""}${h.cwd ? ` in ${h.cwd}` : ""}, outside AgentOS`;
+  }
+}

package/lib/project-config/brief.ts

@@ -19,15 +19,17 @@ export function runningBrief(
   config: ProjectConfig,
   ports: Record<string, number>,
   database: SessionDatabase | null = null,
-  warning: string | null = null
+  warning: string | null = null,
+  hardcoded: string[] = []
 ): string {
   const lines: string[] = [];
   if (warning) lines.push(`- ${warning}`);
   const names = Object.entries(ports);
   if (names.length)
     lines.push(
-      `- Your ports, exported in your shell and no other session's: ${names.map(([n, p]) => `${n}=${p}`).join(", ")}. Start servers on these; never stop a process you didn't start (kill by your port: \`lsof -ti tcp:<port> -sTCP:LISTEN | xargs kill\`).`
+      `- Your ports, exported in your shell and no other session's: ${names.map(([n, p]) => `${n}=${p}`).join(", ")}. Start servers on these; never stop a process you didn't start (kill by your port: \`lsof -ti tcp:<port> -sTCP:LISTEN | xargs kill\`). If one is taken, never wait for it: \`aos port\` names the holder and gives you a free one.`
     );
+  for (const note of hardcoded) lines.push(`- ${note}`);
   if (config.dev)
     lines.push(`- Dev server: \`${withPorts(config.dev, ports)}\``);
   const ready = readyCommand(config, ports);

package/lib/project-config/session.ts

@@ -9,7 +9,8 @@ import os from "os";
 import { sessionTmpDir } from "../sessions/leftovers";
 import { db } from "../db";
 import { getProject } from "../projects";
-import { sessionPorts } from "../ports";
+import { sessionPorts } from "../ports/allocatePorts";
+import { findHardcodedPorts, hardcodedNote } from "../ports/findHardcodedPorts";
 import {
   loadProjectConfig,
   NONE,
@@ -71,12 +72,27 @@ export function sessionProjectEnv(sessionId: string): Record<string, string> {
   }
 }
 
+// With no config file the section is only the session's ports, so an agent
+// in a project without agentos.json still knows it has them.
 export function sessionRunningBrief(sessionId: string): string {
   try {
     const { config, source, warning, ports } = sessionConfig(sessionId);
+    if (!source && !ports) return "";
+    const dir = projectPathOf(sessionId);
+    const primary = ports ? Object.values(ports)[0] : undefined;
+    const hardcoded =
+      dir && primary !== undefined
+        ? findHardcodedPorts(dir, config.dev, primary).map(hardcodedNote)
+        : [];
     return source
-      ? runningBrief(config, ports ?? {}, sessionDatabase(sessionId), warning)
-      : "";
+      ? runningBrief(
+          config,
+          ports ?? {},
+          sessionDatabase(sessionId),
+          warning,
+          hardcoded
+        )
+      : runningBrief({}, ports ?? {}, null, null, hardcoded);
   } catch (error) {
     console.error(`[project-config] brief for ${sessionId}:`, error);
     return "";

package/lib/reports/drafts.ts

@@ -0,0 +1,87 @@
+// The drafted next prompt: approve (one click), edit-and-approve, or dismiss.
+// A task with an analyst pairing uses the analyst's own recommendation, so
+// there is one draft system; a plain task's draft lives on its report row.
+
+import { db, type Session } from "../db";
+import { deliver } from "../bus";
+import {
+  dismissRecommendation,
+  forwardToCoder,
+  sendRecommendation,
+} from "../analyst/forward";
+import { statusDetector } from "../status-detector";
+import { claimDraft, getReport, reopenDraft, setDraftText } from "./store";
+
+export class DraftError extends Error {
+  constructor(
+    message: string,
+    readonly status: 400 | 404 | 409 = 409
+  ) {
+    super(message);
+  }
+}
+
+export const draftItemId = (reportId: number) =>
+  `user-report-draft-${reportId}`;
+
+export async function approveDraft(
+  sessionId: string,
+  input: {
+    source: "report" | "analyst";
+    id: string;
+    linkId?: string;
+    text?: string;
+  }
+): Promise<void> {
+  if (input.source === "analyst") {
+    if (!input.linkId) throw new DraftError("Missing pairing", 400);
+    await sendRecommendation(input.linkId, input.id, input.text);
+    return;
+  }
+  const reportId = Number(input.id);
+  const report = getReport(reportId);
+  if (!report || report.sessionId !== sessionId || !report.draft)
+    throw new DraftError("No such draft", 404);
+  const text = (input.text ?? report.draft.text).trim();
+  if (!text) throw new DraftError("There is no prompt to send", 400);
+  if (!claimDraft(reportId, "sent"))
+    throw new DraftError(`This draft was already ${report.draft.status}`);
+  if (input.text && text !== report.draft.text)
+    setDraftText(reportId, text, "sent");
+  try {
+    const session = db
+      .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+      .get(sessionId) as Session | undefined;
+    if (!session) throw new DraftError("No such task", 404);
+    if (session.view === "chat")
+      await forwardToCoder(sessionId, {
+        text,
+        id: draftItemId(reportId),
+        label: "Analyst",
+      });
+    else {
+      await statusDetector.refreshCache();
+      const delivery = await deliver(session, text, { name: "Analyst" });
+      if (delivery.state === "failed") throw new Error(delivery.why);
+    }
+  } catch (error) {
+    reopenDraft(reportId);
+    throw error;
+  }
+}
+
+export function dismissDraft(
+  sessionId: string,
+  input: { source: "report" | "analyst"; id: string; linkId?: string }
+): void {
+  if (input.source === "analyst") {
+    if (!input.linkId) throw new DraftError("Missing pairing", 400);
+    dismissRecommendation(input.linkId, input.id);
+    return;
+  }
+  const report = getReport(Number(input.id));
+  if (!report || report.sessionId !== sessionId || !report.draft)
+    throw new DraftError("No such draft", 404);
+  if (!claimDraft(report.id, "dismissed"))
+    throw new DraftError(`This draft was already ${report.draft.status}`);
+}

package/lib/reports/end-hook.ts

@@ -0,0 +1,17 @@
+// The task-end trigger, decoupled from the code that ends tasks: finishing a
+// task calls taskEnded(), and the report generator is plugged in at server
+// start (hooks.ts), so ending a task never reaches for gh or a model on its own.
+
+let onEnd: ((sessionId: string) => void) | null = null;
+
+export const setTaskEndHook = (fn: ((sessionId: string) => void) | null) => {
+  onEnd = fn;
+};
+
+export function taskEnded(sessionId: string): void {
+  try {
+    onEnd?.(sessionId);
+  } catch (error) {
+    console.error(`Report at the end of ${sessionId}:`, error);
+  }
+}

package/lib/reports/estimate.ts

@@ -0,0 +1,107 @@
+// The completion estimate. Computed here from evidence, never by a model:
+// the model may only propose which evidence backs an acceptance item, and
+// this decides whether the citation holds.
+
+import type { Estimate, EstimateItem, EvidenceRef } from "./types";
+
+export interface AcceptanceItem {
+  label: string;
+  // Verified by the system itself (a loop criterion met with resolved
+  // evidence), so no model mapping is needed.
+  evidence?: string[];
+}
+
+export interface Stages {
+  planned: boolean;
+  pushed: boolean;
+  prOpen: boolean;
+  ciGreen: boolean;
+  reviewed: boolean;
+  merged: boolean;
+}
+
+export const STAGE_COUNT = 6;
+
+// Diff, piece and log evidence is true of the work, not of one head.
+const HEAD_FREE = new Set(["diff", "piece", "log", "accept", "state"]);
+// A diff alone never verifies: a file changed shows nothing works.
+const PROVING = new Set(["test", "ci", "review", "piece", "accept"]);
+
+export interface Mapping {
+  item: number;
+  evidence: string[];
+}
+
+function holds(
+  ids: string[],
+  evidence: Map<string, EvidenceRef>,
+  head: string | null
+): boolean {
+  if (!ids.length) return false;
+  const cited: EvidenceRef[] = [];
+  for (const id of ids) {
+    const ev = evidence.get(id);
+    if (!ev || ev.status !== "pass") return false;
+    if (!HEAD_FREE.has(ev.kind) && head && ev.sha && ev.sha !== head)
+      return false;
+    cited.push(ev);
+  }
+  if (!cited.some((e) => PROVING.has(e.kind))) return false;
+  const kinds = new Set(cited.map((e) => e.kind));
+  for (const e of evidence.values())
+    if (
+      e.status === "fail" &&
+      kinds.has(e.kind) &&
+      (HEAD_FREE.has(e.kind) || !head || !e.sha || e.sha === head)
+    )
+      return false;
+  return true;
+}
+
+export function computeEstimate(input: {
+  head: string | null;
+  evidence: EvidenceRef[];
+  items: AcceptanceItem[];
+  mappings: Mapping[];
+  stages: Stages;
+}): Estimate {
+  const byId = new Map(input.evidence.map((e) => [e.id, e]));
+  if (input.items.length) {
+    const items: EstimateItem[] = input.items.map((it, i) => {
+      const own = it.evidence ?? [];
+      if (own.length && holds(own, byId, input.head))
+        return { label: it.label, verified: true, evidence: own };
+      const mapped = input.mappings
+        .filter((m) => m.item === i)
+        .flatMap((m) => m.evidence);
+      const ids = [...new Set(mapped)];
+      const ok = holds(ids, byId, input.head);
+      return { label: it.label, verified: ok, evidence: ok ? ids : [] };
+    });
+    return {
+      done: items.filter((i) => i.verified).length,
+      total: items.length,
+      basis: "acceptance",
+      items,
+    };
+  }
+  const s = input.stages;
+  const list: [string, boolean][] = [
+    ["Plan approved", s.planned],
+    ["Code pushed", s.pushed],
+    ["Pull request open", s.prOpen],
+    ["CI green on the latest push", s.ciGreen],
+    ["Review passed", s.reviewed],
+    ["Merged", s.merged],
+  ];
+  return {
+    done: list.filter(([, ok]) => ok).length,
+    total: STAGE_COUNT,
+    basis: "stages",
+    items: list.map(([label, verified]) => ({
+      label,
+      verified,
+      evidence: [],
+    })),
+  };
+}

package/lib/reports/evidence/build.ts

@@ -0,0 +1,193 @@
+// Evidence items from what was read. Pure: the collectors in gather.ts do the
+// reading, so these are tested with fixtures.
+
+import type { TaskCheck, TaskReviewVerdict } from "../../tasks/loop-types";
+import type { TaskState } from "../../tasks/state";
+import type { DigestSignals } from "../../analyst/types";
+import { latestChecks } from "../../analyst/signals";
+import type { EvidenceRef } from "../types";
+
+const EXCERPT = 1500;
+const cap = (s: string, n = EXCERPT) =>
+  s.length > n ? `${s.slice(0, n)}…` : s;
+
+export function ciEvidence(
+  checks: TaskCheck[],
+  head: string | null,
+  at: string
+): EvidenceRef[] {
+  return checks
+    .filter((c) => c.state !== "skipped" && c.state !== "neutral")
+    .slice(0, 30)
+    .map((c) => ({
+      id: `ci:${c.name}`,
+      kind: "ci",
+      label: `CI · ${c.name}`,
+      status:
+        c.state === "pass"
+          ? "pass"
+          : c.state === "pending"
+            ? "pending"
+            : "fail",
+      at: c.completedAt ?? at,
+      sha: head ?? undefined,
+      url: c.url ?? undefined,
+      excerpt: c.log
+        ? cap(`${c.log.step ?? ""}\n${c.log.tail}`.trim())
+        : undefined,
+    }));
+}
+
+export function reviewEvidence(
+  review: TaskReviewVerdict | null
+): EvidenceRef[] {
+  if (!review) return [];
+  const findings = review.findings
+    .map(
+      (f) =>
+        `[${f.severity}] ${f.file ?? ""}${f.line ? `:${f.line}` : ""} ${f.summary}`
+    )
+    .join("\n");
+  return [
+    {
+      id: `review:${review.sha.slice(0, 7)}`,
+      kind: "review",
+      label: "Independent review",
+      status:
+        review.status === "pass"
+          ? "pass"
+          : review.status === "running"
+            ? "pending"
+            : "fail",
+      at: review.at,
+      sha: review.sha,
+      excerpt: cap(`${review.summary}\n${findings}`.trim()),
+    },
+  ];
+}
+
+// The last run of each test, build, typecheck or lint command.
+export function testEvidence(
+  signals: DigestSignals,
+  sessionId: string,
+  head: string | null,
+  at: string
+): EvidenceRef[] {
+  return latestChecks(signals)
+    .slice(0, 12)
+    .map((c, i) => ({
+      id: `test:${i + 1}`,
+      kind: "test",
+      label: c.command.slice(0, 120),
+      status: c.passed ? "pass" : "fail",
+      at,
+      sha: head ?? undefined,
+      href: `/?session=${sessionId}`,
+    }));
+}
+
+export function diffEvidence(
+  numstat: string,
+  sessionId: string,
+  at: string
+): EvidenceRef[] {
+  const out: EvidenceRef[] = [];
+  for (const line of numstat.split("\n")) {
+    const m = /^(\d+|-)\t(\d+|-)\t(.+)$/.exec(line);
+    if (!m) continue;
+    out.push({
+      id: `diff:${m[3]}`,
+      kind: "diff",
+      label: `${m[3]} (+${m[1] === "-" ? 0 : m[1]} −${m[2] === "-" ? 0 : m[2]})`,
+      status: "info",
+      at,
+      href: `/?session=${sessionId}`,
+    });
+    if (out.length >= 40) break;
+  }
+  return out;
+}
+
+export function stateEvidence(
+  state: TaskState,
+  blocked: string | null,
+  at: string
+): EvidenceRef {
+  return {
+    id: "state:task",
+    kind: "state",
+    label: `Task state: ${state}`,
+    status: state === "checks-failing" || state === "blocked" ? "fail" : "info",
+    at,
+    excerpt: blocked ? cap(blocked) : undefined,
+  };
+}
+
+export function askEvidence(
+  asks: { id: number; title: string; detail: string; created_at: string }[]
+): EvidenceRef[] {
+  return asks.slice(0, 5).map((a) => ({
+    id: `ask:${a.id}`,
+    kind: "ask",
+    label: `Waiting on you: ${a.title}`,
+    status: "pending",
+    at: a.created_at,
+    excerpt: cap(a.detail),
+  }));
+}
+
+export function acceptEvidence(
+  items: { label: string; met: boolean; note?: string }[],
+  at: string
+): EvidenceRef[] {
+  return items.map((it, i) => ({
+    id: `accept:${i + 1}`,
+    kind: "accept",
+    label: it.label,
+    status: it.met ? "pass" : "pending",
+    at,
+    excerpt: it.note ? cap(it.note) : undefined,
+  }));
+}
+
+export function logEvidence(log: {
+  sessionId: string;
+  mergeCommit: string | null;
+  prNumber: number | null;
+  durationMs: number | null;
+  costUsd: number;
+  createdAt: string;
+}): EvidenceRef {
+  const mins =
+    log.durationMs !== null
+      ? Math.max(1, Math.round(log.durationMs / 60000))
+      : null;
+  return {
+    id: "log:task",
+    kind: "log",
+    label: [
+      log.prNumber ? `Merged as pull request ${log.prNumber}` : "Task log",
+      mins ? `in ${mins} min` : "",
+    ]
+      .filter(Boolean)
+      .join(" "),
+    status: "pass",
+    at: log.createdAt,
+    excerpt: log.mergeCommit ? `Merge commit ${log.mergeCommit}` : undefined,
+    href: `/?session=${log.sessionId}`,
+  };
+}
+
+// FNV-1a over ids and statuses: times and excerpts don't change it.
+export function evidenceHash(evidence: EvidenceRef[], head: string | null) {
+  let h = 2166136261;
+  const s = `${head ?? ""}|${evidence
+    .map((e) => `${e.id}:${e.status}`)
+    .sort()
+    .join(",")}`;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16);
+}