@thinkingai/ae-cli 6.0.31 → 6.0.33

package/dist/chunk-IMMGMU54.js

@@ -0,0 +1,674 @@
+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/update-check.ts
+import fs from "fs";
+import path from "path";
+var CONFIG_DIR = path.join(process.env.HOME || "", ".ae-cli");
+var CACHE_FILE = path.join(CONFIG_DIR, "update-check.json");
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+var REGISTRY_BY_PACKAGE = {
+  "@thinkingai/ae-cli": "https://registry.npmjs.org"
+};
+var UPDATE_CHECK_PACKAGE = "@thinkingai/ae-cli";
+function isUpdateCheckEnabled(packageName) {
+  return packageName === UPDATE_CHECK_PACKAGE;
+}
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+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;
+}
+function resolveRegistry(packageName) {
+  if (REGISTRY_BY_PACKAGE[packageName]) {
+    return REGISTRY_BY_PACKAGE[packageName];
+  }
+  const envRegistry = process.env.npm_config_registry?.replace(/\/$/, "");
+  return envRegistry || DEFAULT_REGISTRY;
+}
+function buildInstallCommand(packageName, registry) {
+  const base = `npm install -g ${packageName}@latest`;
+  if (registry === DEFAULT_REGISTRY) {
+    return base;
+  }
+  return `${base} --registry=${registry}`;
+}
+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 ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function readCache() {
+  try {
+    if (!fs.existsSync(CACHE_FILE)) return null;
+    const raw = fs.readFileSync(CACHE_FILE, "utf8");
+    const data = JSON.parse(raw);
+    if (!data.packageName || !data.latestVersion || !data.lastCheckedAt) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    ensureConfigDir();
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
+  } catch {
+  }
+}
+function cacheIsStale(cache, packageName) {
+  if (!cache || cache.packageName !== packageName) return true;
+  const age = Date.now() - new Date(cache.lastCheckedAt).getTime();
+  return age >= CHECK_INTERVAL_MS;
+}
+function printUpdateNotice(current, latest, installCommand) {
+  process.stderr.write(`[ae-cli] Update available: ${current} \u2192 ${latest}
+`);
+  process.stderr.write(`         Run: ${installCommand}
+`);
+}
+async function fetchLatestVersion(packageName, registry) {
+  const url = `${registry.replace(/\/$/, "")}/${encodeURIComponent(packageName)}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const resp = await fetch(url, {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    if (!resp.ok) return null;
+    const data = await resp.json();
+    const latest = data["dist-tags"]?.latest;
+    return typeof latest === "string" && latest.trim() ? latest.trim() : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function refreshCache(pkg, registry) {
+  const latest = await fetchLatestVersion(pkg.name, registry);
+  if (!latest) return readCache();
+  const cache = {
+    packageName: pkg.name,
+    currentVersion: pkg.version,
+    latestVersion: latest,
+    lastCheckedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeCache(cache);
+  return cache;
+}
+function maybeNotifyFromCache(pkg, cache, registry) {
+  if (!cache || cache.packageName !== pkg.name) return;
+  if (!isNewer(cache.latestVersion, pkg.version)) return;
+  printUpdateNotice(pkg.version, cache.latestVersion, buildInstallCommand(pkg.name, registry));
+}
+function notifyIfUpdateAvailable(pkg) {
+  if (!isUpdateCheckEnabled(pkg.name)) return;
+  if (shouldSkipUpdateCheck()) return;
+  const registry = resolveRegistry(pkg.name);
+  const cache = readCache();
+  maybeNotifyFromCache(pkg, cache, registry);
+  if (!cacheIsStale(cache, pkg.name)) return;
+  void refreshCache(pkg, registry).then((fresh) => {
+    if (!fresh) return;
+    if (cache && fresh.latestVersion === cache.latestVersion) return;
+    maybeNotifyFromCache(pkg, fresh, registry);
+  });
+}
+
+// src/core/compat-check.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// 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 formatCompatNotice(verdict) {
+  if (verdict.kind === "ok") return void 0;
+  const pinTarget = resolvePinTarget(verdict.expected);
+  const pins = formatPinCommands(verdict.expected);
+  const pinBlock = pins.map((c) => `           ${c}`).join("\n");
+  const pinNote = pinTarget && pinTarget !== verdict.expected ? `         (historical match: public ${pinTarget} for cluster ${verdict.expected}; GitHub usually published later)` : void 0;
+  if (verdict.kind === "local_newer") {
+    if (pins.length > 0) {
+      return [
+        `[ae-cli] Host compat: local ${verdict.local} > environment ${verdict.expected} (cluster ${verdict.line}).`,
+        `         Pin CLI + skills to the matched public release:`,
+        pinBlock,
+        ...pinNote ? [pinNote] : [],
+        `         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") {
+    const upgrades = formatUpgradeCommands(verdict.expected);
+    if (upgrades.length > 0) {
+      return [
+        `[ae-cli] Host compat: local ${verdict.local} < environment ${verdict.expected} (cluster ${verdict.line}).`,
+        `         Upgrade CLI + skills to the environment version:`,
+        ...upgrades.map((c) => `           ${c}`)
+      ].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 (pins.length > 0) {
+    return [
+      `[ae-cli] Host compat: local ${verdict.local} line mismatches environment ${verdict.expected} (cluster ${verdict.line}).`,
+      `         Switch to the matched public release (CLI + skills):`,
+      pinBlock,
+      ...pinNote ? [pinNote] : [],
+      `         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/compat-check.ts
+var CHECK_INTERVAL_MS2 = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS2 = 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_MS2;
+}
+function shouldNotify(entry) {
+  if (!entry?.lastNotifiedAt) return true;
+  const age = Date.now() - new Date(entry.lastNotifiedAt).getTime();
+  return age >= CHECK_INTERVAL_MS2;
+}
+function shouldSkipCompatCheck(argv = process.argv) {
+  if (process.env.AE_CLI_NO_COMPAT_CHECK === "1") return true;
+  if (isAeSandboxRuntime()) return true;
+  return shouldSkipUpdateCheck(argv);
+}
+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_MS2);
+  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}
+`);
+}
+function isNonInteractiveOutput() {
+  return !process.stdout.isTTY || !process.stderr.isTTY;
+}
+var pendingHostCompatNotice;
+function getPendingHostCompatNotice() {
+  return pendingHostCompatNotice;
+}
+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).";
+}
+async function refreshAndMaybeNotify(host, pkg) {
+  const token = peekCliToken(host);
+  if (!token) return;
+  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;
+    }
+    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;
+  const verdict = evaluateCompat(pkg.version, expected, cluster);
+  const notice = formatCompatNotice(verdict);
+  if (!notice) {
+    pendingHostCompatNotice = void 0;
+    return;
+  }
+  pendingHostCompatNotice = notice;
+  const entry = store.hosts[key] ?? {
+    host: key,
+    localVersion: pkg.version,
+    expectedVersion: expected,
+    clusterVersion: cluster || "",
+    lastFetchedAt: fetchedAt || (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const dueForHumanTip = shouldNotify(entry);
+  if (!dueForHumanTip && !isNonInteractiveOutput()) return;
+  printNotice(notice);
+  if (dueForHumanTip) {
+    entry.lastNotifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  entry.localVersion = pkg.version;
+  entry.expectedVersion = expected;
+  entry.clusterVersion = cluster || entry.clusterVersion;
+  store.hosts[key] = entry;
+  writeStore(store);
+}
+async function runHostCompatCheck(pkg, hostOverride) {
+  if (shouldSkipCompatCheck()) return;
+  const host = hostOverride || getActiveHost();
+  if (!host) return;
+  try {
+    await refreshAndMaybeNotify(host, pkg);
+  } catch {
+  }
+}
+
+// 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 envelope = {
+    ok: true,
+    data: processed,
+    ...meta ? { meta } : {},
+    // Soft tip lives only under _notice (not mirrored into meta) to avoid duplicate fields.
+    ...hostCompat ? { _notice: { host_compat: hostCompat } } : {}
+  };
+  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");
+  const hostCompat = getPendingHostCompatNotice();
+  if (hostCompat && (!process.stdout.isTTY || !process.stderr.isTTY)) {
+    process.stderr.write(`${hostCompat}
+`);
+  }
+}
+
+export {
+  notifyIfUpdateAvailable,
+  formatCapabilityMissCompatHint,
+  runHostCompatCheck,
+  withOutputMetadata,
+  printError,
+  printOutput
+};

package/dist/{chunk-AJTH7LT3.js → chunk-IR4ZLVPW.js}

@@ -1,10 +1,12 @@
 import {
   getActiveHost,
   getConfigDir,
-  logger,
   normalizeUrl,
   safeJsonParse
-} from "./chunk-YCLVYFK7.js";
+} from "./chunk-V6FR6WTW.js";
+import {
+  logger
+} from "./chunk-LYVNONC4.js";
 
 // src/core/secure-store.ts
 import crypto from "crypto";