@saadnvd1/agent-os 0.3.553 → 0.3.556

package/scripts/update-run.mjs

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+// Runs one update, started detached by the server so it survives the restart.
+// Runs scripts/redeploy, follows its "::phase <name>" lines into the state
+// file the server and the browser read, and writes how it ended.
+//   AGENTOS_UPDATE_STATE  the state file (JSON, written atomically)
+//   AGENTOS_RESTART       the restart command; none means "built, restart it yourself"
+//   AGENTOS_UPDATE_REDEPLOY  the script to run (tests); default scripts/redeploy
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import { fileURLToPath } from "node:url";
+
+const file = process.env.AGENTOS_UPDATE_STATE;
+if (!file) {
+  console.error("AGENTOS_UPDATE_STATE is not set");
+  process.exit(2);
+}
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const script =
+  process.env.AGENTOS_UPDATE_REDEPLOY || path.join(root, "scripts/redeploy");
+const PHASES = new Set(["pulling", "installing", "building", "restarting"]);
+
+function read() {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function write(patch) {
+  const run = { ...(read() ?? {}), ...patch };
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(run));
+  fs.renameSync(tmp, file);
+}
+
+const tail = [];
+const keep = (line) => {
+  tail.push(line);
+  if (tail.length > 30) tail.shift();
+};
+
+const child = spawn("bash", [script], {
+  cwd: root,
+  env: process.env,
+  stdio: ["ignore", "pipe", "pipe"],
+});
+for (const stream of [child.stdout, child.stderr]) {
+  readline.createInterface({ input: stream }).on("line", (line) => {
+    const m = /^::phase (\w+)$/.exec(line);
+    if (m && PHASES.has(m[1])) return write({ phase: m[1] });
+    keep(line);
+    console.log(line);
+  });
+}
+child.on("error", (error) =>
+  write({
+    phase: "failed",
+    finishedAt: Date.now(),
+    error: error.message,
+    log: tail,
+  })
+);
+child.on("close", (code) => {
+  // The server may have marked this done already when it came back up.
+  const phase = read()?.phase;
+  if (code === 0) {
+    write({
+      phase: process.env.AGENTOS_RESTART ? "done" : "built",
+      finishedAt: Date.now(),
+      log: tail,
+    });
+  } else if (phase !== "done") {
+    write({
+      phase: "failed",
+      finishedAt: Date.now(),
+      error: `The update failed (exit ${code}). The running server was not changed unless it says otherwise below.`,
+      log: tail,
+    });
+  }
+});

package/scripts/update-run.test.ts

@@ -0,0 +1,64 @@
+import { execFile } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { promisify } from "util";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+const exec = promisify(execFile);
+const runner = path.join(__dirname, "update-run.mjs");
+
+let dir: string;
+beforeEach(() => {
+  dir = fs.mkdtempSync(path.join(os.tmpdir(), "aos-runner-"));
+  fs.writeFileSync(
+    path.join(dir, "state.json"),
+    JSON.stringify({ id: "r1", phase: "starting", from: "a" })
+  );
+});
+afterEach(() => fs.rmSync(dir, { recursive: true, force: true }));
+
+const go = async (script: string, restart?: string) => {
+  const redeploy = path.join(dir, "redeploy");
+  fs.writeFileSync(redeploy, `#!/usr/bin/env bash\n${script}\n`, {
+    mode: 0o755,
+  });
+  const env: NodeJS.ProcessEnv = {
+    ...process.env,
+    AGENTOS_UPDATE_STATE: path.join(dir, "state.json"),
+    AGENTOS_UPDATE_REDEPLOY: redeploy,
+  };
+  if (restart) env.AGENTOS_RESTART = restart;
+  else delete env.AGENTOS_RESTART;
+  await exec(process.execPath, [runner], { env }).catch(() => {});
+  return JSON.parse(fs.readFileSync(path.join(dir, "state.json"), "utf8"));
+};
+
+describe("scripts/update-run.mjs", () => {
+  it("finishes done after a restart command, keeping the id and the log", async () => {
+    const s = await go(
+      'echo "::phase pulling"\necho hello\necho "::phase restarting"',
+      "x"
+    );
+    expect(s).toMatchObject({ id: "r1", phase: "done", from: "a" });
+    expect(s.log).toEqual(["hello"]);
+    expect(s.finishedAt).toBeTypeOf("number");
+  });
+
+  it("finishes built when there was nothing to restart with", async () => {
+    expect((await go("echo ok")).phase).toBe("built");
+  });
+
+  it("fails with the last lines of output when redeploy fails", async () => {
+    const s = await go("echo boom >&2\nexit 3");
+    expect(s.phase).toBe("failed");
+    expect(s.error).toContain("exit 3");
+    expect(s.log).toContain("boom");
+  });
+
+  it("keeps only the last 30 lines", async () => {
+    const s = await go("for i in $(seq 1 50); do echo line$i; done\nexit 1");
+    expect(s.log).toHaveLength(30);
+    expect(s.log.at(-1)).toBe("line50");
+  });
+});

package/server.ts

@@ -44,6 +44,11 @@ import {
 import { lanEnabled } from "./lib/security/network-settings";
 import { startConnect } from "./lib/connect/serve";
 import { serverPort } from "./lib/connect/config";
+import { startUpdateChecks, updateChecksEnabled } from "./lib/updates/check";
+import {
+  reconcileOnBoot as reconcileUpdateRun,
+  startIdleWatcher,
+} from "./lib/updates/run";
 import { startTailnetHttps } from "./lib/security/tailnet-https";
 import {
   setStatusSource,
@@ -413,6 +418,17 @@ app.prepare().then(async () => {
   if (process.env.AGENTOS_ORCHESTRATOR !== "off") startOrchestratorWatcher();
   // Schedules tick here, once a minute, and nowhere else.
   if (schedulesEnabled(process.env)) startScheduler(realDeps);
+  // Looking for a newer version, and running an update only when one is
+  // asked for (the banner, Settings > Updates).
+  try {
+    reconcileUpdateRun();
+  } catch (error) {
+    console.error("Reconciling the update run failed:", error);
+  }
+  if (updateChecksEnabled()) {
+    startUpdateChecks();
+    startIdleWatcher();
+  }
   startSettling();
   // Sessions that sat in Done for 30 days are archived.
   startAutoArchive();