@saadnvd1/agent-os 0.3.606 → 0.3.609

package/lib/tasks/move.ts

@@ -13,7 +13,7 @@ import { db, type Session } from "../db";
 import { getProject } from "../projects";
 import { endTmuxSession } from "../tmux/end";
 import { launchClaude } from "../agents/launch";
-import { buildTaskBrief } from "./brief";
+import { buildTaskBrief, declaredTest } from "./brief";
 import { git as runGit } from "../git-exec";
 import { getTaskSession, isoUTC } from "./session";
 import { projectRef } from "./project-ref";
@@ -308,6 +308,7 @@ async function relaunch(session: Session, note?: string): Promise<void> {
       ? buildTaskBrief({
           branch: session.branch_name,
           baseBranch: session.base_branch ?? "main",
+          test: declaredTest(session.working_directory),
         })
       : undefined,
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.606",
+  "version": "0.3.609",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

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/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