@saadnvd1/agent-os 0.3.503 → 0.3.506

package/lib/session-logs/hq.ts

@@ -0,0 +1,201 @@
+/**
+ * A workspace's HQ folder: a git repo that session logs are written into
+ * (<hq>/docs/sessions/<project>/) and committed to. Logs hold private task
+ * details, so a repo whose remote is public is refused when it's saved, and
+ * nothing is pushed unless the stored visibility says private.
+ */
+
+import fs from "fs";
+import path from "path";
+import { db } from "../db";
+import { git } from "../git-exec";
+import { run } from "../tasks/gh";
+import { getWorkspace } from "../workspaces";
+import { expand, repoPaths, resolved, within } from "./paths";
+
+export type Visibility = "private" | "internal" | "none";
+
+export interface Hq {
+  folder: string;
+  // "none": the repo has no remote, so its logs stay local.
+  visibility: Visibility;
+}
+
+const key = (workspaceId: string) => `session-logs.hq.${workspaceId}`;
+
+export function getHq(workspaceId: string): Hq | null {
+  const row = db
+    .prepare(`SELECT value FROM settings WHERE key = ?`)
+    .get(key(workspaceId)) as { value: string } | undefined;
+  if (!row) return null;
+  try {
+    const hq = JSON.parse(row.value) as Hq;
+    return hq.folder ? hq : null;
+  } catch {
+    return null;
+  }
+}
+
+function projectRepos(workspaceId: string): string[] {
+  const ids = db
+    .prepare(`SELECT id FROM projects WHERE workspace_id = ?`)
+    .all(workspaceId) as { id: string }[];
+  return ids.flatMap((p) => repoPaths(p.id));
+}
+
+const insideRepo = (hq: string, workspaceId: string) =>
+  projectRepos(workspaceId).find((r) => within(hq, r));
+
+// The HQ when logs can still go into it: it's there, it's a git
+// repo and no project's repository has swallowed it since it was saved.
+export function usableHq(
+  workspaceId: string
+): { dir: string; visibility: Visibility } | null {
+  const hq = getHq(workspaceId);
+  if (!hq) return null;
+  try {
+    const dir = resolved(expand(hq.folder));
+    if (!fs.existsSync(path.join(dir, ".git")) || insideRepo(dir, workspaceId))
+      throw new Error("not usable");
+    return { dir, visibility: hq.visibility };
+  } catch {
+    console.error(
+      `[session-logs] the HQ folder ${hq.folder} can't be used; logs go to the default`
+    );
+    return null;
+  }
+}
+
+export interface HqDeps {
+  // gh's answer for the repo at `dir`: PUBLIC, PRIVATE or INTERNAL.
+  visibility: (dir: string) => Promise<string>;
+}
+
+const ghVisibility = async (dir: string) =>
+  (
+    await run(
+      "gh",
+      ["repo", "view", "--json", "visibility", "-q", ".visibility"],
+      dir,
+      20_000
+    )
+  ).trim();
+
+// Saves the HQ folder, or throws a plain message saying why not. An empty
+// value clears it.
+export async function setHq(
+  workspaceId: string,
+  value: string | null,
+  deps: HqDeps = { visibility: ghVisibility }
+): Promise<void> {
+  if (!getWorkspace(workspaceId)) throw new Error("Workspace not found");
+  const folder = value?.trim() ?? "";
+  if (!folder) {
+    db.prepare(`DELETE FROM settings WHERE key = ?`).run(key(workspaceId));
+    return;
+  }
+  if (!(folder === "~" || folder.startsWith("~/") || path.isAbsolute(folder)))
+    throw new Error(
+      `"${folder}" isn't an absolute path. Use a full path or one starting with ~/.`
+    );
+  const dir = resolved(expand(folder));
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory())
+    throw new Error(`${folder} isn't a folder.`);
+  let top: string;
+  try {
+    top = resolved((await git(dir, ["rev-parse", "--show-toplevel"])).trim());
+  } catch {
+    throw new Error(`${folder} isn't a git repository.`);
+  }
+  if (top !== dir)
+    throw new Error(
+      `${folder} is inside the git repository at ${top}. Give the repository's top folder.`
+    );
+  const repo = insideRepo(dir, workspaceId);
+  if (repo)
+    throw new Error(
+      `${folder} is inside a project's repository (${repo}). Repositories can be public, so logs are never written into one.`
+    );
+  let visibility: Visibility = "none";
+  if ((await git(dir, ["remote"])).trim()) {
+    let seen: string;
+    try {
+      seen = (await deps.visibility(dir)).toUpperCase();
+    } catch (error) {
+      throw new Error(
+        `Couldn't check whether ${folder}'s GitHub repository is private: ${error instanceof Error ? error.message : error}`
+      );
+    }
+    if (seen === "PUBLIC")
+      throw new Error(
+        `${folder}'s GitHub repository is public. Logs hold private task details, so use a private repository.`
+      );
+    if (seen !== "PRIVATE" && seen !== "INTERNAL")
+      throw new Error(`Unexpected repository visibility "${seen}".`);
+    visibility = seen === "PRIVATE" ? "private" : "internal";
+  }
+  db.prepare(
+    `INSERT INTO settings (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  ).run(key(workspaceId), JSON.stringify({ folder, visibility }));
+}
+
+// One commit at a time per HQ: two merges at once would race on its index.
+const queues = new Map<string, Promise<unknown>>();
+
+function serialized<T>(hq: string, job: () => Promise<T>): Promise<T> {
+  const next = (queues.get(hq) ?? Promise.resolve()).then(job, job);
+  const tail = next.catch(() => {});
+  queues.set(hq, tail);
+  void tail.then(() => {
+    if (queues.get(hq) === tail) queues.delete(hq);
+  });
+  return next;
+}
+
+async function push(hq: string): Promise<void> {
+  const branch = (await git(hq, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+  const [remote, ref] = (
+    await git(hq, [
+      "for-each-ref",
+      "--format=%(upstream:remotename) %(upstream)",
+      `refs/heads/${branch}`,
+    ])
+  )
+    .trim()
+    .split(" ");
+  // The upstream's remote branch is "refs/remotes/<remote>/<name>".
+  const name = ref?.replace(/^refs\/remotes\/[^/]+\//, "");
+  if (!remote || !name) return;
+  await git(hq, ["push", remote, `HEAD:refs/heads/${name}`], {
+    timeout: 120_000,
+  });
+}
+
+// Commits exactly these files (nothing else in the tree) and pushes when the
+// stored visibility is private. Never throws: a failure is logged, and the
+// next call's push carries the commit along.
+export function commitLogs(
+  hq: string,
+  files: string[],
+  message: string,
+  visibility: Visibility
+): Promise<void> {
+  return serialized(hq, async () => {
+    const rel = files.map((f) => path.relative(hq, f));
+    try {
+      const opts = { literalPathspecs: true };
+      await git(hq, ["add", "--", ...rel], opts);
+      await git(hq, ["commit", "-m", message, "--only", "--", ...rel], opts);
+    } catch (error) {
+      console.error(`[session-logs] commit in ${hq}:`, error);
+      return;
+    }
+    if (visibility !== "private") return;
+    try {
+      await push(hq);
+    } catch (error) {
+      console.error(`[session-logs] push from ${hq} failed (kept):`, error);
+    }
+  });
+}

package/lib/session-logs/index.ts

@@ -0,0 +1,193 @@
+/**
+ * Session logs: when a task merges, AgentOS writes a log of it from data it
+ * already holds. It costs no model tokens, on purpose: nothing in this
+ * folder may call a model (a test holds it to that).
+ *
+ * captureMergedTask is called from every place a task becomes merged
+ * (sign-off, done, a merge seen on GitHub). It reads the plan file at once,
+ * because cleanup removes the worktree, then does the rest in the
+ * background. It runs once per task and never throws into the merge.
+ */
+
+import os from "os";
+import { db, type Session } from "../db";
+import { getProject } from "../projects";
+import { run } from "../tasks/gh";
+import { buildLogMarkdown, sqliteMs } from "./build";
+import { writeLogFileTo, type Destination } from "./folder";
+import { commitLogs } from "./hq";
+import { gatherLogData, readPlanFile } from "./gather";
+import { hasLog, insertLog, setFilePath } from "./store";
+
+export * from "./store";
+export { buildLogMarkdown } from "./build";
+export { logFolder, setLogFolder } from "./folder";
+export { getHq, setHq } from "./hq";
+
+const inFlight = new Map<string, Promise<void>>();
+// Tasks known to have a log, so a poll that sees a merged PR again asks
+// nothing of the database.
+const done = new Set<string>();
+
+const sqliteNow = () => new Date().toISOString().replace("T", " ").slice(0, 19);
+
+export interface CaptureOpts {
+  // The PR's head at the merge, when the caller knows it.
+  head?: string | null;
+  // The plan, when it was read already; else the worktree is read now.
+  plan?: string | null;
+  // A log written after the worktree went (the backfill).
+  planKept?: boolean;
+  // Skip asking GitHub for the merge commit (a batch of old tasks).
+  noGh?: boolean;
+  // Given, the file is handed over instead of committed: a batch commits
+  // once at its end.
+  onFile?: (file: string, hq: NonNullable<Destination["hq"]>) => void;
+}
+
+function eligible(s: Session | undefined): s is Session {
+  return (
+    !!s &&
+    !!s.task_prompt &&
+    !s.peer_mirror &&
+    s.task_status !== "dropped" &&
+    (s.task_status === "merged" || s.pr_status === "merged")
+  );
+}
+
+async function mergeCommitOf(s: Session): Promise<string | null> {
+  const project = s.project_id ? getProject(s.project_id) : undefined;
+  if (!project || !s.pr_number || process.env.AGENTOS_SESSION_LOGS_NO_GH)
+    return null;
+  try {
+    const out = await run(
+      "gh",
+      [
+        "pr",
+        "view",
+        String(s.pr_number),
+        "--json",
+        "mergeCommit",
+        "-q",
+        ".mergeCommit.oid",
+      ],
+      project.working_directory.replace(/^~/, os.homedir()),
+      15_000
+    );
+    return out.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeLog(
+  id: string,
+  opts: CaptureOpts & { plan?: string | null } = {}
+): Promise<boolean> {
+  const row = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+    | Session
+    | undefined;
+  if (!eligible(row) || hasLog(id)) return false;
+  const s = { ...row, merged_at: row.merged_at ?? sqliteNow() };
+  const mergeCommit = opts.noGh ? null : await mergeCommitOf(s);
+  const data = gatherLogData(s, {
+    plan: opts.plan ?? null,
+    planKept: opts.planKept ?? true,
+    head: opts.head ?? null,
+    mergeCommit: mergeCommit ?? (opts.head ? `${opts.head} (PR head)` : null),
+  });
+  const markdown = buildLogMarkdown(data);
+  const start = sqliteMs(data.startedAt);
+  const end = sqliteMs(data.mergedAt);
+  const workspaceId =
+    s.workspace_id ?? getProject(s.project_id ?? "")?.workspace_id ?? null;
+  const stored = insertLog({
+    sessionId: id,
+    projectId: s.project_id,
+    workspaceId,
+    markdown,
+    header: {
+      id,
+      name: data.name,
+      workspace: data.workspace,
+      project: data.project,
+      branch: data.branch,
+      prNumber: data.prNumber,
+      prUrl: data.prUrl,
+      mergeCommit: data.mergeCommit,
+      startedAt: data.startedAt,
+      mergedAt: data.mergedAt,
+      durationMs: start !== null && end !== null ? end - start : null,
+      costUsd: data.usage.reduce((t, u) => t + u.costUsd, 0),
+      planKept: data.planKept,
+      hasPlan: data.plan !== null,
+    },
+    filePath: null,
+  });
+  if (!stored) return false;
+  try {
+    const { file, hq } = writeLogFileTo(
+      {
+        workspace: data.workspace,
+        workspaceId,
+        project: data.project,
+        projectId: s.project_id,
+        name: data.name,
+        id,
+        day: (data.mergedAt ?? sqliteNow()).slice(0, 10),
+      },
+      markdown
+    );
+    setFilePath(id, file);
+    if (hq && opts.onFile) opts.onFile(file, hq);
+    else if (hq)
+      await commitLogs(
+        hq.dir,
+        [file],
+        `session log: ${data.name.replace(/\s+/g, " ").trim().slice(0, 100)}`,
+        hq.visibility
+      );
+  } catch (error) {
+    // The database holds the log; the file is a copy.
+    console.error(`[session-logs] file for ${id}:`, error);
+  }
+  return true;
+}
+
+export function captureMergedTask(
+  id: string,
+  opts: CaptureOpts = {}
+): Promise<void> {
+  if (done.has(id)) return Promise.resolve();
+  const running = inFlight.get(id);
+  if (running) return running;
+  let plan: string | null | undefined = opts.plan;
+  try {
+    if (plan === undefined) {
+      const row = db
+        .prepare(`SELECT worktree_path FROM sessions WHERE id = ?`)
+        .get(id) as { worktree_path: string | null } | undefined;
+      plan = readPlanFile(row?.worktree_path ?? null);
+    }
+  } catch (error) {
+    console.error(`[session-logs] plan for ${id}:`, error);
+  }
+  const job = (async () => {
+    // After the caller's own work: the merge never waits on this.
+    await new Promise<void>((r) => setImmediate(r));
+    try {
+      await writeLog(id, { ...opts, plan });
+      if (hasLog(id)) done.add(id);
+    } catch (error) {
+      console.error(`[session-logs] ${id}:`, error);
+    }
+  })().finally(() => inFlight.delete(id));
+  inFlight.set(id, job);
+  return job;
+}
+
+// Tests start from nothing.
+export function resetSessionLogState(): void {
+  done.clear();
+  inFlight.clear();
+}

package/lib/session-logs/paths.ts

@@ -0,0 +1,37 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { getProject, getProjectRepositories } from "../projects";
+
+export const expand = (p: string) =>
+  p === "~" ? os.homedir() : p.replace(/^~(?=\/)/, os.homedir());
+
+// The path with symlinks resolved as far as it exists, so a link into a
+// repository is seen for what it is.
+export function resolved(p: string): string {
+  let cur = path.resolve(p);
+  const rest: string[] = [];
+  while (!fs.existsSync(cur)) {
+    const up = path.dirname(cur);
+    if (up === cur) break;
+    rest.unshift(path.basename(cur));
+    cur = up;
+  }
+  return path.join(fs.realpathSync(cur), ...rest);
+}
+
+export const within = (child: string, parent: string) => {
+  const rel = path.relative(parent, child);
+  return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+};
+
+export function repoPaths(projectId: string): string[] {
+  const project = getProject(projectId);
+  if (!project) return [];
+  return [
+    project.working_directory,
+    ...getProjectRepositories(projectId).map((r) => r.path),
+  ]
+    .filter(Boolean)
+    .map((p) => resolved(expand(p)));
+}

package/lib/session-logs/reexport.ts

@@ -0,0 +1,90 @@
+/**
+ * Rewrites the files of logs already in the database to where they'd go
+ * now, from the stored markdown: no rebuild, no model. The old files are
+ * left alone. A log whose file is already in its destination is skipped, so
+ * a second run changes nothing.
+ */
+
+import path from "path";
+import { db } from "../db";
+import { destination, writeLogFileTo } from "./folder";
+import { commitLogs } from "./hq";
+import { headerOf, setFilePath, type LogRow } from "./store";
+
+export interface ReexportResult {
+  moved: number;
+  unchanged: number;
+  failed: number;
+  committed: number;
+}
+
+export async function reexportLogs(
+  opts: { dry?: boolean; log?: (line: string) => void } = {}
+): Promise<ReexportResult> {
+  const log = opts.log ?? (() => {});
+  const rows = db
+    .prepare(
+      `SELECT * FROM session_logs
+       ORDER BY json_extract(data, '$.mergedAt'), created_at`
+    )
+    .all() as LogRow[];
+  const result: ReexportResult = {
+    moved: 0,
+    unchanged: 0,
+    failed: 0,
+    committed: 0,
+  };
+  const byHq = new Map<
+    string,
+    { files: string[]; visibility: "private" | "internal" | "none" }
+  >();
+  for (const row of rows) {
+    const h = headerOf(row);
+    const target = {
+      workspace: h.workspace,
+      workspaceId: row.workspace_id,
+      project: h.project,
+      projectId: row.project_id,
+      name: h.name,
+      id: row.session_id,
+      day: (h.mergedAt ?? row.created_at).slice(0, 10),
+    };
+    try {
+      const dest = destination(target);
+      if (row.file_path && path.dirname(row.file_path) === dest.dir) {
+        result.unchanged++;
+        continue;
+      }
+      if (opts.dry) {
+        log(`  would move ${h.name} to ${dest.dir}`);
+        result.moved++;
+        continue;
+      }
+      const { file, hq } = writeLogFileTo(target, row.markdown);
+      setFilePath(row.session_id, file);
+      if (hq) {
+        const entry = byHq.get(hq.dir) ?? {
+          files: [],
+          visibility: hq.visibility,
+        };
+        entry.files.push(file);
+        byHq.set(hq.dir, entry);
+      }
+      result.moved++;
+      log(`  wrote ${file}`);
+    } catch (error) {
+      result.failed++;
+      log(`  FAILED ${h.name} (${row.session_id.slice(0, 8)}): ${error}`);
+    }
+  }
+  for (const [hq, { files, visibility }] of byHq) {
+    await commitLogs(
+      hq,
+      files,
+      `session logs: ${files.length} moved in`,
+      visibility
+    );
+    result.committed += files.length;
+  }
+  return result;
+}

package/lib/session-logs/store.ts

@@ -0,0 +1,105 @@
+import { db } from "../db";
+
+// What the list and the orchestrator's tool show of a log without its text.
+export interface LogHeader {
+  id: string;
+  name: string;
+  workspace: string | null;
+  project: string | null;
+  branch: string | null;
+  prNumber: number | null;
+  prUrl: string | null;
+  mergeCommit: string | null;
+  startedAt: string | null;
+  mergedAt: string | null;
+  durationMs: number | null;
+  costUsd: number;
+  planKept: boolean;
+  hasPlan: boolean;
+  createdAt: string;
+  filePath: string | null;
+}
+
+export interface LogRow {
+  session_id: string;
+  project_id: string | null;
+  workspace_id: string | null;
+  created_at: string;
+  markdown: string;
+  data: string;
+  file_path: string | null;
+}
+
+export const hasLog = (sessionId: string): boolean =>
+  !!db
+    .prepare(`SELECT 1 FROM session_logs WHERE session_id = ?`)
+    .get(sessionId);
+
+export function getLog(sessionId: string): LogRow | null {
+  return (
+    (db
+      .prepare(`SELECT * FROM session_logs WHERE session_id = ?`)
+      .get(sessionId) as LogRow | undefined) ?? null
+  );
+}
+
+// True when this call stored it: a log already there is never replaced.
+export function insertLog(row: {
+  sessionId: string;
+  projectId: string | null;
+  workspaceId: string | null;
+  markdown: string;
+  header: Omit<LogHeader, "createdAt" | "filePath">;
+  filePath: string | null;
+}): boolean {
+  return (
+    db
+      .prepare(
+        `INSERT OR IGNORE INTO session_logs
+           (session_id, project_id, workspace_id, markdown, data, file_path)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        row.sessionId,
+        row.projectId,
+        row.workspaceId,
+        row.markdown,
+        JSON.stringify(row.header),
+        row.filePath
+      ).changes > 0
+  );
+}
+
+export function setFilePath(sessionId: string, filePath: string): void {
+  db.prepare(`UPDATE session_logs SET file_path = ? WHERE session_id = ?`).run(
+    filePath,
+    sessionId
+  );
+}
+
+const toHeader = (r: LogRow): LogHeader => ({
+  ...(JSON.parse(r.data) as LogHeader),
+  createdAt: r.created_at,
+  filePath: r.file_path,
+});
+
+export const headerOf = (r: LogRow): LogHeader => toHeader(r);
+
+// Newest merge first.
+export function listLogs(
+  where: { projectId?: string; workspaceId?: string },
+  limit = 50
+): LogHeader[] {
+  const rows = db
+    .prepare(
+      `SELECT * FROM session_logs
+       WHERE (@p IS NULL OR project_id = @p) AND (@w IS NULL OR workspace_id = @w)
+       ORDER BY json_extract(data, '$.mergedAt') DESC, created_at DESC LIMIT @n`
+    )
+    .all({
+      p: where.projectId ?? null,
+      w: where.workspaceId ?? null,
+      n: Math.max(1, Math.min(limit, 500)),
+    }) as LogRow[];
+  return rows.map(toHeader);
+}

