@saadnvd1/agent-os 0.3.605 → 0.3.608

package/scripts/autodeploy

@@ -4,6 +4,11 @@
 # background. Chat turns live in workers and outlive the restart; reviews
 # and task setups don't, so the restart waits up to 10 minutes for them.
 #   sm add agentos-autodeploy "scripts/autodeploy" --cron "* * * * *"
+# Restarts are spaced AGENTOS_MIN_GAP seconds apart (10 minutes; 0 turns it
+# off): a head that lands inside the gap waits and is deployed, whatever it
+# has become by then, when the gap ends. A commit message with [deploy-now]
+# (in any commit the deploy would take) skips the gap. Each hold logs one line:
+#   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.
 set -euo pipefail
@@ -44,6 +49,28 @@ if [ "$head" != "$deployed" ] && [ "$settle" -gt 0 ] &&
   exit 0
 fi
 
+# Restarts kill simulator starts and reviews in flight, so they are spaced
+# apart. The head isn't recorded as deployed while it waits, so it (or a
+# newer one) goes out as soon as the gap is over; nothing is dropped.
+gap="${AGENTOS_MIN_GAP:-600}"
+if [ "$head" != "$deployed" ] && [ "$gap" -gt 0 ]; then
+  last=$(cat "$state/restarted" 2>/dev/null || echo 0)
+  left=$(( last + gap - $(date +%s) ))
+  if [ "$left" -gt 0 ]; then
+    msgs=$(git log --format=%B "${deployed:+$deployed..}$head" 2>/dev/null || git log -1 --format=%B "$head")
+    if printf '%s' "$msgs" | grep -qF '[deploy-now]'; then
+      log "Restart gap skipped for ${head:0:7}: [deploy-now]"
+    else
+      # Once per head, not once per minute, so the log counts holds.
+      if [ "$(cat "$state/held" 2>/dev/null)" != "$head" ]; then
+        echo "$head" > "$state/held"
+        log "HELD ${head:0:7} ${left}s left in the ${gap}s restart gap"
+      fi
+      exit 0
+    fi
+  fi
+fi
+
 # A deploy that can't land says so once per commit, rather than retrying
 # quietly every minute (uncommitted edits in this checkout block the pull).
 alert() {
@@ -70,6 +97,7 @@ if [ "$head" != "$deployed" ]; then
   fi
   # The pull takes what landed while it waited, too.
   git rev-parse HEAD > "$state/deployed"
+  date +%s > "$state/restarted"
 fi
 
 # Publishing waits minutes for npm to serve a version, so it runs on its own

package/scripts/autodeploy.test.ts

@@ -0,0 +1,106 @@
+import { execFileSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { describe, expect, it } from "vitest";
+
+// Runs the real scripts/autodeploy in a scratch clone with a stub redeploy
+// (a pull) and wait-quiet, against a scratch origin and HOME.
+const script = path.resolve(__dirname, "autodeploy");
+const sh = (cwd: string, ...args: string[]) =>
+  execFileSync("git", args, { cwd, encoding: "utf-8" }).trim();
+
+function setup() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "aos-autodeploy-"));
+  const origin = path.join(root, "origin.git");
+  const work = path.join(root, "work");
+  const clone = path.join(root, "live");
+  const home = path.join(root, "home");
+  fs.mkdirSync(home);
+  sh(root, "init", "-q", "--bare", "-b", "main", origin);
+  sh(root, "clone", "-q", origin, work);
+  fs.mkdirSync(path.join(work, "scripts"));
+  fs.copyFileSync(script, path.join(work, "scripts/autodeploy"));
+  fs.writeFileSync(path.join(work, "scripts/wait-quiet"), "#!/bin/sh\n");
+  fs.writeFileSync(
+    path.join(work, "scripts/redeploy"),
+    "#!/bin/sh\ngit pull -q origin main && echo x >> ../restarts\n"
+  );
+  fs.chmodSync(path.join(work, "scripts/autodeploy"), 0o755);
+  fs.chmodSync(path.join(work, "scripts/wait-quiet"), 0o755);
+  fs.chmodSync(path.join(work, "scripts/redeploy"), 0o755);
+  const commit = (msg: string) => {
+    fs.appendFileSync(path.join(work, "f"), msg + "\n");
+    sh(work, "add", "-A");
+    sh(work, "-c", "user.name=t", "-c", "user.email=t@t", "commit", "-qm", msg);
+    sh(work, "push", "-q", "origin", "main");
+    return sh(work, "rev-parse", "HEAD");
+  };
+  commit("first");
+  sh(root, "clone", "-q", origin, clone);
+  const state = path.join(home, ".agent-os/autodeploy");
+  const run = () =>
+    execFileSync(path.join(clone, "scripts/autodeploy"), [], {
+      cwd: clone,
+      encoding: "utf-8",
+      env: {
+        ...process.env,
+        HOME: home,
+        AGENTOS_PUBLISH: "0",
+        AGENTOS_SETTLE: "0",
+        AGENTOS_RESTART: "true",
+      },
+    });
+  const restarts = () => {
+    try {
+      return (
+        fs.readFileSync(path.join(root, "restarts"), "utf-8").split("\n")
+          .length - 1
+      );
+    } catch {
+      return 0;
+    }
+  };
+  const deployed = () =>
+    fs.readFileSync(path.join(state, "deployed"), "utf-8").trim();
+  return { commit, run, restarts, deployed, state };
+}
+
+describe("autodeploy restart gap", () => {
+  it("holds a second deploy inside the gap, then deploys the newest head once it ends", () => {
+    const t = setup();
+    const a = t.commit("a");
+    expect(t.run()).toContain("Deploying");
+    expect(t.deployed()).toBe(a);
+    expect(t.restarts()).toBe(1);
+
+    t.commit("b");
+    const c = t.commit("c");
+    const held = t.run();
+    expect(held).toMatch(/HELD [0-9a-f]{7} \d+s left in the 600s restart gap/);
+    expect(t.deployed()).toBe(a);
+    expect(t.restarts()).toBe(1);
+    // Still waiting a minute later: no second log line for the same head.
+    expect(t.run()).toBe("");
+
+    // The gap ends: the head that was waiting goes out, once.
+    fs.writeFileSync(
+      path.join(t.state, "restarted"),
+      `${Math.floor(Date.now() / 1000) - 601}\n`
+    );
+    expect(t.run()).toContain("Deploying");
+    expect(t.deployed()).toBe(c);
+    expect(t.restarts()).toBe(2);
+    expect(t.run()).toBe("");
+  });
+
+  it("skips the gap for a [deploy-now] commit", () => {
+    const t = setup();
+    t.commit("a");
+    t.run();
+    const urgent = t.commit("fix: login loop [deploy-now]");
+    expect(t.run()).toContain("[deploy-now]");
+    expect(t.deployed()).toBe(urgent);
+    expect(t.restarts()).toBe(2);
+  });
+});

