@virtengine/openfleet 0.25.0 → 0.26.1

package/.env.example

@@ -735,11 +735,15 @@ COMPLEXITY_ROUTING_ENABLED=true
 # COMPLEXITY_ROUTING_CODEX_LOW_REASONING=low
 # COMPLEXITY_ROUTING_CODEX_MEDIUM_MODEL=gpt-5.2-codex
 # COMPLEXITY_ROUTING_CODEX_MEDIUM_VARIANT=DEFAULT
+# COMPLEXITY_ROUTING_CODEX_MEDIUM_REASONING=medium
 # COMPLEXITY_ROUTING_CODEX_HIGH_MODEL=gpt-5.1-codex-max
 # COMPLEXITY_ROUTING_CODEX_HIGH_VARIANT=GPT51_CODEX_MAX
-# COMPLEXITY_ROUTING_COPILOT_LOW_MODEL=haiku-4.5
-# COMPLEXITY_ROUTING_COPILOT_MEDIUM_MODEL=sonnet-4.5
-# COMPLEXITY_ROUTING_COPILOT_HIGH_MODEL=opus-4.6
+# COMPLEXITY_ROUTING_CODEX_HIGH_REASONING=high
+# COMPLEXITY_ROUTING_COPILOT_LOW_MODEL=claude-haiku-4.5
+# COMPLEXITY_ROUTING_COPILOT_MEDIUM_MODEL=claude-sonnet-4.5
+# COMPLEXITY_ROUTING_COPILOT_MEDIUM_REASONING=medium
+# COMPLEXITY_ROUTING_COPILOT_HIGH_MODEL=claude-opus-4.6
+# COMPLEXITY_ROUTING_COPILOT_HIGH_REASONING=high
 
 # ─── Shared Cloud Workspaces ────────────────────────────────────────────────
 # Registry file for shared workspace leasing (default: .cache/openfleet/shared-workspaces.json)

package/cli.mjs

@@ -689,6 +689,68 @@ async function main() {
     console.log("\n  Setup complete! Starting openfleet...\n");
   }
 
+  // ── Handle --echo-logs: tail the active monitor's log instead of spawning a new instance ──
+  if (args.includes("--echo-logs")) {
+    // Search for the monitor PID file in common cache locations
+    const candidatePidFiles = [
+      process.env.CODEX_MONITOR_DIR
+        ? resolve(process.env.CODEX_MONITOR_DIR, ".cache", "openfleet.pid")
+        : null,
+      resolve(__dirname, "..", ".cache", "openfleet.pid"),
+      resolve(process.cwd(), ".cache", "openfleet.pid"),
+    ].filter(Boolean);
+
+    let activePidFile = null;
+    for (const f of candidatePidFiles) {
+      if (existsSync(f)) {
+        activePidFile = f;
+        break;
+      }
+    }
+
+    if (activePidFile) {
+      try {
+        const pidData = JSON.parse(readFileSync(activePidFile, "utf8"));
+        const monitorPid = Number(pidData.pid);
+        const monitorPath = (pidData.argv || [])[1] || "";
+
+        let isAlive = false;
+        try {
+          process.kill(monitorPid, 0);
+          isAlive = true;
+        } catch {}
+
+        if (isAlive && monitorPath) {
+          const logDir = resolve(dirname(monitorPath), "logs");
+          const daemonLog = resolve(logDir, "daemon.log");
+          const monitorLog = resolve(logDir, "monitor.log");
+          const logFile = existsSync(daemonLog) ? daemonLog : monitorLog;
+
+          if (existsSync(logFile)) {
+            console.log(
+              `\n  Tailing logs for active openfleet (PID ${monitorPid}):\n  ${logFile}\n`,
+            );
+            await new Promise((res) => {
+              const tail = spawn("tail", ["-f", "-n", "200", logFile], {
+                stdio: "inherit",
+              });
+              tail.on("exit", res);
+              process.on("SIGINT", () => {
+                tail.kill();
+                res();
+              });
+            });
+            process.exit(0);
+          }
+        }
+      } catch {
+        // best-effort — fall through to normal start
+      }
+    }
+
+    // No active monitor found — start normally; echoLogs will be picked up by config.mjs
+  }
+
   // Fork monitor as a child process — enables self-restart on source changes.
   // When monitor exits with code 75, cli re-forks with a fresh ESM module cache.
   await runMonitor();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@virtengine/openfleet",
-  "version": "0.25.0",
+  "version": "0.26.1",
   "description": "AI-powered orchestrator supervisor — manages AI agent executors with failover, auto-restarts on failure, analyzes crashes with Codex SDK, creates PRs via Vibe-Kanban API, and sends Telegram notifications. Supports N executors with weighted distribution, multi-repo projects, and auto-setup.",
   "type": "module",
   "license": "Apache 2.0",
