@saadnvd1/agent-os 0.3.782 → 0.3.786

package/lib/whats-new/generate.ts

@@ -0,0 +1,107 @@
+import fs from "fs";
+import path from "path";
+import { areaFor, collectCommits, type Git } from "./collect";
+import { lintEntry } from "./lint";
+import { fileSchema, type Entry } from "./schema";
+import { authorLine, fillGaps, type Ask, type Line } from "./summarize";
+import { WHATS_NEW_FILE } from "./load";
+
+export interface PrInfo {
+  body: string;
+  url: string;
+}
+
+export interface GenerateDeps {
+  git: Git;
+  /** Bodies and links of merged PRs; throws when it can't ask, so nothing is guessed. */
+  prs: (numbers: number[]) => Map<number, PrInfo>;
+  ask: Ask;
+  blocklist: string[];
+}
+
+export interface GenerateResult {
+  added: Entry[];
+  /** Merges that had a line but couldn't ship, with the reason. */
+  dropped: { pr: number; reason: string }[];
+  skipped: number;
+  head: string;
+}
+
+// `raw` is what is written back for existing entries, so a field the schema
+// doesn't know about survives a run too.
+export function readFile(root: string): { entries: Entry[]; raw: unknown[] } {
+  try {
+    const json = JSON.parse(
+      fs.readFileSync(path.join(root, WHATS_NEW_FILE), "utf-8")
+    );
+    return { entries: fileSchema.parse(json).entries, raw: json.entries };
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === "ENOENT")
+      return { entries: [], raw: [] };
+    throw e;
+  }
+}
+
+/**
+ * New entries for merges since `through` (or the last `sinceDays`). Append
+ * only: an id already in the file is never read, changed or reordered, so a
+ * hand edit or "hidden" survives. Writes the file only when there is
+ * something to add.
+ */
+export async function generate(
+  root: string,
+  opts: { through?: string | null; sinceDays: number; write: boolean },
+  deps: GenerateDeps
+): Promise<GenerateResult> {
+  const { entries, raw } = readFile(root);
+  const head = deps.git(["rev-parse", "HEAD"]).trim();
+  const commits = collectCommits(
+    deps.git,
+    opts,
+    new Set(entries.map((e) => e.id)),
+    WHATS_NEW_FILE
+  );
+  const result: GenerateResult = { added: [], dropped: [], skipped: 0, head };
+  if (!commits.length) return result;
+
+  const prs = deps.prs(commits.map((c) => c.pr));
+  const lines = new Map<number, Line>();
+  const gaps = [];
+  for (const c of commits) {
+    const line = authorLine(prs.get(c.pr)?.body);
+    if (line) lines.set(c.pr, line);
+    else gaps.push({ n: c.pr, type: c.type, title: c.title });
+  }
+  if (gaps.length)
+    for (const [n, line] of await fillGaps(gaps, deps.ask)) lines.set(n, line);
+
+  for (const c of commits) {
+    const line = lines.get(c.pr);
+    if (!line || "skip" in line) {
+      result.skipped++;
+      continue;
+    }
+    const entry: Entry = {
+      id: c.pr,
+      date: c.date,
+      kind: line.kind,
+      area: areaFor(c),
+      text: line.text,
+      ...(prs.get(c.pr)?.url && { url: prs.get(c.pr)!.url }),
+    };
+    const bad = lintEntry(entry, deps.blocklist);
+    if (bad) result.dropped.push({ pr: c.pr, reason: bad });
+    else result.added.push(entry);
+  }
+
+  if (opts.write && result.added.length) {
+    const file = path.join(root, WHATS_NEW_FILE);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(
+      file,
+      JSON.stringify({ v: 1, entries: [...raw, ...result.added] }, null, 2) +
+        "\n"
+    );
+  }
+  return result;
+}

package/lib/whats-new/lint.ts

