@virtengine/openfleet 0.25.0

package/publish.mjs

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SCRIPT_DIR = resolve(fileURLToPath(new URL(".", import.meta.url)));
+
+function hasArg(flag) {
+  return process.argv.includes(flag);
+}
+
+function getRegistryUrl() {
+  const raw =
+    process.env.NPM_REGISTRY_URL ||
+    process.env.npm_config_registry ||
+    "https://registry.npmjs.org/";
+  const parsed = new URL(raw);
+  if (!parsed.pathname.endsWith("/")) {
+    parsed.pathname = `${parsed.pathname}/`;
+  }
+  return parsed.toString();
+}
+
+function createEphemeralNpmrc(registryUrl, token) {
+  const folder = mkdtempSync(join(tmpdir(), "openfleet-npmrc-"));
+  const npmrcPath = join(folder, ".npmrc");
+  const parsed = new URL(registryUrl);
+  const authPath = parsed.pathname || "/";
+  const authLine = `//${parsed.host}${authPath}:_authToken=${token}`;
+  const content = [
+    `registry=${registryUrl}`,
+    "always-auth=true",
+    authLine,
+  ].join("\n");
+  writeFileSync(npmrcPath, `${content}\n`, "utf8");
+  return { folder, npmrcPath };
+}
+
+function run(command, args, env) {
+  const result = spawnSync(command, args, {
+    stdio: "inherit",
+    cwd: SCRIPT_DIR,
+    env,
+    shell: true,
+  });
+  if (result.error) {
+    console.error(`[publish] Failed to execute ${command}: ${result.error.message}`);
+    return 1;
+  }
+  return result.status ?? 1;
+}
+
+function runCheck(label, command, args, env) {
+  console.log(`[publish] Running ${label}...`);
+  const status = run(command, args, env);
+  if (status !== 0) {
+    console.error(`[publish] ${label} failed (exit ${status}). Aborting publish.`);
+  }
+  return status;
+}
+
+const NPM_BIN = "npm";
+
+function main() {
+  const dryRun = hasArg("--dry-run");
+  const tag = process.env.NPM_PUBLISH_TAG || "latest";
+  const otp = process.env.NPM_OTP || "";
+  const access = process.env.NPM_PUBLISH_ACCESS || "public";
+  const registry = getRegistryUrl();
+  const token = process.env.NPM_ACCESS_TOKEN || process.env.NODE_AUTH_TOKEN || "";
+
+  if (!dryRun && !token) {
+    console.error(
+      "[publish] Missing token. Set NPM_ACCESS_TOKEN (or NODE_AUTH_TOKEN) in environment. - use a 2FA Permissionless token",
+    );
+    process.exit(1);
+  }
+
+  console.log(
+    `[publish] Running validation gates (${dryRun ? "dry-run" : "publish"})...`,
+  );
+  const prepushStatus = runCheck(
+    "pre-push checks",
+    NPM_BIN,
+    ["run", "prepush:check"],
+    process.env,
+  );
+  if (prepushStatus !== 0) {
+    process.exit(prepushStatus);
+  }
+
+  const prepublishStatus = runCheck(
+    "prepublish checks",
+    NPM_BIN,
+    ["run", "prepublishOnly"],
+    process.env,
+  );
+  if (prepublishStatus !== 0) {
+    process.exit(prepublishStatus);
+  }
+
+  let tempConfig = null;
+  try {
+    const env = { ...process.env };
+    if (!dryRun) {
+      tempConfig = createEphemeralNpmrc(registry, token);
+      env.NPM_CONFIG_USERCONFIG = tempConfig.npmrcPath;
+      env.NODE_AUTH_TOKEN = token;
+    }
+
+    const publishArgs = [
+      "publish",
+      "--registry",
+      registry,
+      "--access",
+      access,
+      "--tag",
+      tag,
+    ];
+
+    if (dryRun) {
+      publishArgs.push("--dry-run");
+    }
+    if (otp) {
+      publishArgs.push("--otp", otp);
+    }
+
+    console.log(
+      `[publish] npm ${publishArgs.join(" ")} (token via env/userconfig, redacted)`,
+    );
+    const status = run(NPM_BIN, publishArgs, env);
+    if (status === 0 && !dryRun) {
+      console.log(
+        "\n[publish] REMINDER: deprecate the legacy npm package to redirect users:\n" +
+        "  npm deprecate codex-monitor@'*' \"Renamed to @virtengine/openfleet. Install: npm install -g @virtengine/openfleet\"\n" +
+        "  # If a scoped legacy package exists:\n" +
+        "  npm deprecate @virtengine/codex-monitor@'*' \"Renamed to @virtengine/openfleet. Install: npm install -g @virtengine/openfleet\"\n",
+      );
+    }
+    process.exit(status);
+  } finally {
+    if (tempConfig?.folder) {
+      rmSync(tempConfig.folder, { recursive: true, force: true });
+    }
+  }
+}
+
+main();

package/repo-root.mjs