@@ -92,7 +92,11 @@
     "prepush:check": "npm run syntax:check && npm test",
     "prepublishOnly": "node prepublish-check.mjs",
     "publish:env": "node publish.mjs",
-    "publish:dry-run": "node publish.mjs --dry-run"
+    "publish:dry-run": "node publish.mjs --dry-run",
+    "publish:minor": "node publish.mjs --bump minor",
+    "publish:major": "node publish.mjs --bump major",
+    "publish:minor:dry": "node publish.mjs --bump minor --dry-run",
+    "publish:major:dry": "node publish.mjs --bump major --dry-run"
   },
   "files": [
     ".env.example",

package/publish.mjs

@@ -1,7 +1,17 @@
 #!/usr/bin/env node
+//
+// Usage:
+//   node publish.mjs                  # publish at current version
+//   node publish.mjs --bump minor      # 0.25.0 → 0.25.1  (patch digit)
+//   node publish.mjs --bump major      # 0.25.0 → 0.26.0  (minor digit)
+//   node publish.mjs --bump minor --dry-run
+//
+// Terminology matches the openfleet convention (not semver):
+//   minor = last digit (semver patch)
+//   major = middle digit (semver minor)
 
 import { spawnSync } from "node:child_process";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -64,8 +74,82 @@ function runCheck(label, command, args, env) {
 
 const NPM_BIN = "npm";
 
+/**
+ * Bump the version in package.json and sync package-lock.json.
+ * type: "minor" → patch digit (0.25.0 → 0.25.1)
+ *       "major" → middle digit (0.25.0 → 0.26.0)
+ * Returns the new version string.
+ */
+function bumpVersion(type, dryRun) {
+  const pkgPath = resolve(SCRIPT_DIR, "package.json");
+  const lockPath = resolve(SCRIPT_DIR, "package-lock.json");
+
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  const [maj, mid, pat] = pkg.version.split(".").map(Number);
+
+  let newVersion;
+  if (type === "minor") {
+    // minor = patch digit (last number)
+    newVersion = `${maj}.${mid}.${pat + 1}`;
+  } else if (type === "major") {
+    // major = middle digit, reset patch
+    newVersion = `${maj}.${mid + 1}.0`;
+  } else {
+    console.error(
+      `[publish] Unknown bump type "${type}". Use "minor" (0.25.0→0.25.1) or "major" (0.25.0→0.26.0).`,
+    );
+    process.exit(1);
+  }
+
+  console.log(`[publish] Bumping version: ${pkg.version} → ${newVersion}`);
+
+  if (!dryRun) {
+    pkg.version = newVersion;
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+
+    // Update package-lock.json in-place
+    try {
+      const lock = JSON.parse(readFileSync(lockPath, "utf8"));
+      lock.version = newVersion;
+      if (lock.packages?.[""] != null) {
+        lock.packages[""].version = newVersion;
+      }
+      writeFileSync(lockPath, JSON.stringify(lock, null, 2) + "\n", "utf8");
+      console.log(
+        `[publish] package.json + package-lock.json updated to ${newVersion}`,
+      );
+    } catch {
+      console.warn(
+        "[publish] Could not update package-lock.json — regenerating...",
+      );
+      spawnSync(NPM_BIN, ["install", "--package-lock-only", "--ignore-scripts"], {
+        stdio: "inherit",
+        cwd: SCRIPT_DIR,
+        shell: true,
+      });
+    }
+  } else {
+    console.log(
+      `[publish] dry-run: would write version ${newVersion} to package.json & package-lock.json`,
+    );
+  }
+
+  return newVersion;
+}
+
+function getBumpArg() {
+  const idx = process.argv.indexOf("--bump");
+  if (idx !== -1 && process.argv[idx + 1]) return process.argv[idx + 1];
+  const flag = process.argv.find((a) => a.startsWith("--bump="));
+  if (flag) return flag.slice(7);
+  return null;
+}
+
 function main() {
+  const bumpType = getBumpArg();
   const dryRun = hasArg("--dry-run");
+  if (bumpType) bumpVersion(bumpType, dryRun);
+
   const tag = process.env.NPM_PUBLISH_TAG || "latest";
   const otp = process.env.NPM_OTP || "";
   const access = process.env.NPM_PUBLISH_ACCESS || "public";

package/telegram-bot.mjs

@@ -2614,7 +2614,7 @@ async function clearWebAppMenuButton() {
   }
 }
 
-const MENU_BUTTON_REFRESH_MS = 5 * 60 * 1000; // 5 minutes
+const MENU_BUTTON_REFRESH_MS = 60 * 1000; // 1 minute — re-sync after tunnel URL rotates
 
 async function refreshMenuButton() {
   const { uiUrl: currentUiUrl, webAppUrl: currentUrl } = syncUiUrlsFromServer();