@@ -0,0 +1,69 @@
+import fs from "fs";
+import path from "path";
+import { agentosHome } from "@/lib/agentos-home";
+import type { Entry } from "./schema";
+
+// The repo is public, so this checks only generic shapes. Names that must
+// never appear (other products) live in a private list outside the repo and
+// are passed in.
+const GENERIC: [string, RegExp][] = [
+  ["a user path", /\/Users\/|~\/|\/home\/\w|(?:^|[\s(])\.[a-z][\w-]*\//i],
+  ["a file path", /\b[\w.-]+\/[\w.-]+\/[\w./-]+|\/[\w.-]+\/[\w.-]+/],
+  [
+    "a file name",
+    /\b[\w-]+\.(?:tsx?|jsx?|mjs|json|md|sh|py|sql|ya?ml|toml)\b/i,
+  ],
+  ["an IP address", /\b\d{1,3}(?:\.\d{1,3}){3}\b/],
+  [
+    "a hostname",
+    /\b[a-z0-9-]+(?:\.[a-z0-9-]+)*\.(?:ts\.net|local|internal|lan|home|com|io|net|app|dev|org|ai|co)\b/i,
+  ],
+  ["a token", /\b(?:gh[pousr]_|github_pat_|npm_|sk-|xox[bp]-)[\w-]{8,}/],
+  ["a long secret-looking string", /\b[A-Za-z0-9_-]{32,}\b/],
+  ["tailnet", /tailnet|tailscale/i],
+  ["a CVE", /\bCVE-\d{4}-\d+/i],
+  ["a vulnerability", /vulnerab|exploit|\bRCE\b/i],
+];
+
+const escape = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+/** Why this text can't ship, or null when it can. */
+export function lintText(
+  text: string,
+  blocklist: string[] = []
+): string | null {
+  for (const [what, re] of GENERIC)
+    if (re.test(text)) return `contains ${what}`;
+  for (const name of blocklist) {
+    if (
+      new RegExp(
+        `(?<![\\p{L}\\p{N}])${escape(name)}(?![\\p{L}\\p{N}])`,
+        "iu"
+      ).test(text)
+    )
+      return "contains a blocked name";
+  }
+  return null;
+}
+
+export const lintEntry = (e: Entry, blocklist: string[] = []) =>
+  lintText(e.text, blocklist) ?? (e.note ? lintText(e.note, blocklist) : null);
+
+const BLOCKLIST_HEADER =
+  "# One name per line (any name that must never appear in the\n# changelog). Matched whole-word, any case. Lives outside the repo on purpose.\n";
+
+export const blocklistPath = () => agentosHome("whats-new-blocklist.txt");
+
+/** The private list; created empty (with a comment) when it is missing. */
+export function readBlocklist(file: string = blocklistPath()): string[] {
+  if (!fs.existsSync(file)) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, BLOCKLIST_HEADER);
+    return [];
+  }
+  return fs
+    .readFileSync(file, "utf-8")
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l && !l.startsWith("#"));
+}

package/lib/whats-new/load.ts

@@ -0,0 +1,59 @@
+import fs from "fs";
+import path from "path";
+import { fileSchema, type Entry, type Head, type Page } from "./schema";
+
+export const WHATS_NEW_FILE = "content/whats-new.json";
+
+const fileAt = (root: string) => path.join(root, WHATS_NEW_FILE);
+
+let cached: { file: string; mtime: number; entries: Entry[] } | null = null;
+
+// Newest first: by day, then by PR number within it. The file is append-only
+// and in the order the generator wrote it, so the order is made here.
+export const byNewest = (a: Entry, b: Entry) =>
+  a.date === b.date ? b.id - a.id : a.date < b.date ? 1 : -1;
+
+/** Every shown entry, newest first. A missing or unreadable file is empty. */
+export function loadEntries(root: string = process.cwd()): Entry[] {
+  const file = fileAt(root);
+  try {
+    const mtime = fs.statSync(file).mtimeMs;
+    if (cached?.file === file && cached.mtime === mtime) return cached.entries;
+    const parsed = fileSchema.safeParse(
+      JSON.parse(fs.readFileSync(file, "utf-8"))
+    );
+    const entries = parsed.success
+      ? parsed.data.entries.filter((e) => !e.hidden).sort(byNewest)
+      : [];
+    cached = { file, mtime, entries };
+    return entries;
+  } catch {
+    return [];
+  }
+}
+
+const RECENT = 10;
+
+export function headOf(entries: Entry[]): Head {
+  return {
+    latestId: entries.reduce((m, e) => Math.max(m, e.id), 0),
+    latestDate: entries[0]?.date ?? null,
+    count: entries.length,
+    recent: entries.slice(0, RECENT).map((e) => e.id),
+  };
+}
+
+/** `limit` entries older than the `before` day (all days when it is unset). */
+export function pageOf(
+  entries: Entry[],
+  { before, limit }: { before?: string | null; limit: number }
+): Page {
+  const older = before ? entries.filter((e) => e.date < before) : entries;
+  const slice = older.slice(0, limit);
+  // Never split a day across pages: the next page starts at a day boundary.
+  const last = slice[slice.length - 1];
+  const rest = older.slice(limit);
+  while (last && rest.length && rest[0].date === last.date)
+    slice.push(rest.shift()!);
+  return { entries: slice, hasMore: rest.length > 0 };
+}