package/lib/sidebar/live-status.ts

@@ -0,0 +1,52 @@
+import {
+  PR_STAGE_BUSY,
+  PR_STAGE_SHORT,
+  type PrStage,
+  type PrStageName,
+} from "../tasks/pr-stage";
+
+export type LiveTone = "blue" | "amber" | "red" | "green" | "purple" | "muted";
+
+export interface LivePart {
+  text: string;
+  tone: LiveTone;
+  // Still moving on its own: the UI shows a spinner.
+  busy?: boolean;
+}
+
+export const PR_STAGE_TONE: Record<PrStageName, LiveTone> = {
+  merged: "purple",
+  conflicts: "amber",
+  "ci-failed": "red",
+  "ci-running": "blue",
+  "ci-settling": "blue",
+  "review-running": "blue",
+  "review-blocked": "red",
+  waiting: "amber",
+  armed: "green",
+  open: "muted",
+};
+
+// What the row's second line says about the session right now, in order:
+// "Compacting", then "PR CI". Empty when there is nothing to say.
+export function liveParts(input: {
+  compacting?: boolean;
+  prStage?: PrStage;
+}): LivePart[] {
+  const parts: LivePart[] = [];
+  if (input.compacting)
+    parts.push({ text: "Compacting", tone: "blue", busy: true });
+  const s = input.prStage;
+  if (s) {
+    const word = PR_STAGE_SHORT[s.stage];
+    parts.push({
+      text: s.stage === "open" ? "PR" : `PR ${word}`,
+      tone: PR_STAGE_TONE[s.stage],
+      busy: PR_STAGE_BUSY.has(s.stage),
+    });
+  }
+  return parts;
+}
+
+export const liveText = (parts: LivePart[]) =>
+  parts.map((p) => p.text).join(" · ");

package/lib/tasks/finish.ts

@@ -23,6 +23,7 @@ import { getProject } from "../projects";
 import { canSignOff } from "./state";
 import { forgetPR, getTaskSession, prFor, projectPathFor } from "./session";
 import { dropSessionDatabase } from "../project-config/database";
+import { captureMergedTask } from "../session-logs";
 
 // Never deleted, whatever a setting says.
 export const PROTECTED_BRANCHES = new Set(["main", "master", "HEAD"]);
@@ -154,6 +155,8 @@ export async function signOffTask(
     signingOff.delete(id);
   }
   syncTaskCardInBackground(session, "merged", pr);
+  // Reads the plan file now: cleanup below removes the worktree.
+  void captureMergedTask(id, { head: opts.head ?? pr!.head ?? null });
   const head = opts.head ?? pr!.head;
   resolveMergedTaskAsks(
     id,