@growthub/cli 0.3.55 → 0.3.57

package/assets/worker-kits/growthub-zernio-social-v1/setup/install-mcp.mjs

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+// install-mcp.mjs — print the per-IDE Zernio MCP server config JSON
+//
+// This is a print-only helper. It does NOT run `pip install zernio-sdk[mcp]`
+// for you, and it does NOT mutate any config file. It prints the exact
+// copy-paste JSON blocks you need to wire Zernio's official MCP server into
+// each MCP-compatible IDE.
+//
+// Cross-platform (macOS, Linux, Windows). Pure Node stdlib — no deps.
+//
+// Usage:
+//   node setup/install-mcp.mjs                 # print all IDE configs
+//   node setup/install-mcp.mjs claude-desktop  # one IDE only
+//   node setup/install-mcp.mjs cursor
+//   node setup/install-mcp.mjs claude-code
+//   node setup/install-mcp.mjs generic
+
+import { platform } from "node:os";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const BLUE = "\x1b[34m";
+const RESET = "\x1b[0m";
+
+const arg = (process.argv[2] ?? "all").toLowerCase();
+const osPlatform = platform();
+
+// ---- Config path hints (cross-platform) ----
+function claudeDesktopConfigPath() {
+  const home = homedir();
+  if (osPlatform === "darwin") return join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  if (osPlatform === "win32") return join(process.env.APPDATA ?? join(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+  return join(home, ".config", "Claude", "claude_desktop_config.json");
+}
+
+function claudeCodeConfigPath() {
+  return join(homedir(), ".claude", "mcp.json");
+}
+
+function cursorConfigPath() {
+  return join(homedir(), ".cursor", "mcp.json");
+}
+
+// ---- MCP server definition ----
+// Zernio's official MCP server ships inside the zernio-python SDK:
+//   pip install zernio-sdk[mcp]
+// The server entrypoint is the Python module. Auth is via ZERNIO_API_KEY env var.
+const ZERNIO_MCP_BLOCK = {
+  command: "python",
+  args: ["-m", "zernio.mcp"],
+  env: {
+    ZERNIO_API_KEY: "${ZERNIO_API_KEY}",
+  },
+};
+
+function header(label) {
+  console.log("");
+  console.log(`${BOLD}${BLUE}${label}${RESET}`);
+  console.log("-".repeat(Math.max(24, label.length)));
+}
+
+function note(msg) {
+  console.log(`${DIM}${msg}${RESET}`);
+}
+
+function codeBlock(obj) {
+  console.log("```json");
+  console.log(JSON.stringify(obj, null, 2));
+  console.log("```");
+}
+
+function printPreamble() {
+  console.log("");
+  console.log(`${BOLD}Zernio MCP Server — per-IDE config${RESET}`);
+  note(`host: ${osPlatform}  ·  pre-req: pip install zernio-sdk[mcp]  ·  env: ZERNIO_API_KEY`);
+  console.log("");
+  console.log(`${GREEN}1.${RESET} Install Zernio's MCP server (one-time):`);
+  console.log(`   ${BOLD}pip install zernio-sdk[mcp]${RESET}`);
+  console.log("");
+  console.log(`${GREEN}2.${RESET} Ensure ZERNIO_API_KEY is set in your shell profile (or pass it via the IDE):`);
+  if (osPlatform === "win32") {
+    console.log(`   ${DIM}setx ZERNIO_API_KEY "sk_..."${RESET}                  ${DIM}# PowerShell, persistent${RESET}`);
+  } else {
+    console.log(`   ${DIM}echo 'export ZERNIO_API_KEY="sk_..."' >> ~/.zshrc${RESET}    ${DIM}# or ~/.bashrc${RESET}`);
+  }
+  console.log("");
+  console.log(`${GREEN}3.${RESET} Paste one of the JSON blocks below into the matching IDE's MCP config.`);
+  console.log("");
+}
+
+function printClaudeDesktop() {
+  header("Claude Desktop");
+  note(`Config file: ${claudeDesktopConfigPath()}`);
+  console.log(`Add the ${BOLD}zernio${RESET} server under the top-level ${BOLD}mcpServers${RESET} object:`);
+  console.log("");
+  codeBlock({
+    mcpServers: {
+      zernio: ZERNIO_MCP_BLOCK,
+    },
+  });
+  console.log(`${YELLOW}Restart Claude Desktop${RESET} after editing the config.`);
+}
+
+function printClaudeCode() {
+  header("Claude Code");
+  note(`Config file: ${claudeCodeConfigPath()}`);
+  console.log(`Add to ${BOLD}.claude/mcp.json${RESET} (or use ${BOLD}claude mcp add${RESET}):`);
+  console.log("");
+  codeBlock({
+    mcpServers: {
+      zernio: ZERNIO_MCP_BLOCK,
+    },
+  });
+  console.log(`Alternative one-liner:`);
+  console.log(`  ${BOLD}claude mcp add zernio -- python -m zernio.mcp${RESET}`);
+}
+
+function printCursor() {
+  header("Cursor");
+  note(`Config file: ${cursorConfigPath()}`);
+  console.log(`Add the ${BOLD}zernio${RESET} entry under the top-level ${BOLD}mcpServers${RESET} object:`);
+  console.log("");
+  codeBlock({
+    mcpServers: {
+      zernio: ZERNIO_MCP_BLOCK,
+    },
+  });
+  console.log(`${YELLOW}Restart Cursor${RESET} after editing the config.`);
+}
+
+function printGeneric() {
+  header("Generic MCP-compatible IDE");
+  note("Use this shape for any IDE that speaks MCP (Codex-mcp, n8n MCP nodes, custom clients).");
+  console.log("");
+  codeBlock({
+    mcpServers: {
+      zernio: ZERNIO_MCP_BLOCK,
+    },
+  });
+  console.log("Adjust the top-level key if your IDE uses a different name (e.g. `servers` vs `mcpServers`).");
+}
+
+function printFooter() {
+  console.log("");
+  header("What this enables");
+  console.log("- The agent can call Zernio endpoints as typed MCP tools instead of raw HTTP.");
+  console.log("- Works alongside this kit's Working Directory pattern — strictly additive.");
+  console.log("- All writes still use Idempotency-Key = clientPostId for safe re-submission.");
+  console.log("- See docs/local-adapters.md for the full matrix of supported IDEs.");
+  console.log("");
+  console.log(`${DIM}Zernio's MCP server lives in the zernio-python SDK:${RESET}`);
+  console.log(`  ${DIM}https://github.com/zernio-dev/zernio-python${RESET}`);
+  console.log("");
+}
+
+// ---- Dispatch ----
+printPreamble();
+
+switch (arg) {
+  case "claude-desktop": printClaudeDesktop(); break;
+  case "claude-code": printClaudeCode(); break;
+  case "cursor": printCursor(); break;
+  case "generic": printGeneric(); break;
+  case "all":
+  default:
+    printClaudeDesktop();
+    printClaudeCode();
+    printCursor();
+    printGeneric();
+    break;
+}
+
+printFooter();

package/assets/worker-kits/growthub-zernio-social-v1/setup/setup.mjs

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+// setup.mjs — one-command cross-platform bootstrap for the Zernio Social Media Studio
+//
+// Works identically on macOS, Linux, and Windows (PowerShell, cmd, WSL, git-bash).
+// Usage:
+//   node setup/setup.mjs                      # full bootstrap (deps + env + verify)
+//   node setup/setup.mjs --skip-deps          # skip dependency check
+//   node setup/setup.mjs --skip-verify        # skip live API reachability check
+//   node setup/setup.mjs --yes                # no-prompt mode (CI-safe)
+//
+// What it does (in order):
+//   1. Prints the kit banner and detects the host OS.
+//   2. Runs the cross-platform dependency check (Node 18+, curl optional, git optional).
+//   3. If .env is missing, copies .env.example to .env verbatim.
+//   4. Runs verify-env.mjs to confirm ZERNIO_API_KEY format + reachability.
+//   5. Prints the exact next step for the user's OS.
+//
+// No external dependencies. Pure Node stdlib only.
+
+import { existsSync, copyFileSync, readFileSync, statSync } from "node:fs";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import { platform, release } from "node:os";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const KIT_ROOT = resolve(__dirname, "..");
+
+const argv = new Set(process.argv.slice(2));
+const SKIP_DEPS = argv.has("--skip-deps");
+const SKIP_VERIFY = argv.has("--skip-verify");
+const YES = argv.has("--yes");
+
+const RED = "\x1b[31m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const BLUE = "\x1b[34m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+
+function log(msg) { console.log(msg); }
+function step(n, label) { log(""); log(`${BOLD}${BLUE}[${n}/4]${RESET} ${BOLD}${label}${RESET}`); }
+function ok(msg) { log(`  ${GREEN}\u2713${RESET} ${msg}`); }
+function warn(msg) { log(`  ${YELLOW}!${RESET} ${msg}`); }
+function fail(msg) { log(`  ${RED}\u2717${RESET} ${msg}`); }
+
+function detectOs() {
+  const p = platform();
+  if (p === "darwin") return { id: "mac", pretty: "macOS" };
+  if (p === "win32") return { id: "windows", pretty: "Windows" };
+  if (p === "linux") return { id: "linux", pretty: "Linux" };
+  return { id: p, pretty: p };
+}
+
+function run(cmd, args, opts = {}) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(cmd, args, { stdio: "inherit", shell: false, ...opts });
+    child.on("close", (code) => resolvePromise(code ?? 1));
+    child.on("error", () => resolvePromise(1));
+  });
+}
+
+function printBanner(osInfo) {
+  log("");
+  log(`${BOLD}Growthub Zernio Social Media Studio${RESET} \u2014 one-command setup`);
+  log(`${DIM}kit: growthub-zernio-social-v1  \u00b7  host: ${osInfo.pretty} (${platform()} ${release()})  \u00b7  node: ${process.version}${RESET}`);
+  log("");
+}
+
+// ---------------------------------------------------------------------------
+// Step 1 \u2014 Dependency check (cross-platform, node-native)
+// ---------------------------------------------------------------------------
+
+function checkNodeVersion() {
+  const major = Number.parseInt(process.versions.node.split(".")[0], 10);
+  if (!Number.isFinite(major) || major < 18) {
+    fail(`Node.js ${process.version} detected \u2014 Node 18+ required. Install from https://nodejs.org`);
+    return false;
+  }
+  ok(`Node.js ${process.version} (>= 18 required)`);
+  return true;
+}
+
+function which(binary) {
+  // Cross-platform "which": spawn a lookup with proper extension handling.
+  return new Promise((resolvePromise) => {
+    const isWin = platform() === "win32";
+    const lookup = isWin ? "where" : "which";
+    const child = spawn(lookup, [binary], { shell: false });
+    let out = "";
+    child.stdout?.on("data", (d) => (out += String(d)));
+    child.on("close", (code) => resolvePromise(code === 0 ? out.trim().split(/\r?\n/)[0] : null));
+    child.on("error", () => resolvePromise(null));
+  });
+}
+
+async function runDepsCheck() {
+  step(1, "Checking dependencies");
+  if (SKIP_DEPS) {
+    warn("--skip-deps passed \u2014 skipping dependency check");
+    return true;
+  }
+  let allGood = true;
+  if (!checkNodeVersion()) allGood = false;
+
+  const curlPath = await which("curl");
+  if (curlPath) ok(`curl at ${curlPath}`);
+  else warn("curl not found \u2014 not required (Node's built-in fetch is used), but recommended for manual API testing");
+
+  const gitPath = await which("git");
+  if (gitPath) ok(`git at ${gitPath}`);
+  else warn("git not found \u2014 not required for the kit, but recommended for your own project versioning");
+
+  return allGood;
+}
+
+// ---------------------------------------------------------------------------
+// Step 2 \u2014 Ensure .env exists
+// ---------------------------------------------------------------------------
+
+function ensureEnvFile() {
+  step(2, "Ensuring .env is in place");
+  const envPath = join(KIT_ROOT, ".env");
+  const examplePath = join(KIT_ROOT, ".env.example");
+
+  if (existsSync(envPath)) {
+    const size = statSync(envPath).size;
+    ok(`.env already exists (${size} bytes) \u2014 not overwriting`);
+    return { created: false, envPath };
+  }
+
+  if (existsSync(examplePath)) {
+    copyFileSync(examplePath, envPath);
+    ok(`Copied .env.example \u2192 .env`);
+    warn(`Open .env and fill in ZERNIO_API_KEY + ZERNIO_PROFILE_ID before running the operator`);
+    return { created: true, envPath };
+  }
+
+  // No .env.example \u2014 guide the user to create .env directly.
+  warn(".env not found \u2014 create it with your Zernio credentials:");
+  log(`  ${DIM}ZERNIO_API_KEY=sk_<your-64-hex-key>${RESET}`);
+  log(`  ${DIM}ZERNIO_API_URL=https://zernio.com/api/v1${RESET}`);
+  log(`  ${DIM}ZERNIO_PROFILE_ID=<your-profile-id>${RESET}`);
+  log(`  ${DIM}ZERNIO_TIMEZONE=America/New_York  # optional${RESET}`);
+  log(`  ${DIM}ANTHROPIC_API_KEY=sk-ant-...       # optional, for hybrid caption mode${RESET}`);
+  log("");
+  log(`  Skip env entirely for agent-only mode: ${BOLD}node setup/setup.mjs --skip-verify${RESET}`);
+  return { created: false, envPath: null };
+}
+
+// ---------------------------------------------------------------------------
+// Step 3 \u2014 Run verify-env.mjs (same file we already ship)
+// ---------------------------------------------------------------------------
+
+async function runVerifyEnv() {
+  step(3, "Verifying environment (format + reachability)");
+  if (SKIP_VERIFY) {
+    warn("--skip-verify passed \u2014 skipping environment verification");
+    return true;
+  }
+  loadDotEnvInto(process.env);
+  const verifyPath = join(__dirname, "verify-env.mjs");
+  if (!existsSync(verifyPath)) {
+    fail("setup/verify-env.mjs missing \u2014 kit payload is incomplete");
+    return false;
+  }
+  const code = await run(process.execPath, [verifyPath]);
+  // verify-env.mjs returns 0 even on warnings; non-zero only if it crashes
+  return code === 0;
+}
+
+// Minimal inline .env loader \u2014 no dotenv dependency.
+function loadDotEnvInto(target) {
+  const envPath = join(KIT_ROOT, ".env");
+  if (!existsSync(envPath)) return;
+  const raw = readFileSync(envPath, "utf8");
+  for (const rawLine of raw.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq < 0) continue;
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim();
+    if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    if (target[key] === undefined) target[key] = value;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Step 4 \u2014 Print OS-specific next steps
+// ---------------------------------------------------------------------------
+
+function printNextSteps(osInfo, envCreated) {
+  step(4, "Next steps");
+  const open = osInfo.id === "mac" ? "open" : osInfo.id === "windows" ? "start" : "xdg-open";
+  if (envCreated) {
+    log(`  1. Fill in your Zernio key in .env:`);
+    if (osInfo.id === "windows") {
+      log(`       ${DIM}notepad .env${RESET}         (or any editor)`);
+      log(`       ${DIM}code .env${RESET}            (VS Code)`);
+    } else {
+      log(`       ${DIM}${open} .env${RESET}              (system default editor)`);
+      log(`       ${DIM}nano .env${RESET}              (terminal editor)`);
+      log(`       ${DIM}code .env${RESET}              (VS Code)`);
+    }
+    log(`  2. Re-run:  ${BOLD}node setup/setup.mjs${RESET}  to re-verify.`);
+    log(`  3. Then open Claude Code / Codex / Cursor at this folder as the Working Directory.`);
+  } else {
+    log(`  1. Open Claude Code / Codex / Cursor.`);
+    log(`  2. Point the Working Directory at:`);
+    log(`       ${BOLD}${KIT_ROOT}${RESET}`);
+    log(`  3. The ${BOLD}zernio-social-operator${RESET} agent entrypoint is:`);
+    log(`       ${DIM}workers/zernio-social-operator/CLAUDE.md${RESET}`);
+    log(`  4. Try: ${BOLD}"/zernio campaign"${RESET} to run the full 10-step workflow.`);
+  }
+  log("");
+  log(`${DIM}For full setup guidance see QUICKSTART.md. Agent-only mode is always valid \u2014 Zernio reachability does not block planning.${RESET}`);
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const osInfo = detectOs();
+  printBanner(osInfo);
+
+  const depsOk = await runDepsCheck();
+  const envResult = ensureEnvFile();
+  await runVerifyEnv();
+  printNextSteps(osInfo, envResult.created);
+
+  if (!depsOk) {
+    log("");
+    log(`${RED}${BOLD}One or more dependency checks failed. Fix the issues above and re-run.${RESET}`);
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/assets/worker-kits/growthub-zernio-social-v1/setup/verify-env.mjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+// verify-env.mjs — Verify Zernio API key + profile + reachability for the kit
+// Usage: node setup/verify-env.mjs
+
+const RED = "\x1b[31m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RESET = "\x1b[0m";
+
+let allPassed = true;
+const results = [];
+
+function check(label, passed, detail = "") {
+  const icon = passed ? `${GREEN}✓${RESET}` : `${RED}✗${RESET}`;
+  results.push({ label, passed, detail, icon });
+  if (!passed) allPassed = false;
+}
+
+function warn(label, detail = "") {
+  results.push({ label, passed: null, detail, icon: `${YELLOW}⚠${RESET}` });
+}
+
+console.log("Growthub Zernio Social Media Studio — Environment Verification");
+console.log("=".repeat(64));
+console.log("");
+
+// --- Check 1: ZERNIO_API_KEY format ---
+const ZERNIO_KEY_RE = /^sk_[0-9a-fA-F]{64}$/;
+const zernioKey = process.env.ZERNIO_API_KEY;
+let zernioKeyValid = false;
+if (!zernioKey || zernioKey === "your_zernio_api_key_here") {
+  warn("ZERNIO_API_KEY not set", "Set it in .env. Agent-only mode is still available.");
+} else if (!ZERNIO_KEY_RE.test(zernioKey)) {
+  check("ZERNIO_API_KEY format is valid", false, "Key must match sk_ + 64 hex characters");
+} else {
+  check("ZERNIO_API_KEY format is valid", true, zernioKey.slice(0, 8) + "...");
+  zernioKeyValid = true;
+}
+
+// --- Check 2: ZERNIO_API_URL present ---
+const zernioApiUrl = process.env.ZERNIO_API_URL ?? "https://zernio.com/api/v1";
+check("ZERNIO_API_URL is set", Boolean(zernioApiUrl), zernioApiUrl);
+
+// --- Check 3: Zernio API reachable (only if a plausible key exists) ---
+let apiReachable = false;
+if (zernioKeyValid) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    const res = await fetch(`${zernioApiUrl}/profiles`, {
+      signal: controller.signal,
+      headers: { Authorization: `Bearer ${zernioKey}` },
+    });
+    clearTimeout(timeout);
+    apiReachable = res.ok;
+    if (!res.ok) {
+      check("Zernio API accepts the key", false, `HTTP ${res.status} from GET ${zernioApiUrl}/profiles`);
+    } else {
+      check("Zernio API accepts the key", true, `HTTP 200 from GET ${zernioApiUrl}/profiles`);
+    }
+  } catch (err) {
+    check("Zernio API is reachable", false, `Could not reach ${zernioApiUrl} — ${String(err?.message ?? err).slice(0, 120)}`);
+  }
+} else {
+  warn("Zernio API reachability skipped", "No valid ZERNIO_API_KEY — agent-only mode only");
+}
+
+// --- Check 4: ZERNIO_PROFILE_ID ---
+const profileId = process.env.ZERNIO_PROFILE_ID;
+if (!profileId || profileId === "your_zernio_profile_id_here") {
+  warn("ZERNIO_PROFILE_ID not set", "Required for scheduling — find it in the Zernio dashboard or via GET /api/v1/profiles");
+} else if (zernioKeyValid && apiReachable) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    const res = await fetch(`${zernioApiUrl}/profiles/${encodeURIComponent(profileId)}`, {
+      signal: controller.signal,
+      headers: { Authorization: `Bearer ${zernioKey}` },
+    });
+    clearTimeout(timeout);
+    if (res.ok) {
+      check("ZERNIO_PROFILE_ID exists on the account", true, profileId.slice(0, 16) + "...");
+    } else if (res.status === 404) {
+      check("ZERNIO_PROFILE_ID exists on the account", false, "Profile not found for this API key");
+    } else {
+      warn("ZERNIO_PROFILE_ID lookup returned non-2xx", `HTTP ${res.status}`);
+    }
+  } catch (err) {
+    warn("ZERNIO_PROFILE_ID lookup failed", String(err?.message ?? err).slice(0, 120));
+  }
+} else {
+  check("ZERNIO_PROFILE_ID is set", true, "Format check only — API not reached");
+}
+
+// --- Check 5: ZERNIO_TIMEZONE plausibility (optional) ---
+const tz = process.env.ZERNIO_TIMEZONE;
+if (tz) {
+  // minimum sanity: looks like "Area/City" or a UTC offset tag
+  const plausible = /^[A-Za-z]+\/[A-Za-z_]+/.test(tz) || /^UTC[+-]?\d*$/i.test(tz);
+  if (plausible) {
+    check("ZERNIO_TIMEZONE format is plausible", true, tz);
+  } else {
+    check("ZERNIO_TIMEZONE format is plausible", false, `Unexpected value: ${tz}`);
+  }
+}
+
+// --- Check 6: Anthropic API key (optional) ---
+const anthropicKey = process.env.ANTHROPIC_API_KEY;
+if (!anthropicKey || anthropicKey === "your_anthropic_key_here") {
+  warn("ANTHROPIC_API_KEY not set", "Optional — used only for enhanced caption drafting in hybrid mode");
+} else if (anthropicKey.startsWith("sk-ant-")) {
+  check("ANTHROPIC_API_KEY format is valid", true);
+} else {
+  check("ANTHROPIC_API_KEY format is valid", false, "Key does not start with sk-ant- — check your Anthropic console");
+}
+
+// --- Print results ---
+console.log("Results:");
+for (const { icon, label, detail } of results) {
+  const detailStr = detail ? `  → ${detail}` : "";
+  console.log(`  ${icon}  ${label}${detailStr}`);
+}
+
+console.log("");
+
+if (allPassed) {
+  console.log(`${GREEN}All checks passed. Ready for api-live or hybrid mode.${RESET}`);
+} else {
+  const warnings = results.filter((r) => r.passed === null);
+  const failures = results.filter((r) => r.passed === false);
+  if (failures.length > 0) {
+    console.log(`${RED}${failures.length} check(s) failed. See details above.${RESET}`);
+    console.log(`\n  Agent-only mode remains available for campaign planning and dry-run manifests.`);
+  }
+  if (warnings.length > 0 && failures.length === 0) {
+    console.log(`${YELLOW}Checks passed with warnings. Agent-only mode is available.${RESET}`);
+  }
+}