@0dai-dev/cli 4.1.0 → 4.3.4

package/lib/commands/runner.js

@@ -0,0 +1,527 @@
+"use strict";
+
+const shared = require("../shared");
+const { T, R, D, E, G, W, fs, path, spawnSync, log, findRepoScript } = shared;
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (err) {
+    return { error: err.message };
+  }
+}
+
+function commandExists(name) {
+  const result = spawnSync("bash", ["-lc", `command -v ${name} >/dev/null 2>&1`], {
+    encoding: "utf8",
+    timeout: 3000,
+  });
+  return result.status === 0;
+}
+
+function runText(cmd, args, timeoutMs = 10000) {
+  if (!commandExists(cmd)) {
+    return { ok: false, error: `${cmd} not installed`, stdout: "" };
+  }
+  const result = spawnSync(cmd, args, {
+    encoding: "utf8",
+    timeout: timeoutMs,
+    maxBuffer: 2 * 1024 * 1024,
+  });
+  if (result.error) {
+    return { ok: false, error: result.error.message, stdout: result.stdout || "" };
+  }
+  if (typeof result.status === "number" && result.status !== 0) {
+    return {
+      ok: false,
+      error: String(result.stderr || result.stdout || `${cmd} exited ${result.status}`).trim(),
+      stdout: result.stdout || "",
+    };
+  }
+  return { ok: true, error: "", stdout: result.stdout || "" };
+}
+
+function parseDropletList(stdout) {
+  return stdout.split(/\r?\n/).filter(Boolean).map((line) => {
+    const parts = line.trim().split(/\s+/);
+    return {
+      id: parts[0] || "",
+      name: parts[1] || "",
+      size_slug: parts[2] || "",
+      memory_mb: Number(parts[3] || 0),
+      vcpus: Number(parts[4] || 0),
+      disk_gb: Number(parts[5] || 0),
+      public_ip: parts[6] || "",
+      private_ip: parts[7] || "",
+      status: parts[8] || "",
+    };
+  });
+}
+
+function parseAccount(stdout) {
+  const parts = stdout.trim().split(/\s+/);
+  return {
+    email: parts[0] || "",
+    droplet_limit: Number(parts[1] || 0),
+    status: parts[2] || "",
+  };
+}
+
+function parseRunners(stdout) {
+  return stdout.split(/\r?\n/).filter(Boolean).map((line) => {
+    const [name, status, busy, labels] = line.split("\t");
+    return {
+      name: name || "",
+      status: status || "",
+      busy: busy === "true",
+      labels: labels ? labels.split(",").filter(Boolean) : [],
+    };
+  });
+}
+
+function liveSnapshot(config) {
+  const account = runText("doctl", ["account", "get", "--format", "Email,DropletLimit,Status", "--no-header"]);
+  const droplets = runText("doctl", [
+    "compute", "droplet", "list",
+    "--format", "ID,Name,SizeSlug,Memory,VCPUs,Disk,PublicIPv4,PrivateIPv4,Status",
+    "--no-header",
+  ]);
+  const pools = runText("doctl", [
+    "compute", "droplet-autoscale", "list",
+    "--format", "ID,Name,Region,Status,Min Instance,Max Instance,Target Instance,Avg CPU Util,Avg Mem Util,Target CPU Util,Target Mem Util",
+    "--no-header",
+  ]);
+  const repo = config.github_repo || "iGeezmo/0dai";
+  const runners = runText("gh", [
+    "api", `repos/${repo}/actions/runners`, "--paginate",
+    "--jq", '.runners[] | [.name,.status,.busy,([.labels[].name]|join(","))] | @tsv',
+  ]);
+
+  return {
+    account: account.ok ? parseAccount(account.stdout) : null,
+    account_error: account.ok ? "" : account.error,
+    droplets: droplets.ok ? parseDropletList(droplets.stdout) : [],
+    droplets_error: droplets.ok ? "" : droplets.error,
+    autoscale_pools_raw: pools.ok ? pools.stdout.trim() : "",
+    autoscale_pools_error: pools.ok ? "" : pools.error,
+    github_runners: runners.ok ? parseRunners(runners.stdout) : [],
+    github_runners_error: runners.ok ? "" : runners.error,
+  };
+}
+
+function configuredHostRows(config, live) {
+  const liveByName = new Map((live.droplets || []).map((d) => [d.name, d]));
+  return (config.project_hosts || []).map((host) => ({
+    ...host,
+    live: liveByName.get(host.name) || null,
+  }));
+}
+
+function configuredPoolRows(config, live) {
+  const runners = live.github_runners || [];
+  return (config.runner_pools || []).map((pool) => {
+    const memberNames = new Set(pool.member_names || []);
+    const distinctiveLabels = (pool.labels || []).filter((label) => !["self-hosted", "Linux", "X64"].includes(label));
+    const matchingRunners = runners.filter((runner) => {
+      if (memberNames.has(runner.name)) return true;
+      if (!distinctiveLabels.length) return false;
+      const runnerLabels = new Set(runner.labels || []);
+      return distinctiveLabels.every((label) => runnerLabels.has(label));
+    });
+    return { ...pool, matching_runners: matchingRunners };
+  });
+}
+
+function buildRecommendations(config, live, target = process.cwd()) {
+  const recommendations = [];
+  const requestedLimit = Number((config.digitalocean || {}).requested_droplet_limit_min || 0);
+  const currentLimit = Number((live.account || {}).droplet_limit || (config.digitalocean || {}).current_droplet_limit || 0);
+  const liveDropletCount = (live.droplets || []).length;
+  const dropletLimitBlocksNewPool = Boolean(currentLimit && liveDropletCount >= currentLimit);
+  if (requestedLimit && currentLimit && currentLimit < requestedLimit) {
+    recommendations.push({
+      priority: "p0",
+      action: "request_droplet_limit_increase",
+      reason: `current DO droplet limit ${currentLimit} is below target ${requestedLimit}`,
+    });
+  }
+
+  const plannedPools = (config.runner_pools || [])
+    .filter((pool) => pool.provider === "digitalocean-autoscale-pool" && pool.status !== "future")
+    .sort((a, b) => Number(a.activation_priority || 100) - Number(b.activation_priority || 100));
+  const hasLivePool = Boolean(String(live.autoscale_pools_raw || "").trim());
+  const hasBootstrap = fs.existsSync(path.join(target, "ops", "runner", "bootstrap-ephemeral.sh"));
+  const hasScaler = fs.existsSync(path.join(target, "scripts", "do_ephemeral_runner_scaler.py"));
+  const zeroIdleProbe = (config.live_verification || {}).autoscale_zero_idle_probe || {};
+  const nativeAutoscaleRejectsMinZero = zeroIdleProbe.dynamic_min_instances_zero === "rejected"
+    || zeroIdleProbe.static_target_instances_zero === "rejected";
+
+  const legacy = config.legacy_runner_pools || [];
+  if (legacy.length) {
+    recommendations.push({
+      priority: hasLivePool ? "p1" : "p2",
+      action: hasLivePool ? "drain_legacy_app_host_runners_after_smoke" : "keep_legacy_app_host_runners_until_ephemeral_smoke",
+      reason: hasLivePool
+        ? "0dai-app-fra1 should stop carrying routine CI after dedicated runner validation"
+        : "legacy runners are rollback capacity while no DO autoscale pool exists",
+    });
+  }
+  for (const pool of plannedPools.slice(0, 1)) {
+    if (!hasLivePool) {
+      if (!hasBootstrap) {
+        recommendations.push({
+          priority: "p1",
+          action: "build_ephemeral_runner_bootstrap_before_pool_create",
+          reason: `${pool.pool_name || pool.id} is planned but no bootstrap entrypoint exists`,
+        });
+        continue;
+      }
+      if (!hasScaler) {
+        recommendations.push({
+          priority: "p1",
+          action: "add_queue_aware_runner_scaler_before_pool_create",
+          reason: `${pool.pool_name || pool.id} is planned but queue-aware DO target planner is missing`,
+        });
+        continue;
+      }
+      if (dropletLimitBlocksNewPool) {
+        recommendations.push({
+          priority: "p1",
+          action: "wait_for_droplet_limit_before_pool_create",
+          reason: `${pool.pool_name || pool.id} cannot be created while ${liveDropletCount}/${currentLimit} droplet slots are used`,
+        });
+        continue;
+      }
+      if (nativeAutoscaleRejectsMinZero && Number(pool.min_instances || 0) === 0) {
+        recommendations.push({
+          priority: "p1",
+          action: "choose_runner_zero_idle_strategy_before_pool_create",
+          reason: `${pool.pool_name || pool.id} is configured for min=0, but live DO API rejected zero-idle autoscale; choose native min=1 or custom create/delete runners`,
+        });
+        continue;
+      }
+      recommendations.push({
+        priority: "p1",
+        action: "create_and_smoke_ephemeral_runner_pool",
+        reason: `${pool.pool_name || pool.id} is planned, bootstrap/scaler exist, but no DO autoscale pool exists`,
+      });
+    }
+  }
+
+  const futurePools = (config.runner_pools || [])
+    .filter((pool) => pool.provider === "digitalocean-autoscale-pool" && pool.status === "future");
+  if (futurePools.length) {
+    recommendations.push({
+      priority: "p2",
+      action: "defer_future_specialized_profiles_until_base_pool_smoke_passes",
+      reason: `${futurePools.length} future pool profile(s) require separate image/toolchain validation`,
+    });
+  }
+
+  const warmPools = configuredPoolRows(config, live).filter((pool) => pool.status === "active-transitional");
+  for (const pool of warmPools) {
+    const online = (pool.matching_runners || []).filter((runner) => runner.status === "online").length;
+    if (online === 0) {
+      recommendations.push({
+        priority: "p0",
+        action: "restore_warm_runner",
+        reason: `${pool.id} has no online runner`,
+      });
+    } else {
+      recommendations.push({
+        priority: "p2",
+        action: "keep_warm_runner_until_ephemeral_pool_passes_smoke",
+        reason: `${pool.id} is online and provides rollback capacity`,
+      });
+    }
+  }
+
+  const rank = { p0: 0, p1: 1, p2: 2 };
+  return recommendations.sort((a, b) => (rank[a.priority] ?? 99) - (rank[b.priority] ?? 99));
+}
+
+function printHuman(config, live, recommendations = [], command = "status") {
+  console.log(`\n  ${T}0dai runner architecture${R}`);
+  console.log(`  strategy: ${config.strategy || "unknown"}`);
+  console.log(`  persistent CLI: ${(config.placement || {}).persistent_cli || "unknown"}`);
+  console.log(`  disposable compute: ${(config.placement || {}).disposable_compute || "unknown"}`);
+
+  if (live.account) {
+    const desired = (config.digitalocean || {}).requested_droplet_limit_min || 0;
+    const limitColor = desired && live.account.droplet_limit < desired ? W : G;
+    console.log(`\n  DO account: ${live.account.email || "unknown"} limit=${limitColor}${live.account.droplet_limit}${R} status=${live.account.status || "unknown"}`);
+    if (desired && live.account.droplet_limit < desired) {
+      console.log(`  ${W}limit below target: request at least ${desired}${R}`);
+    }
+  } else if (live.account_error) {
+    console.log(`\n  ${E}DO account unavailable:${R} ${live.account_error}`);
+  }
+
+  console.log("\n  Project hosts");
+  for (const row of configuredHostRows(config, live)) {
+    const liveText = row.live ? `${row.live.size_slug} ${row.live.status}` : "not found";
+    console.log(`  - ${row.name.padEnd(20)} role=${row.role || ""} live=${liveText} cli=${row.persistent_cli ? "persistent" : "none"} autoscale=${row.autoscale ? "yes" : "no"}`);
+  }
+
+  console.log("\n  Runner pools");
+  for (const row of configuredPoolRows(config, live)) {
+    const count = row.matching_runners ? row.matching_runners.length : 0;
+    const online = (row.matching_runners || []).filter((r) => r.status === "online").length;
+    const busy = (row.matching_runners || []).filter((r) => r.busy).length;
+    console.log(`  - ${row.id.padEnd(22)} ${row.status || ""} ${row.provider || ""} size=${row.size_slug || ""} runners=${online}/${count} online busy=${busy}`);
+  }
+
+  if (live.github_runners_error) {
+    console.log(`\n  ${E}GitHub runners unavailable:${R} ${live.github_runners_error}`);
+  } else {
+    console.log("\n  GitHub runners");
+    for (const runner of live.github_runners) {
+      const busy = runner.busy ? `${W}busy${R}` : "idle";
+      console.log(`  - ${runner.name.padEnd(22)} ${runner.status.padEnd(8)} ${busy} ${D}${runner.labels.join(",")}${R}`);
+    }
+  }
+
+  if (live.autoscale_pools_raw) {
+    console.log(`\n  DO autoscale pools:\n${live.autoscale_pools_raw}`);
+  } else if (live.autoscale_pools_error) {
+    console.log(`\n  ${D}DO autoscale pools unavailable: ${live.autoscale_pools_error}${R}`);
+  } else {
+    console.log(`\n  ${D}DO autoscale pools: none${R}`);
+  }
+  if (command === "plan") {
+    console.log("\n  Recommended next actions");
+    for (const rec of recommendations) {
+      const color = rec.priority === "p0" ? E : rec.priority === "p1" ? W : D;
+      console.log(`  - ${color}${rec.priority}${R} ${rec.action}: ${rec.reason}`);
+    }
+    if (!recommendations.length) {
+      console.log(`  ${G}no immediate runner architecture actions${R}`);
+    }
+  }
+  console.log("");
+}
+
+function runQueueController(target, configPath, forwarded) {
+  const script = findRepoScript(target, "runner_queue_controller.py");
+  if (!script) {
+    log("runner queue controller not found");
+    console.log(`  ${D}expected: scripts/runner_queue_controller.py${R}`);
+    process.exitCode = 1;
+    return;
+  }
+  const result = spawnSync("python3", [script, "queue-status", "--config", configPath, ...forwarded], {
+    encoding: "utf8",
+    timeout: 30000,
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  if (result.error) {
+    log(`runner queue controller failed: ${result.error.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (typeof result.status === "number" && result.status !== 0) {
+    process.exitCode = result.status;
+  }
+}
+
+function runBurstPlanner(target, configPath, forwarded) {
+  const script = findRepoScript(target, "runner_burst_planner.py");
+  if (!script) {
+    log("runner burst planner not found");
+    console.log(`  ${D}expected: scripts/runner_burst_planner.py${R}`);
+    process.exitCode = 1;
+    return;
+  }
+  const result = spawnSync("python3", [script, "burst-plan", "--config", configPath, ...forwarded], {
+    encoding: "utf8",
+    timeout: 30000,
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  if (result.error) {
+    log(`runner burst planner failed: ${result.error.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (typeof result.status === "number" && result.status !== 0) {
+    process.exitCode = result.status;
+  }
+}
+
+function runRouteDryRunController(target, configPath, forwarded) {
+  const script = findRepoScript(target, "runner_route_dry_run.py");
+  if (!script) {
+    log("runner route dry-run controller not found");
+    console.log(`  ${D}expected: scripts/runner_route_dry_run.py${R}`);
+    process.exitCode = 1;
+    return;
+  }
+  const result = spawnSync("python3", [script, "route-dry-run", "--config", configPath, ...forwarded], {
+    encoding: "utf8",
+    timeout: 30000,
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  if (result.error) {
+    log(`runner route dry-run controller failed: ${result.error.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (typeof result.status === "number" && result.status !== 0) {
+    process.exitCode = result.status;
+  }
+}
+
+function runLabelAuditController(target, configPath, forwarded) {
+  const script = findRepoScript(target, "runner_label_audit.py");
+  if (!script) {
+    log("runner label audit controller not found");
+    console.log(`  ${D}expected: scripts/runner_label_audit.py${R}`);
+    process.exitCode = 1;
+    return;
+  }
+  const result = spawnSync("python3", [script, "label-audit", "--config", configPath, ...forwarded], {
+    encoding: "utf8",
+    timeout: 30000,
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  if (result.error) {
+    log(`runner label audit controller failed: ${result.error.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (typeof result.status === "number" && result.status !== 0) {
+    process.exitCode = result.status;
+  }
+}
+
+function runJitApplyController(target, configPath, jitCommand, forwarded) {
+  const script = findRepoScript(target, "runner_jit_apply_controller.py");
+  if (!script) {
+    log("runner JIT apply controller not found");
+    console.log(`  ${D}expected: scripts/runner_jit_apply_controller.py${R}`);
+    process.exitCode = 1;
+    return;
+  }
+  const result = spawnSync("python3", [script, jitCommand, "--config", configPath, ...forwarded], {
+    encoding: "utf8",
+    timeout: 30000,
+    maxBuffer: 8 * 1024 * 1024,
+  });
+  if (result.error) {
+    log(`runner JIT apply controller failed: ${result.error.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (typeof result.status === "number" && result.status !== 0) {
+    process.exitCode = result.status;
+  }
+}
+
+function resolveRunnerManifestPath(target) {
+  const candidates = [
+    path.join(target, "ai", "meta", "manifest", "runner-pools.json"),
+    path.join(target, "ai", "manifest", "runner-pools.json"),
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate)) || candidates[0];
+}
+
+function cmdRunner(target, sub, args) {
+  const command = sub && !sub.startsWith("-") ? sub : "status";
+  const forwarded = command === sub ? args.slice(2) : args.slice(1);
+  const asJson = forwarded.includes("--json") || args.includes("--json");
+  const offline = forwarded.includes("--offline") || args.includes("--offline");
+  const configPath = resolveRunnerManifestPath(target);
+  if (!fs.existsSync(configPath)) {
+    log("runner-pools manifest not found");
+    console.log(`  ${D}expected: ai/meta/manifest/runner-pools.json${R}`);
+    process.exitCode = 1;
+    return;
+  }
+  const config = readJson(configPath);
+  if (config.error) {
+    log(`invalid runner-pools manifest: ${config.error}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (command === "queue-status") {
+    runQueueController(target, configPath, forwarded);
+    return;
+  }
+
+  if (command === "burst-plan") {
+    runBurstPlanner(target, configPath, forwarded);
+    return;
+  }
+
+  if (command === "route-dry-run" || command === "burst-route") {
+    runRouteDryRunController(target, configPath, forwarded);
+    return;
+  }
+
+  if (command === "label-audit") {
+    runLabelAuditController(target, configPath, forwarded);
+    return;
+  }
+
+  if (command === "burst-apply" || command === "burst-preflight" || command === "burst-reap" || command === "burst-reap-plan") {
+    const jitCommand = {
+      "burst-apply": "burst-apply",
+      "burst-preflight": "preflight",
+      "burst-reap": "reap",
+      "burst-reap-plan": "reap-plan",
+    }[command];
+    runJitApplyController(target, configPath, jitCommand, forwarded);
+    return;
+  }
+
+  if (command !== "status" && command !== "plan") {
+    console.log("Usage: 0dai runner [status|plan|queue-status|label-audit|burst-plan|route-dry-run|burst-apply|burst-preflight|burst-reap|burst-reap-plan] [--json] [--offline]");
+    process.exitCode = 1;
+    return;
+  }
+
+  const live = offline ? {
+    account: null,
+    account_error: "offline mode",
+    droplets: [],
+    droplets_error: "offline mode",
+    autoscale_pools_raw: "",
+    autoscale_pools_error: "offline mode",
+    github_runners: [],
+    github_runners_error: "offline mode",
+  } : liveSnapshot(config);
+
+  const recommendations = buildRecommendations(config, live, target);
+  const payload = {
+    schema_version: 1,
+    command,
+    config_path: configPath,
+    strategy: config.strategy || "",
+    placement: config.placement || {},
+    digitalocean: config.digitalocean || {},
+    project_hosts: configuredHostRows(config, live),
+    runner_pools: configuredPoolRows(config, live),
+    legacy_runner_pools: config.legacy_runner_pools || [],
+    rules: config.rules || [],
+    recommendations,
+    live,
+  };
+
+  if (asJson) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  printHuman(config, live, recommendations, command);
+}
+
+module.exports = { cmdRunner };

package/lib/commands/session.js

@@ -1,18 +1,12 @@
 "use strict";
 const shared = require("../shared");
-const { log, fs, path, requirePlan } = shared;
+const { log, fs, path } = shared;
 
 function cmdSession(target, sub, args) {
   const sessFile = path.join(target, "ai", "sessions", "active.json");
   const sessDir = path.dirname(sessFile);
 
   if (sub === "save") {
-    const gate = requirePlan("pro", "Session Roaming", target);
-    if (gate) {
-      log(gate.error);
-      log(gate.hint);
-      return;
-    }
     fs.mkdirSync(sessDir, { recursive: true });
     const goal = args.find((_, i) => args[i - 1] === "--goal") || "";
     const summary = args.find((_, i) => args[i - 1] === "--summary") || "";