@awak-app/simy-cli 0.1.3 → 0.1.5

package/src/auto-update.js

@@ -0,0 +1,631 @@
+import { execFile, spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { EventEmitter } from "node:events";
+import {
+  mkdir,
+  open,
+  readFile,
+  realpath,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export const CLI_PACKAGE_NAME = "@awak-app/simy-cli";
+export const AUTO_UPDATE_CHECK_INTERVAL_MS = 60 * 60 * 1_000;
+const AUTO_UPDATE_INITIAL_DELAY_MS = 15_000;
+const AUTO_UPDATE_IDLE_RETRY_MS = 30_000;
+const UPDATE_LOCK_STALE_MS = 30 * 60 * 1_000;
+const RESTART_HANDOFF_TIMEOUT_MS = 30_000;
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const NON_IDLE_STATES = new Set([
+  "queued",
+  "risk_classifying",
+  "chartering",
+  "dispatching",
+  "coding",
+  "collecting_evidence",
+  "auditing",
+  "independent_auditing",
+  "checking_pr",
+  "re_instructing",
+  "waiting_human",
+  "blocked",
+]);
+const NON_IDLE_CONTROL_STATES = new Set([
+  "queued",
+  "running",
+  "paused",
+  "waiting_human",
+  "stopping",
+]);
+
+export class CliAutoUpdater extends EventEmitter {
+  #snapshot;
+  #options;
+  #registry = null;
+  #restartDaemon = null;
+  #checkTimer = null;
+  #initialTimer = null;
+  #idleTimer = null;
+  #checking = null;
+  #applying = null;
+  #stopped = false;
+  #registryListener = null;
+  #activeWork = 0;
+
+  constructor(options) {
+    super();
+    this.#options = options;
+    this.#snapshot = {
+      state: options.disabled ? "disabled" : "idle",
+      current_version: options.currentVersion,
+      target_version: null,
+      install_mode: options.installMode,
+      automatic: Boolean(
+        !options.disabled &&
+          options.daemon &&
+          options.installMode === "global_npm" &&
+          options.requestedPort === 0
+      ),
+      checked_at: null,
+      message: options.disabled
+        ? "Automatic update checks are disabled."
+        : "SIMY will check for CLI updates in the background.",
+      action: null,
+      error: null,
+    };
+  }
+
+  snapshot() {
+    return structuredClone(this.#snapshot);
+  }
+
+  acceptsNewWork() {
+    return !["updating", "restarting"].includes(this.#snapshot.state);
+  }
+
+  beginWork() {
+    if (!this.acceptsNewWork()) return null;
+    this.#activeWork += 1;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.#activeWork = Math.max(0, this.#activeWork - 1);
+      if (this.#activeWork === 0 && this.#snapshot.state === "waiting_for_idle") {
+        void this.maybeApply();
+      }
+    };
+  }
+
+  start({ registry, restartDaemon } = {}) {
+    if (this.#snapshot.state === "disabled" || this.#checkTimer || this.#stopped) return this;
+    this.#registry = registry;
+    this.#restartDaemon = restartDaemon;
+    this.#registryListener = () => {
+      if (this.#snapshot.state === "waiting_for_idle") void this.maybeApply();
+    };
+    this.#registry?.on("change", this.#registryListener);
+    this.#initialTimer = setTimeout(() => void this.checkNow(), this.#options.initialDelayMs);
+    this.#initialTimer.unref?.();
+    this.#checkTimer = setInterval(() => void this.checkNow(), this.#options.checkIntervalMs);
+    this.#checkTimer.unref?.();
+    return this;
+  }
+
+  stop() {
+    this.#stopped = true;
+    if (this.#initialTimer) clearTimeout(this.#initialTimer);
+    if (this.#checkTimer) clearInterval(this.#checkTimer);
+    if (this.#idleTimer) clearInterval(this.#idleTimer);
+    if (this.#registryListener) this.#registry?.off("change", this.#registryListener);
+    this.#initialTimer = null;
+    this.#checkTimer = null;
+    this.#idleTimer = null;
+  }
+
+  async checkNow() {
+    if (this.#stopped || this.#snapshot.state === "disabled") return this.snapshot();
+    if (this.#checking) return this.#checking;
+    if (["updating", "restarting"].includes(this.#snapshot.state)) return this.snapshot();
+
+    this.#checking = this.#performCheck().finally(() => {
+      this.#checking = null;
+    });
+    return this.#checking;
+  }
+
+  async #performCheck() {
+    this.#setState("checking", {
+      message: "Checking for a newer SIMY CLI version...",
+      error: null,
+    });
+    try {
+      const release = await this.#options.checkLatestVersion();
+      const targetVersion = String(release?.version || "").trim();
+      if (!parseStableVersion(targetVersion)) {
+        throw new Error("The npm registry returned an invalid stable CLI version.");
+      }
+      const checkedAt = new Date(this.#options.now()).toISOString();
+      if (compareStableVersions(targetVersion, this.#options.currentVersion) <= 0) {
+        this.#clearIdleTimer();
+        this.#setState("up_to_date", {
+          target_version: null,
+          checked_at: checkedAt,
+          message: `SIMY CLI ${this.#options.currentVersion} is up to date.`,
+          action: null,
+          error: null,
+        });
+        return this.snapshot();
+      }
+
+      const automatic = this.#snapshot.automatic && isPatchUpgrade(
+        this.#options.currentVersion,
+        targetVersion,
+      );
+      const action = updateAction(targetVersion);
+      if (!automatic) {
+        this.#clearIdleTimer();
+        this.#setState("update_available", {
+          target_version: targetVersion,
+          checked_at: checkedAt,
+          message: manualUpdateMessage({
+            currentVersion: this.#options.currentVersion,
+            targetVersion,
+            installMode: this.#options.installMode,
+            daemon: this.#options.daemon,
+            requestedPort: this.#options.requestedPort,
+          }),
+          action,
+          error: null,
+        });
+        this.#announce();
+        return this.snapshot();
+      }
+
+      this.#setState("waiting_for_idle", {
+        target_version: targetVersion,
+        checked_at: checkedAt,
+        message: `SIMY CLI ${targetVersion} is ready and will install when no task is active.`,
+        action,
+        error: null,
+      });
+      this.#startIdleTimer();
+      this.#announce();
+      return this.maybeApply();
+    } catch (error) {
+      this.#clearIdleTimer();
+      this.#setState("check_failed", {
+        checked_at: new Date(this.#options.now()).toISOString(),
+        message: "SIMY could not check for updates. It will try again later.",
+        error: errorMessage(error),
+      });
+      this.#announce();
+      return this.snapshot();
+    }
+  }
+
+  async maybeApply() {
+    if (this.#stopped || this.#snapshot.state !== "waiting_for_idle") {
+      return this.snapshot();
+    }
+    if (this.#applying) return this.#applying;
+    if (!this.#isIdle()) return this.snapshot();
+
+    this.#applying = this.#performUpdate().finally(() => {
+      this.#applying = null;
+    });
+    return this.#applying;
+  }
+
+  async #performUpdate() {
+    const targetVersion = this.#snapshot.target_version;
+    this.#setState("updating", {
+      message: `Updating SIMY CLI ${this.#options.currentVersion} to ${targetVersion}...`,
+      error: null,
+    });
+    this.#announce();
+
+    if (!this.#isIdle()) {
+      this.#setState("waiting_for_idle", {
+        message: `SIMY CLI ${targetVersion} is ready and will install when no task is active.`,
+      });
+      return this.snapshot();
+    }
+
+    let releaseLock = null;
+    try {
+      releaseLock = await this.#options.acquireUpdateLock();
+      if (!releaseLock) {
+        this.#setState("waiting_for_idle", {
+          message: "Another SIMY process is updating the CLI. This process will check again shortly.",
+        });
+        return this.snapshot();
+      }
+      if (!this.#isIdle()) {
+        this.#setState("waiting_for_idle", {
+          message: `SIMY CLI ${targetVersion} is ready and will install when no task is active.`,
+        });
+        return this.snapshot();
+      }
+
+      await this.#options.installVersion(targetVersion);
+      if (typeof this.#restartDaemon !== "function") {
+        throw new Error("The daemon restart handoff is unavailable.");
+      }
+      this.#setState("restarting", {
+        message: `SIMY CLI ${targetVersion} is installed. Verifying the restarted daemon...`,
+      });
+      this.#announce();
+      await this.#restartDaemon?.(targetVersion);
+      this.#clearIdleTimer();
+      this.#setState("updated", {
+        message: `SIMY CLI ${targetVersion} is running.`,
+        action: null,
+        error: null,
+      });
+      return this.snapshot();
+    } catch (error) {
+      this.#clearIdleTimer();
+      this.#setState("failed", {
+        message: `Automatic update failed. SIMY ${this.#options.currentVersion} is still running.`,
+        action: updateAction(targetVersion),
+        error: errorMessage(error),
+      });
+      this.#announce();
+      return this.snapshot();
+    } finally {
+      await releaseLock?.();
+    }
+  }
+
+  #startIdleTimer() {
+    if (this.#idleTimer) return;
+    this.#idleTimer = setInterval(() => void this.maybeApply(), this.#options.idleRetryMs);
+    this.#idleTimer.unref?.();
+  }
+
+  #isIdle() {
+    return this.#activeWork === 0 && isRegistryIdle(this.#registry);
+  }
+
+  #clearIdleTimer() {
+    if (this.#idleTimer) clearInterval(this.#idleTimer);
+    this.#idleTimer = null;
+  }
+
+  #setState(state, values = {}) {
+    this.#snapshot = { ...this.#snapshot, ...values, state };
+    this.emit("change", this.snapshot());
+  }
+
+  #announce() {
+    if (this.#options.quiet) return;
+    const suffix =
+      ["update_available", "failed"].includes(this.#snapshot.state) &&
+      this.#snapshot.action?.command
+      ? ` Run manually: ${this.#snapshot.action.command}`
+      : "";
+    const detail = this.#snapshot.error ? ` (${this.#snapshot.error})` : "";
+    this.#options.logger(`${this.#snapshot.message}${suffix}${detail}`);
+  }
+}
+
+export async function createCliAutoUpdater({
+  daemon,
+  interactive,
+  requestedPort = 0,
+  disabled = false,
+  packageRoot = PACKAGE_ROOT,
+  dependencies = {},
+} = {}) {
+  const packageInfo = dependencies.packageInfo || (await readCliPackageInfo(packageRoot));
+  const installMode = dependencies.installMode || (await detectInstallMode({
+    packageRoot,
+    execFileCommand: dependencies.execFileCommand,
+  }));
+  const stateRoot = dependencies.stateRoot || defaultStateRoot();
+  return new CliAutoUpdater({
+    daemon: Boolean(daemon),
+    interactive: Boolean(interactive),
+    requestedPort,
+    disabled,
+    currentVersion: packageInfo.version,
+    installMode,
+    checkLatestVersion: dependencies.checkLatestVersion || checkLatestVersion,
+    installVersion:
+      dependencies.installVersion ||
+      ((version) => installGlobalNpmVersion(version, { execFileCommand: dependencies.execFileCommand })),
+    acquireUpdateLock:
+      dependencies.acquireUpdateLock || (() => acquireUpdateLock(stateRoot, dependencies)),
+    logger: dependencies.logger || console.log,
+    quiet: Boolean(interactive),
+    now: dependencies.now || Date.now,
+    initialDelayMs: dependencies.initialDelayMs ?? AUTO_UPDATE_INITIAL_DELAY_MS,
+    checkIntervalMs: dependencies.checkIntervalMs ?? AUTO_UPDATE_CHECK_INTERVAL_MS,
+    idleRetryMs: dependencies.idleRetryMs ?? AUTO_UPDATE_IDLE_RETRY_MS,
+  });
+}
+
+export async function readCliPackageInfo(packageRoot = PACKAGE_ROOT) {
+  const payload = JSON.parse(await readFile(path.join(packageRoot, "package.json"), "utf8"));
+  const version = String(payload.version || "").trim();
+  if (!parseStableVersion(version)) throw new Error("SIMY CLI package.json has an invalid version.");
+  return { name: String(payload.name || ""), version };
+}
+
+export async function detectInstallMode({
+  packageRoot = PACKAGE_ROOT,
+  execFileCommand = execFileAsync,
+} = {}) {
+  const resolvedRoot = await realpathOrResolve(packageRoot);
+  if (resolvedRoot.split(path.sep).includes("_npx")) return "npx";
+
+  try {
+    const { stdout } = await execFileCommand("npm", ["root", "--global"], {
+      timeout: 10_000,
+      encoding: "utf8",
+    });
+    const globalRoot = await realpathOrResolve(String(stdout || "").trim());
+    if (isPathInside(globalRoot, resolvedRoot)) return "global_npm";
+  } catch {
+    // The actionable fallback is the same for source checkouts and unknown package managers.
+  }
+
+  return resolvedRoot.split(path.sep).includes("node_modules") ? "package" : "source";
+}
+
+export async function checkLatestVersion({ fetchImpl = fetch } = {}) {
+  const response = await fetchImpl(
+    "https://registry.npmjs.org/@awak-app%2fsimy-cli/latest",
+    {
+      headers: { Accept: "application/vnd.npm.install-v1+json" },
+      signal: AbortSignal.timeout(10_000),
+    },
+  );
+  if (!response.ok) throw new Error(`npm registry returned HTTP ${response.status}`);
+  const payload = await response.json();
+  return {
+    version: payload?.version,
+    integrity: payload?.dist?.integrity || null,
+  };
+}
+
+export async function installGlobalNpmVersion(
+  version,
+  { execFileCommand = execFileAsync } = {},
+) {
+  if (!parseStableVersion(version)) throw new Error("Refusing to install an invalid CLI version.");
+  await execFileCommand(
+    "npm",
+    [
+      "install",
+      "--global",
+      `${CLI_PACKAGE_NAME}@${version}`,
+      "--no-audit",
+      "--no-fund",
+    ],
+    { timeout: 10 * 60_000, encoding: "utf8" },
+  );
+}
+
+export function isRegistryIdle(registry) {
+  const runs = registry?.list?.() || [];
+  return runs.every((run) => {
+    if (run?.operation || run?.child || run?.pendingLedgerUpdate || run?.ledgerUpdateRunning) {
+      return false;
+    }
+    if (NON_IDLE_STATES.has(run?.status)) return false;
+    if (NON_IDLE_CONTROL_STATES.has(run?.controlState)) return false;
+    return true;
+  });
+}
+
+export function compareStableVersions(left, right) {
+  const leftParts = parseStableVersion(left);
+  const rightParts = parseStableVersion(right);
+  if (!leftParts || !rightParts) throw new Error("A stable semantic version is required.");
+  for (let index = 0; index < 3; index += 1) {
+    if (leftParts[index] !== rightParts[index]) return leftParts[index] - rightParts[index];
+  }
+  return 0;
+}
+
+export function isPatchUpgrade(currentVersion, targetVersion) {
+  const current = parseStableVersion(currentVersion);
+  const target = parseStableVersion(targetVersion);
+  return Boolean(
+    current &&
+      target &&
+      current[0] === target[0] &&
+      current[1] === target[1] &&
+      target[2] > current[2]
+  );
+}
+
+export async function restartDaemonProcess({
+  entryPath,
+  argv,
+  targetVersion,
+  stateRoot = defaultStateRoot(),
+  spawnProcess = spawn,
+  timeoutMs = RESTART_HANDOFF_TIMEOUT_MS,
+  env = process.env,
+} = {}) {
+  const handoffDirectory = path.join(stateRoot, "updates", "handoff");
+  await mkdir(handoffDirectory, { recursive: true, mode: 0o700 });
+  const nonce = randomBytes(24).toString("hex");
+  const handoffPath = path.join(handoffDirectory, `${process.pid}-${nonce}.json`);
+  const child = spawnProcess(process.execPath, [entryPath, ...argv], {
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...env,
+      SIMY_DAEMON_CHILD: "1",
+      SIMY_UPDATE_HANDOFF_FILE: handoffPath,
+      SIMY_UPDATE_HANDOFF_NONCE: nonce,
+    },
+  });
+  child.unref?.();
+  const spawnFailure = new Promise((_, reject) => {
+    child.once?.("error", reject);
+  });
+
+  try {
+    const handoff = await Promise.race([
+      waitForHandoff(handoffPath, nonce, timeoutMs),
+      spawnFailure,
+    ]);
+    if (handoff.version !== targetVersion) {
+      throw new Error(
+        `Restarted SIMY reported version ${handoff.version || "unknown"}, expected ${targetVersion}.`,
+      );
+    }
+    return handoff;
+  } finally {
+    await rm(handoffPath, { force: true });
+  }
+}
+
+export async function writeUpdateHandoffFromEnvironment({
+  version,
+  port,
+  env = process.env,
+  stateRoot = defaultStateRoot(),
+} = {}) {
+  const handoffPath = String(env.SIMY_UPDATE_HANDOFF_FILE || "").trim();
+  const nonce = String(env.SIMY_UPDATE_HANDOFF_NONCE || "").trim();
+  if (!handoffPath || !nonce) return false;
+  const handoffDirectory = path.resolve(stateRoot, "updates", "handoff");
+  if (!isPathInside(handoffDirectory, path.resolve(handoffPath))) {
+    throw new Error("Refusing to write an update handoff outside the SIMY state directory.");
+  }
+  await mkdir(handoffDirectory, { recursive: true, mode: 0o700 });
+  await writeFile(
+    handoffPath,
+    `${JSON.stringify({ nonce, version, port, pid: process.pid, ready_at: new Date().toISOString() })}\n`,
+    { encoding: "utf8", mode: 0o600 },
+  );
+  return true;
+}
+
+export function autoUpdateHelpText() {
+  return [
+    "Recommended installation (enables daemon auto-update):",
+    `  npm install -g ${CLI_PACKAGE_NAME}`,
+    "  simy --daemon",
+  ].join("\n");
+}
+
+function manualUpdateMessage({
+  currentVersion,
+  targetVersion,
+  installMode,
+  daemon,
+  requestedPort,
+}) {
+  if (installMode !== "global_npm") {
+    return `SIMY CLI ${targetVersion} is available. Install the global version to enable automatic updates.`;
+  }
+  if (!daemon) {
+    return `SIMY CLI ${targetVersion} is available. Update it after leaving this foreground session.`;
+  }
+  if (requestedPort !== 0) {
+    return `SIMY CLI ${targetVersion} is available. A daemon using a fixed port requires a manual restart.`;
+  }
+  return `SIMY CLI ${targetVersion} is available. This version change requires manual confirmation.`;
+}
+
+function updateAction(version) {
+  return {
+    id: "install_global_cli",
+    label: "Install and restart SIMY",
+    command: `npm install -g ${CLI_PACKAGE_NAME}@${version} && simy --daemon`,
+  };
+}
+
+function parseStableVersion(value) {
+  const match = String(value || "").match(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/);
+  return match ? match.slice(1).map(Number) : null;
+}
+
+async function acquireUpdateLock(stateRoot, dependencies = {}) {
+  const now = dependencies.now || Date.now;
+  const lockDirectory = path.join(stateRoot, "updates");
+  const lockPath = path.join(lockDirectory, "global-npm-update.lock");
+  await mkdir(lockDirectory, { recursive: true, mode: 0o700 });
+
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      const handle = await open(lockPath, "wx", 0o600);
+      const token = randomBytes(16).toString("hex");
+      await handle.writeFile(`${JSON.stringify({ token, pid: process.pid, created_at: now() })}\n`);
+      await handle.close();
+      return async () => {
+        try {
+          const payload = JSON.parse(await readFile(lockPath, "utf8"));
+          if (payload.token === token) await rm(lockPath, { force: true });
+        } catch (error) {
+          if (error?.code !== "ENOENT") throw error;
+        }
+      };
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+      if (!(await isStaleLock(lockPath, now))) return null;
+      await rm(lockPath, { force: true });
+    }
+  }
+  return null;
+}
+
+async function isStaleLock(lockPath, now) {
+  try {
+    const details = await stat(lockPath);
+    return now() - details.mtimeMs > UPDATE_LOCK_STALE_MS;
+  } catch (error) {
+    if (error?.code === "ENOENT") return true;
+    throw error;
+  }
+}
+
+async function waitForHandoff(handoffPath, nonce, timeoutMs) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    try {
+      const payload = JSON.parse(await readFile(handoffPath, "utf8"));
+      if (payload.nonce === nonce) return payload;
+    } catch (error) {
+      if (error?.code !== "ENOENT" && !(error instanceof SyntaxError)) throw error;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error("The updated SIMY daemon did not become healthy in time.");
+}
+
+async function realpathOrResolve(value) {
+  try {
+    return await realpath(value);
+  } catch {
+    return path.resolve(value);
+  }
+}
+
+function isPathInside(parent, child) {
+  const relative = path.relative(parent, child);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function defaultStateRoot() {
+  return process.env.SIMY_HOME?.trim() || path.join(homedir(), ".simy");
+}
+
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}