@@ -0,0 +1,29 @@
+import { execSync } from "node:child_process";
+import { resolve } from "node:path";
+
+/**
+ * Resolve the repo root for openfleet.
+ *
+ * Priority:
+ *  1. Explicit REPO_ROOT env var.
+ *  2. git rev-parse --show-toplevel (relative to cwd).
+ *  3. process.cwd().
+ */
+export function resolveRepoRoot(options = {}) {
+  const envRoot = process.env.REPO_ROOT;
+  if (envRoot) return resolve(envRoot);
+
+  const cwd = options.cwd || process.cwd();
+  try {
+    const gitRoot = execSync("git rev-parse --show-toplevel", {
+      encoding: "utf8",
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    if (gitRoot) return gitRoot;
+  } catch {
+    // ignore - fall back to cwd
+  }
+
+  return resolve(cwd);
+}

package/restart-controller.mjs

@@ -0,0 +1,100 @@
+const DEFAULT_MUTEX_BACKOFF_STEP_MS = 30_000;
+const DEFAULT_MUTEX_BACKOFF_MAX_MS = 90_000;
+const DEFAULT_MIN_RESTART_INTERVAL_MS = 15_000;
+const DEFAULT_QUICK_EXIT_THRESHOLD_MS = 20_000;
+
+export class RestartController {
+  constructor(options = {}) {
+    this.mutexBackoffStepMs =
+      options.mutexBackoffStepMs ?? DEFAULT_MUTEX_BACKOFF_STEP_MS;
+    this.mutexBackoffMaxMs =
+      options.mutexBackoffMaxMs ?? DEFAULT_MUTEX_BACKOFF_MAX_MS;
+    this.minRestartIntervalMs =
+      options.minRestartIntervalMs ?? DEFAULT_MIN_RESTART_INTERVAL_MS;
+    this.quickExitThresholdMs =
+      options.quickExitThresholdMs ?? DEFAULT_QUICK_EXIT_THRESHOLD_MS;
+
+    this.mutexHeldDetected = false;
+    this.mutexBackoffMs = 0;
+    this.lastProcessStartAt = 0;
+    this.consecutiveQuickExits = 0;
+  }
+
+  noteLogLine(line) {
+    if (!line) return;
+    if (
+      line.includes("Another orchestrator instance is already running") ||
+      line.includes("mutex held")
+    ) {
+      this.mutexHeldDetected = true;
+    }
+  }
+
+  noteProcessStarted(nowMs = Date.now()) {
+    this.mutexHeldDetected = false;
+    this.lastProcessStartAt = nowMs;
+  }
+
+  getMinRestartDelay(nowMs = Date.now()) {
+    if (this.lastProcessStartAt <= 0) return 0;
+    const sinceLast = nowMs - this.lastProcessStartAt;
+    if (sinceLast < this.minRestartIntervalMs) {
+      return this.minRestartIntervalMs - sinceLast;
+    }
+    return 0;
+  }
+
+  shouldSuppressRestart(reason) {
+    return reason === "file-change" && this.mutexBackoffMs > 0;
+  }
+
+  resetBackoff() {
+    this.mutexBackoffMs = 0;
+  }
+
+  getRestartDelay() {
+    return this.mutexBackoffMs;
+  }
+
+  recordExit(runDurationMs, isMutexHeld) {
+    const hadBackoff = this.mutexBackoffMs > 0;
+    const isQuickExit = runDurationMs < this.quickExitThresholdMs;
+
+    if (isQuickExit) {
+      this.consecutiveQuickExits += 1;
+    } else {
+      this.consecutiveQuickExits = 0;
+      if (this.mutexBackoffMs > 0) {
+        this.mutexBackoffMs = 0;
+      }
+    }
+
+    if (isMutexHeld) {
+      this.mutexHeldDetected = false;
+      this.mutexBackoffMs = Math.min(
+        this.mutexBackoffMs + this.mutexBackoffStepMs,
+        this.mutexBackoffMaxMs,
+      );
+      return {
+        isMutexHeld: true,
+        backoffMs: this.mutexBackoffMs,
+        consecutiveQuickExits: this.consecutiveQuickExits,
+        backoffReset: hadBackoff && !isQuickExit,
+      };
+    }
+
+    return {
+      isMutexHeld: false,
+      backoffMs: this.mutexBackoffMs,
+      consecutiveQuickExits: this.consecutiveQuickExits,
+      backoffReset: hadBackoff && !isQuickExit,
+    };
+  }
+}
+
+export const RESTART_DEFAULTS = {
+  mutexBackoffStepMs: DEFAULT_MUTEX_BACKOFF_STEP_MS,
+  mutexBackoffMaxMs: DEFAULT_MUTEX_BACKOFF_MAX_MS,
+  minRestartIntervalMs: DEFAULT_MIN_RESTART_INTERVAL_MS,
+  quickExitThresholdMs: DEFAULT_QUICK_EXIT_THRESHOLD_MS,
+};