package/scripts/bench/worktree-setup.ts

@@ -0,0 +1,101 @@
+/**
+ * Times a new worktree's setup and its first typecheck, test and build, and
+ * the disk it takes, against a checkout. Run it with the seeding on, then
+ * with AGENTOS_NO_BUILD_CACHES=1 (and, to see an install on Linux, --install).
+ *
+ *   npx tsx scripts/bench/worktree-setup.ts <checkout> [--test <file>]
+ *     [--build] [--install] [--cwd <subdir>] [--drop <seeded path>]
+ *
+ * It makes a throwaway git worktree of the checkout's HEAD in the temp
+ * directory and removes it at the end; it touches nothing else.
+ */
+
+import { execFileSync, spawnSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { setupWorktree } from "../../lib/env-setup";
+
+const args = process.argv.slice(2);
+const flag = (name: string) => args.includes(name);
+const value = (name: string) => args[args.indexOf(name) + 1];
+const source = path.resolve(args[0]);
+const sub = flag("--cwd") ? value("--cwd") : ".";
+
+const freeKb = (dir: string) =>
+  Number(
+    execFileSync("df", ["-Pk", dir], { encoding: "utf-8" })
+      .trim()
+      .split("\n")[1]
+      .split(/\s+/)[3]
+  );
+
+function timed(command: string, cwd: string) {
+  const start = Date.now();
+  const run = spawnSync(command, { cwd, shell: true, stdio: "ignore" });
+  return { seconds: (Date.now() - start) / 1000, ok: run.status === 0 };
+}
+
+async function main() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "aos-bench-"));
+  const worktree = path.join(root, "wt");
+  execFileSync("git", ["worktree", "add", "-q", "--detach", worktree, "HEAD"], {
+    cwd: source,
+  });
+  const out: Record<string, unknown> = {
+    source: path.basename(source),
+    platform: process.platform,
+    seeding: process.env.AGENTOS_NO_BUILD_CACHES ? "off" : "on",
+  };
+  try {
+    const before = freeKb(root);
+    const start = Date.now();
+    let steps: string[] = [];
+    if (flag("--install")) {
+      const r = timed("npm ci --include=dev", worktree);
+      steps = [`npm ci ok=${r.ok}`];
+    } else {
+      const result = await setupWorktree({
+        worktreePath: worktree,
+        sourcePath: source,
+      });
+      steps = result.steps.map(
+        (s) => `${s.name}: ${s.success ? "ok" : "failed"}`
+      );
+    }
+    out.setupSeconds = (Date.now() - start) / 1000;
+    out.setupSteps = steps;
+    out.diskMbAfterSetup = Math.round((before - freeKb(root)) / 1024);
+    // Take a seeded cache back out to measure without it.
+    if (flag("--drop"))
+      fs.rmSync(path.join(worktree, value("--drop")), {
+        recursive: true,
+        force: true,
+      });
+    const dir = path.join(worktree, sub);
+    const pkg = path.join(dir, "package.json");
+    const typecheck = fs.existsSync(pkg)
+      ? JSON.parse(fs.readFileSync(pkg, "utf-8")).scripts?.typecheck
+      : undefined;
+    if (typecheck) out.typecheck = timed("npm run typecheck", dir);
+    else if (fs.existsSync(path.join(dir, "tsconfig.json")))
+      out.typecheck = timed("npx tsc --noEmit", dir);
+    if (flag("--test"))
+      out.test = timed(`npx vitest run ${value("--test")}`, dir);
+    if (flag("--build")) {
+      out.build = timed("npx next build", dir);
+      out.diskMbAfterBuild = Math.round((before - freeKb(root)) / 1024);
+    }
+  } finally {
+    execFileSync("git", ["worktree", "remove", "--force", worktree], {
+      cwd: source,
+    });
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+  console.log(JSON.stringify(out));
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/scripts/wait-quiet

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # Waits until the AgentOS server on $PORT has nothing in flight that a
-# restart would cut off (reviews, task setups: GET /api/busy), for at most
+# restart would cut off (reviews, task setups, simulator starts: GET /api/busy), for at most
 # AGENTOS_QUIET_WAIT seconds; then returns, so a deploy always lands. A
 # server that doesn't answer (down, or a build without /api/busy) is quiet.
 set -uo pipefail