@saadnvd1/agent-os 0.3.794 → 0.3.807

package/scripts/autodeploy

@@ -29,6 +29,10 @@ fi
 
 state="$HOME/.agent-os/autodeploy"
 mkdir -p "$state"
+# Tells the server this checkout is deployed from here, so its own automatic
+# updates stand aside (lib/updates/run.ts managedByAutodeploy). Before the
+# lock: a long deploy still counts as managing it.
+touch "$state/heartbeat"
 # A lock older than 30 minutes is from a run that died.
 for lock in lock publish.lock; do
   if [ -d "$state/$lock" ] && [ -n "$(find "$state/$lock" -maxdepth 0 -mmin +30)" ]; then

package/scripts/autodeploy.test.ts

@@ -87,6 +87,18 @@ function setup() {
   return { root, home, clone, commit, run, restarts, deployed, state };
 }
 
+describe("autodeploy heartbeat", () => {
+  it("touches it on every run, even one with nothing to deploy", () => {
+    const t = setup();
+    t.commit("a");
+    t.run();
+    const beat = path.join(t.state, "heartbeat");
+    fs.utimesSync(beat, new Date(0), new Date(0));
+    expect(t.run()).toBe("");
+    expect(Date.now() - fs.statSync(beat).mtimeMs).toBeLessThan(60_000);
+  });
+});
+
 describe("autodeploy restart gap", () => {
   it("holds a second deploy inside the gap, then deploys the newest head once it ends", () => {
     const t = setup();

package/scripts/check

@@ -37,7 +37,7 @@ if has static; then
     out=$(mktemp -d); trap 'rm -rf "$out"' EXIT
     pids=()
     npx tsc --noEmit >"$out/typecheck" 2>&1 & pids+=($!)
-    npx eslint . --max-warnings=40 --concurrency=auto >"$out/lint" 2>&1 & pids+=($!)
+    npx eslint . --max-warnings=28 --concurrency=auto >"$out/lint" 2>&1 & pids+=($!)
     npx prettier --check . --log-level warn >"$out/format" 2>&1 & pids+=($!)
     failed=()
     names=(typecheck lint format)
@@ -51,7 +51,7 @@ if has static; then
     fi
   else
     step "typecheck"; npx tsc --noEmit
-    step "lint";      npx eslint . --max-warnings=40 --concurrency=auto
+    step "lint";      npx eslint . --max-warnings=28 --concurrency=auto
     step "format";    npx prettier --check . --log-level warn
   fi
 fi

package/scripts/docs-links.test.ts

@@ -2,35 +2,11 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { describe, expect, it } from "vitest";
+import { headingSlugs, slug } from "./lib/heading-slugs";
 
 const root = path.resolve(__dirname, "..");
 const REPO = "saadnvd1/agent-os";
 
-function slug(heading: string): string {
-  return heading
-    .trim()
-    .toLowerCase()
-    .replace(/[`*]/g, "")
-    .replace(/[^\w\- ]/g, "")
-    .replace(/ /g, "-");
-}
-
-function headingSlugs(text: string): Set<string> {
-  const seen = new Map<string, number>();
-  const out = new Set<string>();
-  let fence = false;
-  for (const line of text.split("\n")) {
-    if (line.startsWith("```")) fence = !fence;
-    const m = !fence && /^#+ (.*)$/.exec(line);
-    if (!m) continue;
-    const base = slug(m[1]);
-    const n = seen.get(base) ?? 0;
-    seen.set(base, n + 1);
-    out.add(n ? `${base}-${n}` : base);
-  }
-  return out;
-}
-
 function markdownFiles(): string[] {
   const out = execFileSync(
     "git",

package/scripts/lib/commands.sh

@@ -120,7 +120,20 @@ wsl_next_steps() {
     echo "  aren't noticed."
 }
 
+# True when the systemd user unit `agent-os enable` writes is running
+# AgentOS: then start, stop and restart go through systemd, or a restart
+# would leave a second server outside the unit for systemd to fight.
+systemd_unit_active() {
+    has_systemd && systemctl --user is-active --quiet agent-os 2>/dev/null
+}
+
 cmd_start() {
+    if ! is_running && has_systemd &&
+        systemctl --user is-enabled --quiet agent-os 2>/dev/null; then
+        systemctl --user start agent-os
+        log_success "AgentOS started (systemd)"
+        return 0
+    fi
     if is_running; then
         local pid
         pid=$(get_pid)
@@ -173,6 +186,13 @@ cmd_start() {
 }
 
 cmd_stop() {
+    if systemd_unit_active; then
+        log_info "Stopping AgentOS (systemd)..."
+        systemctl --user stop agent-os
+        rm -f "$PID_FILE"
+        log_success "AgentOS stopped"
+        return 0
+    fi
     if ! is_running; then
         log_warn "AgentOS is not running"
         return 0
@@ -206,6 +226,11 @@ cmd_stop() {
 }
 
 cmd_restart() {
+    if systemd_unit_active; then
+        systemctl --user restart agent-os
+        log_success "AgentOS restarted (systemd)"
+        return 0
+    fi
     cmd_stop
     sleep 1
     cmd_start
@@ -417,6 +442,9 @@ Type=simple
 ExecStart=$script_path start-foreground
 Restart=on-failure
 RestartSec=10
+# Only the server is stopped on a restart: terminals (tmux), chat workers and
+# an update in progress outlive it, as they do under launchd.
+KillMode=process
 Environment=PATH=/usr/local/bin:/usr/bin:/bin
 
 [Install]
@@ -542,7 +570,10 @@ cmd_start_foreground() {
     # Create PID file before exec (PID stays the same after exec)
     echo "$$" > "$PID_FILE"
 
-    exec npm start
+    # The server itself is the service's main process, not an npm wrapper:
+    # with KillMode=process a wrapper's stop left the old server on the port.
+    npm run --silent prestart || exit 1
+    exec env NODE_ENV=production AGENTOS_SERVER=live node --import tsx server.ts
 }
 
 cmd_help() {

package/scripts/lib/deps-swap.sh

@@ -9,7 +9,9 @@
 
 DEPS=.deps
 STAGE=$DEPS/stage
-PREV=$DEPS/prev
+# Not PREV: build-swap.sh, sourced beside this, uses that for .next-prev,
+# and sharing it sent the old build into .deps/prev.
+DEPS_PREV=$DEPS/prev
 STAMP=.agentos-deps
 
 # What an install depends on. A new Node or CPU rebuilds the native modules.
@@ -29,7 +31,7 @@ install_beside() {
     echo "Dependencies unchanged."
     # The last build ran on these same dependencies, so a rollback has
     # nothing to put back.
-    rm -rf "$PREV"
+    rm -rf "$DEPS_PREV"
     return 10
   fi
   rm -rf "$STAGE"
@@ -52,9 +54,9 @@ install_beside() {
 
 swap_deps() {
   [ -d "$STAGE/node_modules" ] || { echo "no checked install to swap in" >&2; return 1; }
-  rm -rf "$PREV"
+  rm -rf "$DEPS_PREV"
   mkdir -p "$DEPS"
-  [ -d node_modules ] && mv node_modules "$PREV"
+  [ -d node_modules ] && mv node_modules "$DEPS_PREV"
   mv "$STAGE/node_modules" node_modules
   rm -rf "$STAGE"
 }
@@ -62,7 +64,7 @@ swap_deps() {
 # Put the node_modules from before the last swap back (a failed build, or
 # `redeploy --rollback`); the current one is dropped.
 restore_deps() {
-  [ -d "$PREV" ] || return 0
+  [ -d "$DEPS_PREV" ] || return 0
   rm -rf node_modules
-  mv "$PREV" node_modules
+  mv "$DEPS_PREV" node_modules
 }

package/scripts/lib/heading-slugs.ts

@@ -0,0 +1,26 @@
+/** GitHub's anchor for a heading. */
+export function slug(heading: string): string {
+  return heading
+    .trim()
+    .toLowerCase()
+    .replace(/[`*]/g, "")
+    .replace(/[^\w\- ]/g, "")
+    .replace(/ /g, "-");
+}
+
+/** Every heading anchor in a markdown file, numbering repeats like GitHub does. */
+export function headingSlugs(text: string): Set<string> {
+  const seen = new Map<string, number>();
+  const out = new Set<string>();
+  let fence = false;
+  for (const line of text.split("\n")) {
+    if (line.startsWith("```")) fence = !fence;
+    const m = !fence && /^#+ (.*)$/.exec(line);
+    if (!m) continue;
+    const base = slug(m[1]);
+    const n = seen.get(base) ?? 0;
+    seen.set(base, n + 1);
+    out.add(n ? `${base}-${n}` : base);
+  }
+  return out;
+}

package/scripts/lib/update-verify.mjs

@@ -0,0 +1,90 @@
+// Is the server that just restarted healthy? Used by scripts/update-run.mjs
+// after an update's swap and again after a rollback.
+//   - /api/updates/health answers with the build we expect and every
+//     migration applied (a build from before that route: /api/health only);
+//   - a few key routes answer without a server error;
+//   - it stays up: the same startedAt across the stability checks, so a
+//     crash loop under a service manager's restart doesn't pass.
+// Knobs (tests): AGENTOS_VERIFY_UP_MS, AGENTOS_VERIFY_EVERY_MS, AGENTOS_VERIFY_CHECKS.
+
+const SMOKE = ["/api/projects", "/api/sessions", "/api/updates"];
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function get(base, path) {
+  try {
+    const res = await fetch(base + path, {
+      signal: AbortSignal.timeout(10_000),
+    });
+    const body = await res.json().catch(() => null);
+    return { status: res.status, body };
+  } catch {
+    return { status: 0, body: null };
+  }
+}
+
+/** One look: { ok, startedAt } or { ok: false, why }. */
+async function health(base, expect) {
+  const h = await get(base, "/api/updates/health");
+  if (h.status === 404) {
+    // An older build, from before this route: alive is all it can say.
+    const old = await get(base, "/api/health");
+    return old.status === 200 && old.body?.ok
+      ? { ok: true, startedAt: old.body.startedAt ?? null }
+      : { ok: false, why: `the server didn't answer (${old.status})` };
+  }
+  if (h.status !== 200 || !h.body?.ok)
+    return { ok: false, why: `the server didn't answer (${h.status})` };
+  const { build, migrations, startedAt } = h.body;
+  if (expect && build && build !== expect && !build.startsWith("v"))
+    return {
+      ok: false,
+      why: `it is running ${String(build).slice(0, 7)}, not ${expect.slice(0, 7)}`,
+    };
+  if (migrations && migrations.applied < migrations.known)
+    return {
+      ok: false,
+      why: `${migrations.known - migrations.applied} database migration(s) didn't run`,
+    };
+  return { ok: true, startedAt };
+}
+
+/**
+ * Resolves { ok: true } or { ok: false, why } within about
+ * AGENTOS_VERIFY_UP_MS plus the stability checks.
+ */
+export async function verifyServer({ port, expect, env = process.env }) {
+  const base = `http://127.0.0.1:${port}`;
+  const upMs = Number(env.AGENTOS_VERIFY_UP_MS ?? 120_000);
+  const every = Number(env.AGENTOS_VERIFY_EVERY_MS ?? 30_000);
+  const checks = Number(env.AGENTOS_VERIFY_CHECKS ?? 4);
+
+  let first = null;
+  const until = Date.now() + upMs;
+  for (;;) {
+    first = await health(base, expect);
+    if (first.ok || Date.now() >= until) break;
+    await sleep(Math.min(2_000, every));
+  }
+  if (!first.ok) return first;
+
+  for (const path of SMOKE) {
+    const r = await get(base, path);
+    if (r.status === 0 || r.status >= 500)
+      return { ok: false, why: `${path} failed (${r.status || "no answer"})` };
+  }
+
+  for (let i = 0; i < checks; i++) {
+    await sleep(every);
+    const again = await health(base, expect);
+    if (!again.ok)
+      return { ok: false, why: `it stopped answering: ${again.why}` };
+    if (
+      first.startedAt &&
+      again.startedAt &&
+      again.startedAt !== first.startedAt
+    )
+      return { ok: false, why: "it restarted by itself (a crash loop)" };
+  }
+  return { ok: true };
+}

package/scripts/redeploy

@@ -5,6 +5,9 @@
 # Without AGENTOS_RESTART it builds and checks but swaps nothing in.
 # Restart with: AGENTOS_RESTART="<command>" scripts/redeploy
 # Put the previous build back: AGENTOS_RESTART="<command>" scripts/redeploy --rollback
+# ...and the source with it: scripts/redeploy --rollback --to <sha>
+# AGENTOS_UPDATE_TO=<sha> fast-forwards to that commit instead of the head.
+# "::stage <name>" lines say how far it got, for scripts/update-recover.mjs.
 set -euo pipefail
 cd "$(dirname "$0")/.."
 # shellcheck source=lib/build-swap.sh
@@ -20,10 +23,29 @@ if [ -s "$HOME/.nvm/nvm.sh" ]; then
   nvm use >/dev/null
 fi
 
+# A build next to the live one, plus a staged install, needs room; running
+# out halfway is the one failure that can leave the disk too full to recover.
+check_disk() {
+  local need_gb="${AGENTOS_UPDATE_MIN_FREE_GB:-3}" free_kb
+  [ "$need_gb" = 0 ] && return 0
+  free_kb=$(df -Pk . | awk 'NR==2 {print $4}')
+  if [ -n "$free_kb" ] && [ "$free_kb" -lt $((need_gb * 1024 * 1024)) ]; then
+    echo "Not enough free disk space: $((free_kb / 1024)) MB free, the update needs ${need_gb} GB." >&2
+    exit 1
+  fi
+}
+
 # The pull can replace this script, so what follows runs from a fresh start.
 if [ "${1:-}" != "--rollback" ] && [ "${1:-}" != "--pulled" ]; then
+  check_disk
   echo "::phase pulling"
-  git pull --ff-only
+  if [ -n "${AGENTOS_UPDATE_TO:-}" ]; then
+    git fetch -q origin
+    git merge -q --ff-only "$AGENTOS_UPDATE_TO"
+  else
+    git pull --ff-only
+  fi
+  echo "::stage pulled"
   exec bash "$0" --pulled
 fi
 
@@ -33,6 +55,12 @@ if [ "${1:-}" = "--rollback" ]; then
   rollback_build
   # The build and the dependencies it ran on go back together.
   restore_deps
+  # server.ts and lib/ run from source, so the source goes back too, or the
+  # old build would run under the new server code.
+  if [ "${2:-}" = "--to" ] && [ -n "${3:-}" ]; then
+    git reset -q --keep "$3"
+  fi
+  echo "::stage build_swapped"
 else
   echo "::phase installing"
   use_pnpm
@@ -44,7 +72,7 @@ else
   # and the running server keeps the build and dependencies it has.
   swapped=0
   install_beside && rc=0 || rc=$?
-  [ "$rc" = 0 ] && { swap_deps; swapped=1; }
+  [ "$rc" = 0 ] && { swap_deps; swapped=1; echo "::stage deps_swapped"; }
   [ "$rc" = 0 ] || [ "$rc" = 10 ] || exit 1
   install_pdf_browser
   echo "::phase building"
@@ -59,6 +87,7 @@ else
     exit 0
   fi
   swap_build
+  echo "::stage build_swapped"
 fi
 
 if [ -n "${AGENTOS_RESTART:-}" ]; then

package/scripts/redeploy.test.ts

@@ -1,4 +1,4 @@
-import { spawnSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import {
   chmodSync,
   copyFileSync,
@@ -36,7 +36,11 @@ beforeEach(() => {
     writeFileSync(join(dir, f), "{}");
 });
 
-const redeploy = (restart?: string) => {
+const redeploy = (
+  restart?: string,
+  args: string[] = ["--pulled"],
+  extra: Record<string, string> = {}
+) => {
   const env: NodeJS.ProcessEnv = {
     ...process.env,
     HOME: dir,
@@ -49,8 +53,10 @@ const redeploy = (restart?: string) => {
     PORT: "1",
   };
   delete env.AGENTOS_RESTART;
+  delete env.AGENTOS_UPDATE_TO;
   if (restart) env.AGENTOS_RESTART = restart;
-  return spawnSync("bash", [join(dir, "scripts/redeploy"), "--pulled"], {
+  Object.assign(env, extra);
+  return spawnSync("bash", [join(dir, "scripts/redeploy"), ...args], {
     cwd: dir,
     encoding: "utf8",
     env,
@@ -71,7 +77,92 @@ describe("scripts/redeploy", () => {
   it("with a restart command swaps the build in and restarts", () => {
     const r = redeploy(`touch ${join(dir, "restarted")}`);
     expect(liveBuild()).toBe("new");
+    expect(r.stdout).toContain("::stage build_swapped");
+    // The build it replaced is kept for a rollback, beside the build.
+    expect(readFileSync(join(dir, ".next-prev/BUILD_ID"), "utf8")).toBe("old");
+    expect(existsSync(join(dir, ".deps/prev/BUILD_ID"))).toBe(false);
     expect(existsSync(join(dir, "restarted"))).toBe(true);
     expect(r.stdout).toContain("::phase restarting");
   });
 });
+
+describe("scripts/redeploy with git", () => {
+  const git = (cwd: string, ...args: string[]) =>
+    execFileSync("git", args, { cwd, encoding: "utf8" }).trim();
+  const commit = (cwd: string, msg: string) => {
+    git(
+      cwd,
+      "-c",
+      "user.email=t@t",
+      "-c",
+      "user.name=t",
+      "commit",
+      "-q",
+      "--allow-empty",
+      "-m",
+      msg
+    );
+    return git(cwd, "rev-parse", "HEAD");
+  };
+  // dir becomes a clone at c1 of a remote that has c1..c3.
+  const setup = () => {
+    const remote = join(dir, "remote.git");
+    const src = join(dir, "src");
+    git(dir, "init", "-q", "--bare", remote);
+    git(dir, "init", "-q", src);
+    const shas = ["c1", "c2", "c3"].map((m) => commit(src, m));
+    git(src, "push", "-q", remote, "HEAD:refs/heads/main");
+    git(dir, "init", "-q");
+    git(dir, "remote", "add", "origin", remote);
+    git(dir, "fetch", "-q", "origin");
+    git(dir, "checkout", "-q", "-b", "main", shas[0]);
+    git(dir, "branch", "-q", "--set-upstream-to=origin/main");
+    return shas;
+  };
+
+  it("AGENTOS_UPDATE_TO fast-forwards to that commit, not the head", () => {
+    const [, c2] = setup();
+    const r = redeploy(undefined, [], { AGENTOS_UPDATE_TO: c2 });
+    expect(r.status).toBe(0);
+    expect(git(dir, "rev-parse", "HEAD")).toBe(c2);
+    expect(r.stdout).toContain("::stage pulled");
+    expect(r.stdout).toContain("::stage deps_swapped");
+  });
+
+  it("refuses before pulling when the disk is too full", () => {
+    const [c1] = setup();
+    const r = redeploy("true", [], { AGENTOS_UPDATE_MIN_FREE_GB: "999999" });
+    expect(r.status).toBe(1);
+    expect(r.stderr).toContain("Not enough free disk space");
+    expect(git(dir, "rev-parse", "HEAD")).toBe(c1);
+  });
+
+  it("--rollback --to puts the build, the dependencies and the source back together", () => {
+    const [c1, c2] = setup();
+    git(dir, "merge", "-q", "--ff-only", c2);
+    writeFileSync(join(dir, ".next/BUILD_ID"), "new");
+    mkdirSync(join(dir, ".next-prev"));
+    writeFileSync(join(dir, ".next-prev/BUILD_ID"), "old");
+    mkdirSync(join(dir, "node_modules"));
+    writeFileSync(join(dir, "node_modules/which"), "new");
+    mkdirSync(join(dir, ".deps/prev"), { recursive: true });
+    writeFileSync(join(dir, ".deps/prev/which"), "old");
+    const r = redeploy(undefined, ["--rollback", "--to", c1]);
+    expect(r.status).toBe(0);
+    expect(r.stdout).toContain("::stage build_swapped");
+    expect(liveBuild()).toBe("old");
+    expect(readFileSync(join(dir, "node_modules/which"), "utf8")).toBe("old");
+    expect(git(dir, "rev-parse", "HEAD")).toBe(c1);
+  });
+
+  it("--rollback without --to leaves the source where it is", () => {
+    const [, c2] = setup();
+    git(dir, "merge", "-q", "--ff-only", c2);
+    mkdirSync(join(dir, ".next-prev"));
+    writeFileSync(join(dir, ".next-prev/BUILD_ID"), "older");
+    const r = redeploy(undefined, ["--rollback"]);
+    expect(r.status).toBe(0);
+    expect(liveBuild()).toBe("older");
+    expect(git(dir, "rev-parse", "HEAD")).toBe(c2);
+  });
+});

package/scripts/tips-lint.test.ts

@@ -0,0 +1,77 @@
+import fs from "node:fs";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { lintText } from "@/lib/whats-new/lint";
+import { BUDGET, mediaFiles } from "@/lib/tips/media";
+import { fileSchema } from "@/lib/tips/schema";
+import { headingSlugs } from "./lib/heading-slugs";
+
+const root = path.resolve(__dirname, "..");
+const read = (rel: string) => fs.readFileSync(path.join(root, rel), "utf8");
+const { tips } = fileSchema.parse(JSON.parse(read("content/tips.json")));
+
+describe("content/tips.json", () => {
+  it("has enough tips with unique ids", () => {
+    expect(tips.length).toBeGreaterThanOrEqual(25);
+    const ids = tips.map((t) => t.id);
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  it("points at real guide sections", () => {
+    const problems: string[] = [];
+    for (const t of tips) {
+      if (!t.guide) continue;
+      const file = `docs/guides/${t.guide.file}.md`;
+      if (!fs.existsSync(path.join(root, file))) {
+        problems.push(`${t.id}: no ${file}`);
+        continue;
+      }
+      if (t.guide.anchor && !headingSlugs(read(file)).has(t.guide.anchor))
+        problems.push(`${t.id}: no #${t.guide.anchor} in ${file}`);
+    }
+    expect(problems).toEqual([]);
+  });
+
+  it("reads plainly and is safe for a public repo", () => {
+    const problems: string[] = [];
+    for (const t of tips) {
+      const text = `${t.title} ${t.body}`;
+      const why = lintText(text);
+      if (why) problems.push(`${t.id}: ${why}`);
+      if (/!|did you know/i.test(text)) problems.push(`${t.id}: voice`);
+      if (t.mediaBrief && lintText(t.mediaBrief.shot))
+        problems.push(`${t.id}: brief ${lintText(t.mediaBrief.shot)}`);
+    }
+    expect(problems).toEqual([]);
+  });
+
+  it("has media or a brief, never both, and the files fit the budget", () => {
+    const problems: string[] = [];
+    const used = new Set<string>();
+    let total = 0;
+    for (const t of tips) {
+      if (t.media && t.mediaBrief) problems.push(`${t.id}: media and brief`);
+      if (!t.media) continue;
+      for (const { name, max } of mediaFiles(t.media)) {
+        used.add(name);
+        const file = path.join(root, "public/tips", name);
+        if (!fs.existsSync(file)) {
+          problems.push(`${t.id}: ${name} missing`);
+          continue;
+        }
+        const size = fs.statSync(file).size;
+        total += size;
+        if (size > max) problems.push(`${t.id}: ${name} is ${size} bytes`);
+      }
+      if (
+        t.media.kind === "video" &&
+        t.media.durationMs > BUDGET.clipSeconds * 1000
+      )
+        problems.push(`${t.id}: clip too long`);
+    }
+    for (const f of fs.readdirSync(path.join(root, "public/tips")))
+      if (f !== ".gitkeep" && !used.has(f)) problems.push(`unused ${f}`);
+    expect(total).toBeLessThanOrEqual(BUDGET.total);
+    expect(problems).toEqual([]);
+  });
+});