package/lib/whats-new/rows.ts

@@ -0,0 +1,79 @@
+import type { Entry } from "./schema";
+
+export type Row =
+  | { type: "heading"; key: string; label: string }
+  | { type: "day"; key: string; label: string }
+  | { type: "entry"; key: string; entry: Entry }
+  | { type: "divider"; key: string; label: string };
+
+const MONTHS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec",
+];
+
+const day = (iso: string) => {
+  const [y, m, d] = iso.split("-").map(Number);
+  return new Date(y, m - 1, d);
+};
+
+const isoOf = (d: Date) =>
+  `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+
+/** "Today", "Yesterday" or "Oct 27" (with the year when it isn't this one). */
+export function dayLabel(iso: string, now: Date = new Date()): string {
+  if (iso === isoOf(now)) return "Today";
+  const y = new Date(now);
+  y.setDate(y.getDate() - 1);
+  if (iso === isoOf(y)) return "Yesterday";
+  const d = day(iso);
+  const base = `${MONTHS[d.getMonth()]} ${d.getDate()}`;
+  return d.getFullYear() === now.getFullYear()
+    ? base
+    : `${base}, ${d.getFullYear()}`;
+}
+
+/**
+ * Day headings with entries under them, newest first. When some entries are
+ * newer than `seen`, a divider marks where the last visit ended.
+ */
+export function buildRows(
+  entries: Entry[],
+  seen: number | null,
+  now: Date = new Date()
+): Row[] {
+  const rows: Row[] = [];
+  const anyUnread = seen !== null && entries.some((e) => e.id > seen);
+  let current: string | null = null;
+  let divided = false;
+  for (const e of entries) {
+    if (anyUnread && !divided && e.id <= seen!) {
+      divided = true;
+      current = null;
+      rows.push({
+        type: "divider",
+        key: "divider",
+        label: `You last looked ${dayLabel(e.date, now)}`,
+      });
+    }
+    if (e.date !== current) {
+      current = e.date;
+      rows.push({
+        type: "day",
+        key: `day-${e.date}-${rows.length}`,
+        label: dayLabel(e.date, now),
+      });
+    }
+    rows.push({ type: "entry", key: `e-${e.id}`, entry: e });
+  }
+  return rows;
+}

package/lib/whats-new/schema.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+
+export const KINDS = ["new", "improved", "fixed"] as const;
+export type Kind = (typeof KINDS)[number];
+
+export const KIND_LABEL: Record<Kind, string> = {
+  new: "New",
+  improved: "Improved",
+  fixed: "Fixed",
+};
+
+export const entrySchema = z.object({
+  id: z.number().int().positive(),
+  date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  kind: z.enum(KINDS),
+  area: z.string().min(1).max(40),
+  text: z.string().min(1).max(280),
+  note: z.string().max(400).optional(),
+  url: z.string().optional(),
+  hidden: z.boolean().optional(),
+});
+export type Entry = z.infer<typeof entrySchema>;
+
+export const fileSchema = z.object({
+  v: z.literal(1),
+  entries: z.array(entrySchema),
+});
+export type WhatsNewFile = z.infer<typeof fileSchema>;
+
+export interface Head {
+  latestId: number;
+  latestDate: string | null;
+  count: number;
+  /** Ids of the newest few, so the footer can count unread without the list. */
+  recent: number[];
+}
+
+export interface Page {
+  entries: Entry[];
+  hasMore: boolean;
+}

package/lib/whats-new/summarize.ts

@@ -0,0 +1,91 @@
+import { z } from "zod";
+import { KINDS, type Kind } from "./schema";
+
+export type Line = { skip: true } | { kind: Kind; text: string };
+
+const LINE = /^\s*Whats-new:\s*(.+?)\s*$/gim;
+const KIND_BY_NAME: Record<string, Kind> = {
+  new: "new",
+  improved: "improved",
+  fixed: "fixed",
+};
+
+export const tidy = (text: string) => {
+  const t = text.replace(/\s+/g, " ").trim();
+  return /[.!?]$/.test(t) ? t : `${t}.`;
+};
+
+/** The author's line from a PR body (the last one wins); null when absent or malformed. */
+export function authorLine(body: string | null | undefined): Line | null {
+  if (!body) return null;
+  let last: string | undefined;
+  for (const m of body.slice(0, 65_536).matchAll(LINE)) last = m[1];
+  if (!last) return null;
+  if (/^skip\.?$/i.test(last)) return { skip: true };
+  const m = /^(new|improved|fixed)\s*[—–:-]+\s*(.+)$/i.exec(last);
+  if (!m) return null;
+  return { kind: KIND_BY_NAME[m[1].toLowerCase()], text: tidy(m[2]) };
+}
+
+export const GAP_SYSTEM = `You write one line of a changelog for people who use a coding-agent app. You get a JSON list of merged changes, each only a commit subject. Answer with a JSON array and nothing else: one object per item, {"n": <n>, "kind": "new" | "improved" | "fixed", "text": "<sentence>"}, or {"n": <n>, "skip": true} when a user would not see the change.
+
+Rules for text: one plain sentence under 140 characters that says what a user can now do or what stopped going wrong. Say nothing the subject does not say. No jargon, no file or function names, no paths, no emoji, no dashes used as punctuation, never the word "improved", and no marketing words. "new" is something that did not exist, "fixed" is something that was broken, "improved" is something that already existed and works better.`;
+
+export interface GapItem {
+  n: number;
+  type: string;
+  title: string;
+}
+
+const answer = z.array(
+  z.union([
+    z.object({ n: z.number(), skip: z.literal(true) }),
+    z.object({
+      n: z.number(),
+      kind: z.enum(KINDS),
+      text: z.string().min(1).max(400),
+    }),
+  ])
+);
+
+export function parseAnswer(raw: string): Map<number, Line> {
+  const out = new Map<number, Line>();
+  const start = raw.indexOf("[");
+  const end = raw.lastIndexOf("]");
+  if (start < 0 || end < start) return out;
+  let json: unknown;
+  try {
+    json = JSON.parse(raw.slice(start, end + 1));
+  } catch {
+    return out;
+  }
+  const parsed = answer.safeParse(json);
+  if (!parsed.success) return out;
+  for (const r of parsed.data)
+    out.set(
+      r.n,
+      "skip" in r ? { skip: true } : { kind: r.kind, text: tidy(r.text) }
+    );
+  return out;
+}
+
+export type Ask = (system: string, prompt: string) => Promise<string>;
+
+const BATCH = 80;
+
+/** Haiku sees the commit subject only: never the diff and never the PR body. */
+export async function fillGaps(
+  items: GapItem[],
+  ask: Ask
+): Promise<Map<number, Line>> {
+  const out = new Map<number, Line>();
+  for (let i = 0; i < items.length; i += BATCH) {
+    const batch = items.slice(i, i + BATCH);
+    const prompt = JSON.stringify(
+      batch.map(({ n, type, title }) => ({ n, type, subject: title }))
+    );
+    for (const [n, line] of parseAnswer(await ask(GAP_SYSTEM, prompt)))
+      if (batch.some((b) => b.n === n)) out.set(n, line);
+  }
+  return out;
+}

package/lib/whats-new/unread.ts

@@ -0,0 +1,14 @@
+// Read/unread is local to a browser: the id of the newest entry seen.
+// Pure, so a native client can use the same rules.
+
+export const SEEN_KEY = "aos:whatsnew:seen";
+export const UNREAD_CAP = 9;
+
+/** How many of the newest entries are newer than the seen id (capped by the head's list). */
+export function unreadCount(recent: number[], seen: number | null): number {
+  if (seen === null) return 0;
+  return recent.filter((id) => id > seen).length;
+}
+
+export const unreadLabel = (n: number) =>
+  n > UNREAD_CAP ? `${UNREAD_CAP}+` : String(n);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.782",
+  "version": "0.3.786",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"
@@ -8,6 +8,7 @@
   "files": [
     "app/",
     "components/",
+    "content/",
     "contexts/",
     "data/",
     "hooks/",

package/scripts/autodeploy

@@ -13,6 +13,11 @@
 #   HELD <sha> <seconds> left in the restart gap (since <last restart sha>)
 # Another machine (a server) runs it with AGENTOS_PUBLISH=0: deploy
 # only, and its own AGENTOS_RESTART. Only one machine publishes to npm.
+# The machine that publishes also writes the What's New entries for what
+# merged (scripts/whats-new, before the publish, so the package carries them)
+# and pushes them as a commit that touches only content/whats-new.json. Such a
+# commit is pulled but never rebuilt or restarted for, and the generator
+# ignores it, so it can't loop. AGENTOS_WHATS_NEW=0 turns the step off.
 set -euo pipefail
 cd "$(dirname "$0")/.."
 
@@ -42,6 +47,18 @@ published=$(cat "$state/published" 2>/dev/null || true)
 [ "$head" = "$deployed" ] && [ "$head" = "$published" ] && exit 0
 log() { echo "$(date '+%Y-%m-%d %-I:%M %p') $*"; }
 
+# A head that differs from the deployed one only in the changelog file needs
+# a pull, not a build or a restart: the file is read from disk when asked.
+changelog=content/whats-new.json
+if [ "$head" != "$deployed" ] && [ -n "$deployed" ] &&
+  [ "$(git diff --name-only "$deployed" "$head" 2>/dev/null)" = "$changelog" ] &&
+  [ -z "$(git status --porcelain --untracked-files=no)" ] &&
+  git merge -q --ff-only "$head" 2>/dev/null; then
+  deployed=$head
+  git rev-parse HEAD > "$state/deployed"
+  [ "$head" = "$published" ] && exit 0
+fi
+
 # Merges land in bursts: one that's under AGENTOS_SETTLE seconds old (2
 # minutes) waits for the next run, so a burst is one build and one restart.
 # Its commit time is the merge's, so this never holds a deploy forever.
@@ -104,6 +121,17 @@ if [ "$head" != "$deployed" ]; then
   scripts/sync-cli-links || log "CLI link sync failed"
 fi
 
+# The changelog is written before the publish, from the same checkout, so the
+# package carries it. Best effort: a failure here never holds up the publish.
+if [ "${AGENTOS_PUBLISH:-1}" != 0 ] && [ "${AGENTOS_WHATS_NEW:-1}" != 0 ] &&
+  [ "$head" != "$published" ] && [ "$head" = "$(git rev-parse HEAD)" ]; then
+  if ! node --import tsx scripts/whats-new.ts --commit \
+    --through-file "$state/whats-new-through" >> "$state/whats-new.log" 2>&1; then
+    log "What's New step failed; see $state/whats-new.log"
+  fi
+  head=$(git rev-parse HEAD)
+fi
+
 # Publishing waits minutes for npm to serve a version, so it runs on its own
 # with its own lock and never holds up the next deploy.
 if [ "$head" != "$published" ] && mkdir "$state/publish.lock" 2>/dev/null; then

package/scripts/autodeploy.test.ts

@@ -113,6 +113,59 @@ describe("autodeploy restart gap", () => {
   });
 });
 
+describe("autodeploy changelog commits", () => {
+  const changelog = (t: ReturnType<typeof setup>, also?: string) => {
+    const work = path.join(t.root, "work");
+    fs.mkdirSync(path.join(work, "content"), { recursive: true });
+    fs.writeFileSync(path.join(work, "content/whats-new.json"), "{}\n");
+    if (also) fs.appendFileSync(path.join(work, "f"), also + "\n");
+    sh(work, "add", "-A");
+    sh(
+      work,
+      "-c",
+      "user.name=t",
+      "-c",
+      "user.email=t@t",
+      "commit",
+      "-qm",
+      "chore(whats-new): add 1 entries"
+    );
+    sh(work, "push", "-q", "origin", "main");
+    return sh(work, "rev-parse", "HEAD");
+  };
+
+  it("pulls a commit that touches only the changelog without a restart", () => {
+    const t = setup();
+    const a = t.commit("a");
+    t.run();
+    expect(t.restarts()).toBe(1);
+
+    const b = changelog(t);
+    expect(t.run()).toBe("");
+    expect(t.deployed()).toBe(b);
+    expect(t.deployed()).not.toBe(a);
+    expect(t.restarts()).toBe(1);
+    expect(fs.existsSync(path.join(t.clone, "content/whats-new.json"))).toBe(
+      true
+    );
+    expect(t.run()).toBe("");
+  });
+
+  it("still redeploys a commit that touches the changelog and something else", () => {
+    const t = setup();
+    t.commit("a");
+    t.run();
+    const c = changelog(t, "more");
+    fs.writeFileSync(
+      path.join(t.state, "restarted"),
+      `${Math.floor(Date.now() / 1000) - 3601}\n`
+    );
+    expect(t.run()).toContain("Deploying");
+    expect(t.deployed()).toBe(c);
+    expect(t.restarts()).toBe(2);
+  });
+});
+
 describe("autodeploy CLI links", () => {
   it("repoints a link into another clone at the live checkout after a deploy", () => {
     const t = setup();