@thinkingai/ae-cli 6.1.7 → 6.1.9

package/dist/chunk-KTYR3U6D.js

@@ -0,0 +1,1012 @@
+import {
+  peekCliToken
+} from "./chunk-E7UXXHO3.js";
+import {
+  getToken
+} from "./chunk-IR4ZLVPW.js";
+import {
+  getActiveHost,
+  getConfigDir,
+  isAeSandboxRuntime,
+  normalizeUrl
+} from "./chunk-V6FR6WTW.js";
+import {
+  logger
+} from "./chunk-LYVNONC4.js";
+
+// src/core/version-sync.ts
+import { spawnSync } from "child_process";
+import fs from "fs";
+import path from "path";
+
+// src/core/update-check.ts
+function shouldSkipUpdateCheck(argv = process.argv) {
+  if (process.env.AE_CLI_NO_UPDATE_CHECK === "1") return true;
+  if (process.env.CI === "true" || process.env.CI === "1") return true;
+  return argv.slice(2).some((arg) => {
+    if (arg === "--no-update-check") return true;
+    if (arg === "--version" || arg === "-V" || arg === "--help" || arg === "-h") return true;
+    return false;
+  });
+}
+function parseVersion(version) {
+  const core = version.trim().split("-")[0];
+  return core.split(".").map((part) => {
+    const n = Number.parseInt(part, 10);
+    return Number.isFinite(n) ? n : 0;
+  });
+}
+function isNewer(latest, current) {
+  const a = parseVersion(latest);
+  const b = parseVersion(current);
+  const len = Math.max(a.length, b.length, 3);
+  for (let i = 0; i < len; i += 1) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    if (av > bv) return true;
+    if (av < bv) return false;
+  }
+  return false;
+}
+
+// src/core/legacy-cli-version-map.ts
+var HISTORICAL_CLUSTER_TO_PUBLIC_PIN = {
+  "6.0.0": "1.0.15",
+  "6.0.1": "1.0.15",
+  "6.0.2": "1.0.18",
+  "6.0.3": "1.0.18",
+  "6.0.4": "1.0.20",
+  "6.0.5": "1.0.21",
+  "6.0.6": "1.0.22",
+  "6.0.7": "1.0.22",
+  "6.0.8": "1.0.22",
+  "6.0.9": "1.0.22",
+  "6.0.10": "1.0.24",
+  "6.0.11": "1.0.24",
+  "6.0.12": "1.0.27",
+  "6.0.13": "1.0.28",
+  "6.0.14": "1.0.28",
+  "6.0.15": "1.0.30",
+  "6.0.16": "6.0.16",
+  "6.0.17": "6.0.17",
+  "6.0.18": "6.0.18",
+  "6.0.19": "6.0.18",
+  "6.0.20": "6.0.20",
+  "6.0.21": "6.0.20",
+  "6.0.22": "6.0.22",
+  "6.0.23": "6.0.22",
+  "6.0.24": "6.0.24",
+  "6.0.25": "6.0.24",
+  "6.0.26": "6.0.24"
+};
+
+// src/core/version-compat.ts
+var OPEN_SOURCE_AE_CLI_PACKAGE = "@thinkingai/ae-cli";
+var AE_CLI_SKILLS_REPO = "ThinkingAIAgenticEngine/ae-cli";
+var PUBLISHED_EXTERNAL_VERSIONS = /* @__PURE__ */ new Set([
+  "1.0.15",
+  "1.0.18",
+  "1.0.20",
+  "1.0.21",
+  "1.0.22",
+  "1.0.24",
+  "1.0.27",
+  "1.0.28",
+  "1.0.30",
+  "6.0.16",
+  "6.0.17",
+  "6.0.18",
+  "6.0.20",
+  "6.0.22",
+  "6.0.24",
+  "6.0.27",
+  "6.0.28",
+  "6.0.29",
+  "6.0.30",
+  "6.0.31"
+]);
+function normalizeCliVersion(version) {
+  return version.trim().replace(/^v/i, "");
+}
+function versionLine(version) {
+  const parts = normalizeCliVersion(version).split(/[.-]/);
+  if (parts.length < 2) return normalizeCliVersion(version);
+  return `${parts[0]}.${parts[1]}`;
+}
+function sameVersionLine(a, b) {
+  return versionLine(a) === versionLine(b);
+}
+function parseVersionParts(version) {
+  const core = normalizeCliVersion(version).split("-")[0];
+  return core.split(".").map((p) => {
+    const n = Number.parseInt(p, 10);
+    return Number.isFinite(n) ? n : 0;
+  });
+}
+function compareNormalized(a, b) {
+  const pa = parseVersionParts(a);
+  const pb = parseVersionParts(b);
+  const len = Math.max(pa.length, pb.length, 3);
+  for (let i = 0; i < len; i += 1) {
+    const av = pa[i] ?? 0;
+    const bv = pb[i] ?? 0;
+    if (av > bv) return 1;
+    if (av < bv) return -1;
+  }
+  return 0;
+}
+function evaluateCompat(localRaw, expectedRaw, clusterLine) {
+  const local = normalizeCliVersion(localRaw);
+  const expected = normalizeCliVersion(expectedRaw);
+  if (!local || !expected) return { kind: "ok" };
+  const line = clusterLine && clusterLine.trim() || versionLine(expected);
+  if (!sameVersionLine(local, expected)) {
+    return { kind: "line_mismatch", local, expected, line };
+  }
+  if (clusterLine && clusterLine.trim()) {
+    const clusterNorm = clusterLine.trim();
+    const localLine = versionLine(local);
+    if (localLine !== clusterNorm && localLine !== versionLine(clusterNorm)) {
+      return { kind: "line_mismatch", local, expected, line: clusterNorm };
+    }
+  }
+  if (local === expected) return { kind: "ok" };
+  if (isNewer(local, expected)) {
+    return { kind: "local_newer", local, expected, line };
+  }
+  if (isNewer(expected, local)) {
+    return { kind: "local_older", local, expected, line };
+  }
+  return { kind: "ok" };
+}
+function resolvePinTarget(expectedVersion) {
+  const expected = expectedVersion.trim().replace(/^v/i, "");
+  if (!expected) return null;
+  if (PUBLISHED_EXTERNAL_VERSIONS.has(expected)) return expected;
+  const historical = HISTORICAL_CLUSTER_TO_PUBLIC_PIN[expected];
+  if (historical && PUBLISHED_EXTERNAL_VERSIONS.has(historical)) {
+    return historical;
+  }
+  const line = versionLine(expected);
+  const candidates = [...PUBLISHED_EXTERNAL_VERSIONS].filter((tag) => {
+    if (versionLine(tag) !== line) return false;
+    return compareNormalized(tag, expected) <= 0;
+  });
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => compareNormalized(a, b));
+  return candidates[candidates.length - 1] ?? null;
+}
+function formatPinCommands(expectedVersion) {
+  const ver = resolvePinTarget(expectedVersion);
+  if (!ver) return [];
+  return [
+    `npm i -g ${OPEN_SOURCE_AE_CLI_PACKAGE}@${ver}`,
+    `npx skills add ${AE_CLI_SKILLS_REPO}#v${ver} -g -y`
+  ];
+}
+function formatUpgradeCommands(expectedVersion) {
+  const ver = expectedVersion.trim().replace(/^v/i, "");
+  if (!/^\d+\.\d+\.\d+(?:[-+].*)?$/.test(ver)) return [];
+  return [
+    `npm i -g ${OPEN_SOURCE_AE_CLI_PACKAGE}@${ver}`,
+    `npx skills add ${AE_CLI_SKILLS_REPO}#v${ver} -g -y`
+  ];
+}
+function formatUnifiedUpdateCommand() {
+  return "ae-cli update";
+}
+function formatCompatNotice(verdict) {
+  if (verdict.kind === "ok") return void 0;
+  const canUpdateToHost = formatUpgradeCommands(verdict.expected).length > 0;
+  if (verdict.kind === "local_newer") {
+    if (canUpdateToHost) {
+      return [
+        `[ae-cli] Host compat: local ${verdict.local} > environment ${verdict.expected} (cluster ${verdict.line}).`,
+        `         Run: ${formatUnifiedUpdateCommand()} to sync CLI + skills to this host.`,
+        `         Or update cluster components to the latest version.`
+      ].join("\n");
+    }
+    return [
+      `[ae-cli] Host compat: local ${verdict.local} > environment ${verdict.expected} (cluster ${verdict.line}).`,
+      `         No public GitHub/npm release on this line is \u2264 environment ${verdict.expected}.`,
+      `         Update cluster components to the latest version to match your CLI.`
+    ].join("\n");
+  }
+  if (verdict.kind === "local_older") {
+    if (canUpdateToHost) {
+      return [
+        `[ae-cli] Host compat: local ${verdict.local} < environment ${verdict.expected} (cluster ${verdict.line}).`,
+        `         Run: ${formatUnifiedUpdateCommand()} to sync CLI + skills to this host.`
+      ].join("\n");
+    }
+    return [
+      `[ae-cli] Host compat: local ${verdict.local} < environment ${verdict.expected} (cluster ${verdict.line}).`,
+      `         No installable semver target for environment ${verdict.expected}.`,
+      `         Ask the platform owner for the install package, or wait for a published build.`
+    ].join("\n");
+  }
+  if (canUpdateToHost) {
+    return [
+      `[ae-cli] Host compat: local ${verdict.local} line mismatches environment ${verdict.expected} (cluster ${verdict.line}).`,
+      `         Run: ${formatUnifiedUpdateCommand()} to sync CLI + skills to this host.`,
+      `         Or update cluster components to the latest version to match your CLI line.`
+    ].join("\n");
+  }
+  return [
+    `[ae-cli] Host compat: local ${verdict.local} line mismatches environment ${verdict.expected} (cluster ${verdict.line}).`,
+    `         No public GitHub/npm release for this line; update cluster components to the latest version, or install a published build on the same line.`
+  ].join("\n");
+}
+
+// src/core/version-sync.ts
+var COMMAND_TIMEOUT_MS = 12e4;
+var AUTO_ATTEMPT_INTERVAL_MS = 60 * 60 * 1e3;
+var MAX_AUTO_ATTEMPTS_PER_DAY = 3;
+var LOCK_STALE_MS = 10 * 60 * 1e3;
+var SYNC_STATE_FILE = "version-sync.json";
+var SYNC_LOCK_FILE = "version-sync.lock";
+function syncStatePath() {
+  return path.join(getConfigDir(), SYNC_STATE_FILE);
+}
+function syncLockPath() {
+  return path.join(getConfigDir(), SYNC_LOCK_FILE);
+}
+function readSyncStore() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(syncStatePath(), "utf8"));
+    if (raw && typeof raw === "object" && raw.hosts && typeof raw.hosts === "object") {
+      return raw;
+    }
+  } catch {
+  }
+  return { hosts: {} };
+}
+function writeSyncStore(store) {
+  try {
+    fs.mkdirSync(getConfigDir(), { recursive: true });
+    fs.writeFileSync(syncStatePath(), JSON.stringify(store, null, 2));
+  } catch {
+  }
+}
+function localDay(now) {
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function freshAttemptEntry(target, now) {
+  return {
+    target,
+    attemptDay: localDay(now),
+    attemptsToday: 0
+  };
+}
+function evaluateAutoAttempt(existing, target, now = /* @__PURE__ */ new Date()) {
+  const today = localDay(now);
+  const entry = !existing || existing.target !== target || existing.attemptDay !== today ? freshAttemptEntry(target, now) : { ...existing };
+  if (entry.attemptsToday >= MAX_AUTO_ATTEMPTS_PER_DAY) {
+    return { allowed: false, reason: "daily_limit", entry };
+  }
+  if (entry.lastAttemptAt) {
+    const elapsed = now.getTime() - new Date(entry.lastAttemptAt).getTime();
+    if (Number.isFinite(elapsed) && elapsed < AUTO_ATTEMPT_INTERVAL_MS) {
+      return { allowed: false, reason: "hourly_limit", entry };
+    }
+  }
+  return { allowed: true, entry };
+}
+function reserveAutoAttempt(host, target, now = /* @__PURE__ */ new Date()) {
+  const store = readSyncStore();
+  const key = normalizeUrl(host);
+  const decision = evaluateAutoAttempt(store.hosts[key], target, now);
+  if (!decision.allowed) return decision;
+  decision.entry.attemptsToday += 1;
+  decision.entry.lastAttemptAt = now.toISOString();
+  store.hosts[key] = decision.entry;
+  writeSyncStore(store);
+  return decision;
+}
+function getPendingSkillsTarget(host) {
+  const entry = readSyncStore().hosts[normalizeUrl(host)];
+  return entry?.pendingSkills ? entry.target : void 0;
+}
+function recordVersionSyncResult(host, target, result) {
+  const store = readSyncStore();
+  const key = normalizeUrl(host);
+  const existing = store.hosts[key] ?? freshAttemptEntry(target, /* @__PURE__ */ new Date());
+  const entry = existing.target === target ? existing : freshAttemptEntry(target, /* @__PURE__ */ new Date());
+  if (result.ok) {
+    entry.pendingSkills = false;
+    delete entry.lastFailureStage;
+  } else {
+    entry.pendingSkills = result.skillsPending;
+    entry.lastFailureStage = result.stage;
+  }
+  store.hosts[key] = entry;
+  writeSyncStore(store);
+}
+function isAutoSyncTargetEligible(version) {
+  const normalized = normalizeCliVersion(version);
+  const parts = normalized.split("-")[0].split(".").map((part) => Number.parseInt(part, 10));
+  if (parts.length < 3 || parts.some((part) => !Number.isFinite(part))) return false;
+  const [major, minor, patch] = parts;
+  if (major > 6) return true;
+  if (major !== 6) return false;
+  if (minor > 1) return true;
+  if (minor === 1) return patch >= 5;
+  if (minor === 0) return patch >= 33;
+  return false;
+}
+function isPublicAeCliPackage(packageName) {
+  return packageName === OPEN_SOURCE_AE_CLI_PACKAGE;
+}
+function resolveNodeTool(tool, execPath = process.execPath, platform = process.platform) {
+  const fileName = platform === "win32" ? `${tool}.cmd` : tool;
+  const sibling = path.join(path.dirname(execPath), fileName);
+  return fs.existsSync(sibling) ? sibling : fileName;
+}
+function buildVersionInstallPlan(targetRaw, globalRoot = "<npm-root>") {
+  const target = normalizeCliVersion(targetRaw);
+  const localSkills = path.join(globalRoot, "@thinkingai", "ae-cli", "skills");
+  return {
+    target,
+    commands: [
+      `npm install -g ${OPEN_SOURCE_AE_CLI_PACKAGE}@${target}`,
+      `npx -y skills add ${localSkills} -g -y`,
+      `npx -y skills add ${AE_CLI_SKILLS_REPO}#v${target} -g -y`
+    ],
+    skillsSources: ["installed-package", "github-fallback"]
+  };
+}
+function defaultRunner(command, args, timeoutMs) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    maxBuffer: 2 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: timeoutMs,
+    windowsHide: true
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    error: result.error,
+    signal: result.signal
+  };
+}
+function resultMessage(result) {
+  if (result.error?.message) return result.error.message;
+  const detail = (result.stderr || result.stdout).trim().split(/\r?\n/).filter(Boolean).slice(-3).join(" ");
+  if (detail) return detail;
+  if (result.signal) return `Command terminated by ${result.signal}`;
+  return `Command exited with status ${result.status ?? "unknown"}`;
+}
+function classifyFailure(result) {
+  const text = `${result.error?.message || ""}
+${result.stderr}
+${result.stdout}`;
+  if (result.error && result.error.code === "ETIMEDOUT") return "timeout";
+  if (/timed?\s*out|ETIMEDOUT/i.test(text)) return "timeout";
+  if (/EACCES|EPERM|permission denied|access is denied/i.test(text)) return "permission";
+  if (/EAI_AGAIN|ENOTFOUND|ECONNRESET|ECONNREFUSED|network|unable to access|could not resolve|certificate|SSL/i.test(text)) {
+    return "network";
+  }
+  if (/E404|404 Not Found|no matching version|couldn't find remote ref|not found/i.test(text)) {
+    return "package_missing";
+  }
+  return "unknown";
+}
+function friendlyVersionSyncFailure(result) {
+  if (result.cause === "busy") {
+    return "Another ae-cli process is synchronizing the global installation.";
+  }
+  if (result.cause === "permission") {
+    return "The global npm installation directory is not writable.";
+  }
+  if (result.cause === "timeout") {
+    return "The npm or Skills download timed out.";
+  }
+  if (result.cause === "network") {
+    return "The npm registry or Skills source could not be reached.";
+  }
+  if (result.cause === "package_missing") {
+    return "The required CLI package or Skills tag is not available.";
+  }
+  if (result.cause === "validation") {
+    return "The installed package could not be validated.";
+  }
+  return `Version synchronization failed at ${result.stage}.`;
+}
+function commandSucceeded(result) {
+  return !result.error && result.status === 0;
+}
+function acquireInstallLock(now) {
+  fs.mkdirSync(getConfigDir(), { recursive: true });
+  const file = syncLockPath();
+  try {
+    return fs.openSync(file, "wx");
+  } catch {
+    try {
+      const age = now.getTime() - fs.statSync(file).mtimeMs;
+      if (age >= LOCK_STALE_MS) {
+        fs.unlinkSync(file);
+        return fs.openSync(file, "wx");
+      }
+    } catch {
+      try {
+        return fs.openSync(file, "wx");
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+}
+function releaseInstallLock(fd) {
+  try {
+    fs.closeSync(fd);
+  } catch {
+  }
+  try {
+    fs.unlinkSync(syncLockPath());
+  } catch {
+  }
+}
+function validateInstalledPackage(npm, target, runner) {
+  const rootResult = runner(npm, ["root", "-g"], COMMAND_TIMEOUT_MS);
+  if (!commandSucceeded(rootResult)) {
+    return { ok: false, message: resultMessage(rootResult) };
+  }
+  const globalRoot = rootResult.stdout.trim();
+  const packageRoot = path.join(globalRoot, "@thinkingai", "ae-cli");
+  const packageJson = path.join(packageRoot, "package.json");
+  const skillsPath = path.join(packageRoot, "skills");
+  try {
+    const installed = JSON.parse(fs.readFileSync(packageJson, "utf8"));
+    if (normalizeCliVersion(installed.version || "") !== target) {
+      return {
+        ok: false,
+        message: `Installed package version ${installed.version || "unknown"} does not match ${target}`
+      };
+    }
+    if (!fs.statSync(skillsPath).isDirectory()) {
+      return { ok: false, message: `Installed package has no skills directory: ${skillsPath}` };
+    }
+    return { ok: true, skillsPath };
+  } catch (error) {
+    return { ok: false, message: error?.message || String(error) };
+  }
+}
+function installVersion(targetRaw, options = {}) {
+  const target = normalizeCliVersion(targetRaw);
+  const runner = options.runner ?? defaultRunner;
+  const progress = options.progress ?? (() => {
+  });
+  const npm = resolveNodeTool("npm");
+  const npx = resolveNodeTool("npx");
+  const lock = acquireInstallLock(options.now ?? /* @__PURE__ */ new Date());
+  if (lock === null) {
+    return {
+      ok: false,
+      stage: "lock",
+      cliInstalled: false,
+      skillsPending: Boolean(options.skipCliInstall),
+      cause: "busy",
+      message: "Another ae-cli process is already synchronizing the global installation."
+    };
+  }
+  let cliInstalled = Boolean(options.skipCliInstall);
+  try {
+    if (!options.skipCliInstall) {
+      progress(`[ae-cli] [1/2] Installing ae-cli ${target}...`);
+      const npmResult = runner(
+        npm,
+        ["install", "-g", `${OPEN_SOURCE_AE_CLI_PACKAGE}@${target}`],
+        COMMAND_TIMEOUT_MS
+      );
+      if (!commandSucceeded(npmResult)) {
+        return {
+          ok: false,
+          stage: "npm_install",
+          cliInstalled: false,
+          skillsPending: false,
+          cause: classifyFailure(npmResult),
+          message: resultMessage(npmResult)
+        };
+      }
+      cliInstalled = true;
+    }
+    const installed = validateInstalledPackage(npm, target, runner);
+    if (!installed.ok) {
+      return {
+        ok: false,
+        stage: "package_validation",
+        cliInstalled,
+        skillsPending: cliInstalled,
+        cause: "validation",
+        message: installed.message
+      };
+    }
+    progress("[ae-cli] [2/2] Synchronizing Skills from the installed npm package...");
+    const localResult = runner(
+      npx,
+      ["-y", "skills", "add", installed.skillsPath, "-g", "-y"],
+      COMMAND_TIMEOUT_MS
+    );
+    if (commandSucceeded(localResult)) {
+      return { ok: true, cliInstalled, skillsSource: "local" };
+    }
+    progress("[ae-cli] Local Skills sync did not complete; trying the GitHub fallback...");
+    const githubResult = runner(
+      npx,
+      ["-y", "skills", "add", `${AE_CLI_SKILLS_REPO}#v${target}`, "-g", "-y"],
+      COMMAND_TIMEOUT_MS
+    );
+    if (commandSucceeded(githubResult)) {
+      return { ok: true, cliInstalled, skillsSource: "github" };
+    }
+    return {
+      ok: false,
+      stage: "skills_github",
+      cliInstalled,
+      skillsPending: cliInstalled,
+      cause: classifyFailure(githubResult),
+      message: resultMessage(githubResult) || resultMessage(localResult)
+    };
+  } finally {
+    releaseInstallLock(lock);
+  }
+}
+function autoSyncDirection(current, expected) {
+  if (versionLine(current) !== versionLine(expected)) return "switch";
+  const currentParts = normalizeCliVersion(current).split("-")[0].split(".").map(Number);
+  const expectedParts = normalizeCliVersion(expected).split("-")[0].split(".").map(Number);
+  for (let i = 0; i < Math.max(currentParts.length, expectedParts.length, 3); i += 1) {
+    const local = currentParts[i] ?? 0;
+    const target = expectedParts[i] ?? 0;
+    if (local < target) return "upgrade";
+    if (local > target) return "downgrade";
+  }
+  return "switch";
+}
+
+// src/core/compat-check.ts
+import fs2 from "fs";
+import path2 from "path";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+var CLI_CONFIG_PATH = "/v1/ta/cli/config";
+function cacheFilePath() {
+  return path2.join(getConfigDir(), "compat-check.json");
+}
+function readStore() {
+  try {
+    const file = cacheFilePath();
+    if (!fs2.existsSync(file)) return { hosts: {} };
+    const raw = JSON.parse(fs2.readFileSync(file, "utf8"));
+    if (!raw || typeof raw !== "object" || !raw.hosts) return { hosts: {} };
+    return raw;
+  } catch {
+    return { hosts: {} };
+  }
+}
+function writeStore(store) {
+  try {
+    const dir = getConfigDir();
+    if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
+    fs2.writeFileSync(cacheFilePath(), JSON.stringify(store, null, 2));
+  } catch {
+  }
+}
+function hostKey(host) {
+  return normalizeUrl(host);
+}
+function isStale(entry) {
+  if (!entry?.lastFetchedAt) return true;
+  const age = Date.now() - new Date(entry.lastFetchedAt).getTime();
+  return age >= CHECK_INTERVAL_MS;
+}
+function shouldNotify(entry) {
+  if (!entry?.lastNotifiedAt) return true;
+  const age = Date.now() - new Date(entry.lastNotifiedAt).getTime();
+  return age >= CHECK_INTERVAL_MS;
+}
+function shouldSkipCompatCheck(argv = process.argv) {
+  if (process.env.AE_CLI_NO_COMPAT_CHECK === "1") return true;
+  if (isAeSandboxRuntime()) return true;
+  return shouldSkipUpdateCheck(argv);
+}
+function rootCommand(argv) {
+  const args = argv.slice(2);
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (token === "--") return void 0;
+    if (token.startsWith("-")) {
+      if (!token.includes("=") && ["--host", "--mcp-url", "--format", "--jq"].includes(token)) {
+        i += 1;
+      }
+      continue;
+    }
+    return token;
+  }
+  return void 0;
+}
+function shouldSkipAutoSync(argv = process.argv) {
+  const command = rootCommand(argv);
+  return command === "update" || command === "auth" || command === "config";
+}
+async function fetchCliConfig(host, cliToken) {
+  const url = new URL(CLI_CONFIG_PATH, host.endsWith("/") ? host : `${host}/`);
+  url.searchParams.set("cli-token", cliToken);
+  const headers = { Accept: "application/json" };
+  try {
+    const accessToken = await getToken(host);
+    if (accessToken) {
+      headers.Authorization = `bearer ${accessToken}`;
+    }
+  } catch {
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const resp = await fetch(url.toString(), {
+      signal: controller.signal,
+      headers
+    });
+    if (!resp.ok) return null;
+    const body = await resp.json();
+    const data = body.data ?? body;
+    const versions = data.versions;
+    if (!versions) return null;
+    const clusterVersion = versions.clusterVersion ?? versions.cluster_version ?? null;
+    const aeCliVersion = versions.aeCliVersion ?? versions.ae_cli_version ?? null;
+    return {
+      clusterVersion: clusterVersion?.trim() || null,
+      aeCliVersion: aeCliVersion?.trim() || null
+    };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function printNotice(text) {
+  process.stderr.write(`${text}
+`);
+}
+var pendingHostCompatNotice;
+var pendingUpdateNotice;
+function getPendingHostCompatNotice() {
+  return pendingHostCompatNotice;
+}
+function getPendingUpdateNotice() {
+  return pendingUpdateNotice;
+}
+function getCachedCompatForHost(host) {
+  return readStore().hosts[hostKey(host)];
+}
+function formatCapabilityMissCompatHint(host) {
+  if (shouldSkipCompatCheck()) return void 0;
+  const active = host || getActiveHost();
+  if (!active) {
+    return "This capability may be missing on the current private cluster. Update cluster components to the latest version, or pin this machine to the environment ae-cli version.";
+  }
+  const cached = getCachedCompatForHost(active);
+  if (cached?.expectedVersion) {
+    const pins = formatPinCommands(cached.expectedVersion);
+    if (pins.length > 0) {
+      return [
+        `Host may be older than this CLI (environment ae-cli ${cached.expectedVersion}, cluster ${cached.clusterVersion || "?"}).`,
+        `Update cluster components to the latest version, or pin locally:`,
+        ...pins.map((c) => `  ${c}`)
+      ].join("\n");
+    }
+    return [
+      `Host may be older than this CLI (environment ae-cli ${cached.expectedVersion}, cluster ${cached.clusterVersion || "?"}).`,
+      `No public GitHub/npm release matches that environment version; update cluster components to the latest version instead of pinning.`
+    ].join("\n");
+  }
+  return "This capability may be missing on the current private cluster. Update cluster components to the latest version, or pin this machine CLI + skills to the environment version (see ae-cli host compat notices after auth login).";
+}
+function setUpdateNotice(pkg, expected, cluster, verdict, state, stage, message) {
+  pendingHostCompatNotice = void 0;
+  pendingUpdateNotice = {
+    command: "ae-cli update",
+    current: pkg.version,
+    expected,
+    cluster,
+    reason: verdict.kind === "ok" && state === "skills_pending" ? "skills_pending" : verdict.kind,
+    state,
+    ...stage ? { stage } : {},
+    message: message ?? `Current ae-cli is ${pkg.version}; this host requires ${expected}. Run: ae-cli update`
+  };
+}
+async function refreshAndMaybeNotify(host, pkg, allowAutoSync) {
+  const token = peekCliToken(host);
+  if (!token) return { status: "continue" };
+  const store = readStore();
+  const key = hostKey(host);
+  const existing = store.hosts[key];
+  let expected = existing?.expectedVersion;
+  let cluster = existing?.clusterVersion;
+  let fetchedAt = existing?.lastFetchedAt;
+  if (isStale(existing)) {
+    const remote = await fetchCliConfig(host, token);
+    if (!remote?.aeCliVersion) {
+      return { status: "continue" };
+    }
+    expected = remote.aeCliVersion;
+    cluster = remote.clusterVersion ?? "";
+    fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+    store.hosts[key] = {
+      host: key,
+      localVersion: pkg.version,
+      expectedVersion: expected,
+      clusterVersion: cluster,
+      lastFetchedAt: fetchedAt,
+      lastNotifiedAt: existing?.lastNotifiedAt
+    };
+    writeStore(store);
+  }
+  if (!expected) return { status: "continue" };
+  let verdict = evaluateCompat(pkg.version, expected, cluster);
+  let pendingSkills = getPendingSkillsTarget(host) === expected;
+  if (verdict.kind === "ok" && !pendingSkills) {
+    pendingHostCompatNotice = void 0;
+    pendingUpdateNotice = void 0;
+    return { status: "continue" };
+  }
+  let entry = store.hosts[key] ?? {
+    host: key,
+    localVersion: pkg.version,
+    expectedVersion: expected,
+    clusterVersion: cluster || "",
+    lastFetchedAt: fetchedAt || (/* @__PURE__ */ new Date()).toISOString()
+  };
+  entry.localVersion = pkg.version;
+  entry.expectedVersion = expected;
+  entry.clusterVersion = cluster || entry.clusterVersion;
+  const canAutoSync = allowAutoSync && isPublicAeCliPackage(pkg.name) && isAutoSyncTargetEligible(expected);
+  if (canAutoSync) {
+    const confirmed = await fetchCliConfig(host, token);
+    if (confirmed?.aeCliVersion) {
+      expected = confirmed.aeCliVersion;
+      cluster = confirmed.clusterVersion ?? cluster ?? "";
+      verdict = evaluateCompat(pkg.version, expected, cluster);
+      pendingSkills = getPendingSkillsTarget(host) === expected;
+      entry = {
+        ...entry,
+        localVersion: pkg.version,
+        expectedVersion: expected,
+        clusterVersion: cluster || "",
+        lastFetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      store.hosts[key] = entry;
+      writeStore(store);
+      if (verdict.kind === "ok" && !pendingSkills) {
+        pendingHostCompatNotice = void 0;
+        pendingUpdateNotice = void 0;
+        return { status: "continue" };
+      }
+      if (isAutoSyncTargetEligible(expected)) {
+        const attempt = reserveAutoAttempt(host, expected);
+        if (attempt.allowed) {
+          const direction = verdict.kind === "ok" && pendingSkills ? "skills" : autoSyncDirection(pkg.version, expected);
+          const verb = direction === "upgrade" ? "upgrading" : direction === "downgrade" ? "downgrading" : direction === "skills" ? "repairing" : "switching";
+          printNotice(
+            `[ae-cli] Current version ${pkg.version}; this host requires ${expected}. Automatically ${verb} CLI and Skills, please wait...`
+          );
+          const result = installVersion(expected, {
+            skipCliInstall: verdict.kind === "ok" && pendingSkills,
+            progress: printNotice
+          });
+          recordVersionSyncResult(host, expected, result);
+          if (result.ok) {
+            printNotice(
+              `[ae-cli] Synchronized to ${expected}. Re-run the previous command to use the new version.`
+            );
+            pendingHostCompatNotice = void 0;
+            pendingUpdateNotice = void 0;
+            return {
+              status: "synced",
+              current: pkg.version,
+              expected,
+              cluster: cluster || "",
+              direction
+            };
+          }
+          const state = result.skillsPending ? "skills_pending" : "auto_sync_failed";
+          const friendlyCause = friendlyVersionSyncFailure(result);
+          const failure = result.skillsPending ? `CLI switched to ${expected}, but Skills synchronization failed. ${friendlyCause} This command will continue; run ae-cli update after access is restored.` : `${friendlyCause} This command will continue; run ae-cli update after fixing access.`;
+          printNotice(`[ae-cli] ${failure}`);
+          setUpdateNotice(pkg, expected, cluster || "", verdict, state, result.stage, failure);
+          entry.lastNotifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+          store.hosts[key] = entry;
+          writeStore(store);
+          return { status: "continue" };
+        }
+      }
+    }
+  }
+  const notice = verdict.kind === "ok" && pendingSkills ? `[ae-cli] CLI ${expected} is installed, but its Skills are not synchronized.
+         Run: ae-cli update` : formatCompatNotice(verdict);
+  if (!notice) return { status: "continue" };
+  const dueForTip = shouldNotify(entry);
+  if (!dueForTip) {
+    pendingHostCompatNotice = void 0;
+    pendingUpdateNotice = void 0;
+    store.hosts[key] = entry;
+    writeStore(store);
+    return { status: "continue" };
+  }
+  setUpdateNotice(
+    pkg,
+    expected,
+    cluster || "",
+    verdict,
+    pendingSkills ? "skills_pending" : "prompt_only",
+    void 0,
+    pendingSkills ? `Skills for ae-cli ${expected} are not synchronized. Run: ae-cli update` : void 0
+  );
+  printNotice(notice);
+  entry.lastNotifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+  store.hosts[key] = entry;
+  writeStore(store);
+  return { status: "continue" };
+}
+async function runHostCompatCheck(pkg, hostOverride, argv = process.argv) {
+  pendingHostCompatNotice = void 0;
+  pendingUpdateNotice = void 0;
+  if (shouldSkipCompatCheck(argv)) return { status: "continue" };
+  const host = hostOverride || getActiveHost();
+  if (!host) return { status: "continue" };
+  try {
+    return await refreshAndMaybeNotify(host, pkg, !shouldSkipAutoSync(argv));
+  } catch {
+    return { status: "continue" };
+  }
+}
+
+// src/framework/output.ts
+import Table from "cli-table3";
+import { JqError, json as jqJson } from "jq-wasm";
+var KNOWN_ARRAY_FIELDS = [
+  "items",
+  "events",
+  "reports",
+  "dashboards",
+  "tags",
+  "clusters",
+  "flows",
+  "tasks",
+  "channels",
+  "nodes",
+  "members",
+  "records",
+  "entities",
+  "metrics",
+  "tables",
+  "columns",
+  "properties"
+];
+var OUTPUT_METADATA = /* @__PURE__ */ Symbol("ae-cli-output-metadata");
+function withOutputMetadata(data, meta) {
+  if (!meta || Object.keys(meta).length === 0) return data;
+  return {
+    [OUTPUT_METADATA]: true,
+    data,
+    meta
+  };
+}
+function isOutputWithMetadata(value) {
+  return Boolean(value?.[OUTPUT_METADATA]);
+}
+function findArrayField(data) {
+  if (Array.isArray(data)) return data;
+  if (typeof data !== "object" || data === null) return null;
+  for (const key of KNOWN_ARRAY_FIELDS) {
+    if (Array.isArray(data[key])) return data[key];
+  }
+  for (const key of Object.keys(data)) {
+    if (Array.isArray(data[key])) return data[key];
+  }
+  return null;
+}
+function formatTable(data) {
+  const rows = findArrayField(data);
+  if (!rows || rows.length === 0) {
+    return JSON.stringify(data, null, 2);
+  }
+  const allKeys = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (typeof row === "object" && row !== null) {
+      Object.keys(row).forEach((k) => allKeys.add(k));
+    }
+  }
+  const keys = Array.from(allKeys);
+  if (keys.length === 0) return JSON.stringify(rows, null, 2);
+  const table = new Table({ head: keys, wordWrap: true });
+  for (const row of rows) {
+    table.push(keys.map((k) => {
+      const v = row?.[k];
+      if (v === void 0 || v === null) return "";
+      if (typeof v === "object") return JSON.stringify(v);
+      return String(v);
+    }));
+  }
+  return table.toString();
+}
+async function applyJq(data, expr) {
+  const trimmed = expr.trim();
+  if (!trimmed) return data;
+  let results;
+  try {
+    results = await jqJson(data, trimmed);
+  } catch (err) {
+    const message = err instanceof JqError ? err.message : err?.message || String(err);
+    const error = new Error(`Invalid --jq expression: ${message}`);
+    error.type = "validation";
+    error.hint = "Use standard jq syntax, e.g. .status or {status,pendingQuestion}";
+    throw error;
+  }
+  if (results.length === 0) return null;
+  if (results.length === 1) return results[0];
+  return results;
+}
+async function formatOutput(data, format, jqExpr) {
+  const outputData = isOutputWithMetadata(data) ? data.data : data;
+  const meta = isOutputWithMetadata(data) ? data.meta : void 0;
+  let processed = outputData;
+  if (jqExpr) {
+    processed = await applyJq(outputData, jqExpr);
+  }
+  if (format === "table") {
+    return formatTable(processed);
+  }
+  const hostCompat = getPendingHostCompatNotice();
+  const updateNotice = getPendingUpdateNotice();
+  const notices = {
+    ...updateNotice ? {} : hostCompat ? { host_compat: hostCompat } : {},
+    ...updateNotice ? { update: updateNotice } : {}
+  };
+  const envelope = {
+    ok: true,
+    data: processed,
+    ...meta ? { meta } : {},
+    // Soft tip lives only under _notice (not mirrored into meta) to avoid duplicate fields.
+    ...Object.keys(notices).length > 0 ? { _notice: notices } : {}
+  };
+  return JSON.stringify(envelope, null, 2);
+}
+function formatError(type, message, hint, code, meta) {
+  const envelope = {
+    ok: false,
+    error: { type, message, hint, code },
+    ...meta && Object.keys(meta).length > 0 ? { meta } : {}
+  };
+  return JSON.stringify(envelope, null, 2);
+}
+function printError(type, message, hint, code, meta, options = {}) {
+  const formatted = formatError(type, message, hint, code, meta);
+  process.stderr.write(formatted + "\n");
+  if (options.log !== false) {
+    logger.error(`[${type}] ${message}${hint ? " | " + hint : ""}`);
+  }
+}
+async function printOutput(data, format, jqExpr) {
+  process.stdout.write(await formatOutput(data, format, jqExpr) + "\n");
+}
+
+export {
+  recordVersionSyncResult,
+  buildVersionInstallPlan,
+  friendlyVersionSyncFailure,
+  installVersion,
+  fetchCliConfig,
+  getCachedCompatForHost,
+  formatCapabilityMissCompatHint,
+  runHostCompatCheck,
+  withOutputMetadata,
+  printError,
+  printOutput
+};