vibebusiness 1.2.49 → 1.2.53

package/dist/scripts/init.js

@@ -41,6 +41,63 @@ function resolveScript(baseDir, scriptName) {
 var import_child_process = require("child_process");
 var fs = __toESM(require("fs"));
 var path2 = __toESM(require("path"));
+var CREDENTIALS_DIR = path2.join(process.env.HOME || "", ".vibebusiness");
+var CREDENTIALS_FILE = path2.join(CREDENTIALS_DIR, "credentials.json");
+function saveCredential(envVar, value) {
+  if (!fs.existsSync(CREDENTIALS_DIR)) {
+    fs.mkdirSync(CREDENTIALS_DIR, { recursive: true, mode: 448 });
+  }
+  const existing = loadCredentials();
+  existing[envVar] = value;
+  fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(existing, null, 2), { mode: 384 });
+  fs.chmodSync(CREDENTIALS_FILE, 384);
+}
+function loadCredentials() {
+  try {
+    if (fs.existsSync(CREDENTIALS_FILE)) {
+      return JSON.parse(fs.readFileSync(CREDENTIALS_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+async function validateApiKey(provider, key) {
+  if (provider === "anthropic-api") {
+    try {
+      const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": key,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: "claude-haiku-4-5-20251001",
+          max_tokens: 1,
+          messages: [{ role: "user", content: "Hi" }]
+        }),
+        signal: AbortSignal.timeout(15e3)
+      });
+      if (response.ok) {
+        return { valid: true };
+      }
+      const errorText = await response.text();
+      if (response.status === 401) {
+        return { valid: false, error: "Invalid API key" };
+      }
+      if (response.status === 403) {
+        return { valid: false, error: "API key does not have access to this model" };
+      }
+      if (response.status === 429 || response.status >= 500) {
+        return { valid: true };
+      }
+      return { valid: false, error: `API error ${response.status}: ${errorText.slice(0, 100)}` };
+    } catch (err) {
+      return { valid: false, error: `Connection failed: ${err.message}` };
+    }
+  }
+  return { valid: true };
+}
 function detectClaudeCLI(customPath) {
   const claudeBin = customPath || "claude";
   try {
@@ -73,13 +130,27 @@ function detectClaudeCLI(customPath) {
 }
 function detectBYOKKeys() {
   if (process.env.ANTHROPIC_API_KEY) {
-    return { provider: "anthropic-api", key: process.env.ANTHROPIC_API_KEY };
+    return { provider: "anthropic-api", key: process.env.ANTHROPIC_API_KEY, source: "env" };
   }
   if (process.env.OPENAI_API_KEY) {
-    return { provider: "openai-api", key: process.env.OPENAI_API_KEY };
+    return { provider: "openai-api", key: process.env.OPENAI_API_KEY, source: "env" };
   }
   if (process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY) {
-    return { provider: "google-api", key: process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY };
+    return { provider: "google-api", key: process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY, source: "env" };
+  }
+  const creds = loadCredentials();
+  if (creds.ANTHROPIC_API_KEY) {
+    process.env.ANTHROPIC_API_KEY = creds.ANTHROPIC_API_KEY;
+    return { provider: "anthropic-api", key: creds.ANTHROPIC_API_KEY, source: "credentials" };
+  }
+  if (creds.OPENAI_API_KEY) {
+    process.env.OPENAI_API_KEY = creds.OPENAI_API_KEY;
+    return { provider: "openai-api", key: creds.OPENAI_API_KEY, source: "credentials" };
+  }
+  if (creds.GOOGLE_API_KEY || creds.GEMINI_API_KEY) {
+    const key = creds.GOOGLE_API_KEY || creds.GEMINI_API_KEY;
+    process.env.GOOGLE_API_KEY = key;
+    return { provider: "google-api", key, source: "credentials" };
   }
   return null;
 }
@@ -125,6 +196,53 @@ function saveProviderConfig(config) {
   fs.writeFileSync(PROVIDER_CONFIG_FILE, JSON.stringify(safeConfig, null, 2));
 }
 
+// scripts/lib/secure-input.ts
+function askSecret(prompt) {
+  return new Promise((resolve2, reject) => {
+    process.stdout.write(prompt);
+    const input = [];
+    if (!process.stdin.isTTY) {
+      let data = "";
+      process.stdin.setEncoding("utf-8");
+      process.stdin.on("data", (chunk) => {
+        data += chunk;
+      });
+      process.stdin.on("end", () => resolve2(data.trim()));
+      process.stdin.resume();
+      return;
+    }
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    const onData = (ch) => {
+      const code = ch.charCodeAt(0);
+      if (ch === "\r" || ch === "\n") {
+        cleanup();
+        process.stdout.write("\n");
+        resolve2(input.join(""));
+      } else if (code === 3) {
+        cleanup();
+        process.stdout.write("\n");
+        reject(new Error("User cancelled input"));
+      } else if (code === 127 || code === 8) {
+        if (input.length > 0) {
+          input.pop();
+          process.stdout.write("\b \b");
+        }
+      } else if (code >= 32) {
+        input.push(ch);
+        process.stdout.write("*");
+      }
+    };
+    const cleanup = () => {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdin.removeListener("data", onData);
+    };
+    process.stdin.on("data", onData);
+  });
+}
+
 // scripts/lib/license.ts
 var fs2 = __toESM(require("fs"));
 var path3 = __toESM(require("path"));
@@ -788,6 +906,8 @@ async function stepAIProvider(rootDir) {
   }
   if (!detection.message.includes("No AI provider")) {
     printSuccess(`AI: ${detection.message}`);
+    print("    Heartbeat reasoning and idea evaluation will work with your API key.");
+    print("    Codebase analysis and implementation require Claude Code CLI.");
     const config2 = { type: detection.provider };
     saveProviderConfig(config2);
     return config2;
@@ -800,7 +920,7 @@ async function stepAIProvider(rootDir) {
     "Skip for now (AI features will be disabled)"
   ]);
   if (choice === 3) {
-    printWarning("AI features disabled. Configure later with `vibebusiness init`.");
+    printWarning("AI features disabled. Configure later with `vibebusiness provider setup`.");
     const config2 = { type: "claude-cli" };
     return config2;
   }
@@ -810,21 +930,49 @@ async function stepAIProvider(rootDir) {
     2: { type: "google-api", envVar: "GOOGLE_API_KEY" }
   };
   const selected = providerMap[choice];
-  const key = await ask(`Enter your ${selected.envVar}`);
-  if (key) {
-    const envFile = path8.join(rootDir, ".env.local");
-    let envContent = "";
-    if (fs7.existsSync(envFile)) {
-      envContent = fs7.readFileSync(envFile, "utf-8");
+  let key = "";
+  let validated = false;
+  const MAX_ATTEMPTS = 3;
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      rl.pause();
+      key = await askSecret(`
+  Enter your ${selected.envVar}: `);
+      rl.resume();
+    } catch {
+      rl.resume();
+      printWarning("Input cancelled.");
+      const config2 = { type: "claude-cli" };
+      return config2;
     }
-    if (!envContent.includes(selected.envVar)) {
-      envContent += `
-${selected.envVar}=${key}
-`;
-      fs7.writeFileSync(envFile, envContent);
-      printSuccess(`Saved ${selected.envVar} to .env.local`);
+    if (!key.trim()) {
+      printWarning("No key entered. Skipping AI provider setup.");
+      const config2 = { type: "claude-cli" };
+      return config2;
     }
+    key = key.trim();
+    process.stdout.write("  Validating... ");
+    const result = await validateApiKey(selected.type, key);
+    if (result.valid) {
+      console.log("\u2713 API key is valid");
+      validated = true;
+      break;
+    } else {
+      console.log(`\u2717 ${result.error || "Invalid key"}`);
+      if (attempt < MAX_ATTEMPTS) {
+        print(`  Please try again (attempt ${attempt + 1}/${MAX_ATTEMPTS}).`);
+      } else {
+        printWarning(`Failed after ${MAX_ATTEMPTS} attempts.`);
+      }
+    }
+  }
+  if (validated && key) {
+    saveCredential(selected.envVar, key);
+    printSuccess(`Key saved to ~/.vibebusiness/credentials.json (permissions: 600)`);
     process.env[selected.envVar] = key;
+    printSuccess(`AI: ${selected.type === "anthropic-api" ? "Anthropic API" : selected.type === "openai-api" ? "OpenAI API" : "Google AI API"} configured`);
+    print("    Heartbeat reasoning and idea evaluation work with your API key.");
+    print("    Codebase analysis and implementation require Claude Code CLI.");
     appendAnalyticsEvent("api_key_provided", initSessionId, initAnalyticsFile, { provider: selected.type });
   }
   const config = { type: selected.type };

package/dist/scripts/provider.js

@@ -0,0 +1,428 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// scripts/provider.ts
+var readline = __toESM(require("readline"));
+
+// scripts/lib/ai-provider.ts
+var import_child_process = require("child_process");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var CREDENTIALS_DIR = path.join(process.env.HOME || "", ".vibebusiness");
+var CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials.json");
+function saveCredential(envVar, value) {
+  if (!fs.existsSync(CREDENTIALS_DIR)) {
+    fs.mkdirSync(CREDENTIALS_DIR, { recursive: true, mode: 448 });
+  }
+  const existing = loadCredentials();
+  existing[envVar] = value;
+  fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(existing, null, 2), { mode: 384 });
+  fs.chmodSync(CREDENTIALS_FILE, 384);
+}
+function loadCredentials() {
+  try {
+    if (fs.existsSync(CREDENTIALS_FILE)) {
+      return JSON.parse(fs.readFileSync(CREDENTIALS_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+function clearCredentials() {
+  try {
+    if (fs.existsSync(CREDENTIALS_FILE)) {
+      fs.unlinkSync(CREDENTIALS_FILE);
+    }
+  } catch {
+  }
+}
+function maskApiKey(key) {
+  if (key.length <= 12) return "****";
+  return `${key.slice(0, 4)}...${key.slice(-4)}`;
+}
+async function validateApiKey(provider, key) {
+  if (provider === "anthropic-api") {
+    try {
+      const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": key,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: "claude-haiku-4-5-20251001",
+          max_tokens: 1,
+          messages: [{ role: "user", content: "Hi" }]
+        }),
+        signal: AbortSignal.timeout(15e3)
+      });
+      if (response.ok) {
+        return { valid: true };
+      }
+      const errorText = await response.text();
+      if (response.status === 401) {
+        return { valid: false, error: "Invalid API key" };
+      }
+      if (response.status === 403) {
+        return { valid: false, error: "API key does not have access to this model" };
+      }
+      if (response.status === 429 || response.status >= 500) {
+        return { valid: true };
+      }
+      return { valid: false, error: `API error ${response.status}: ${errorText.slice(0, 100)}` };
+    } catch (err) {
+      return { valid: false, error: `Connection failed: ${err.message}` };
+    }
+  }
+  return { valid: true };
+}
+function detectClaudeCLI(customPath) {
+  const claudeBin = customPath || "claude";
+  try {
+    const version = (0, import_child_process.execSync)(`${claudeBin} --version 2>/dev/null`, {
+      timeout: 1e4,
+      encoding: "utf-8"
+    }).trim();
+    return { found: true, path: claudeBin, version };
+  } catch {
+    const commonPaths = [
+      "/usr/local/bin/claude",
+      path.join(process.env.HOME || "", ".claude", "bin", "claude"),
+      path.join(process.env.HOME || "", ".local", "bin", "claude")
+    ];
+    for (const p of commonPaths) {
+      try {
+        if (fs.existsSync(p)) {
+          const version = (0, import_child_process.execSync)(`${p} --version 2>/dev/null`, {
+            timeout: 1e4,
+            encoding: "utf-8"
+          }).trim();
+          return { found: true, path: p, version };
+        }
+      } catch {
+        continue;
+      }
+    }
+    return { found: false, path: claudeBin };
+  }
+}
+function detectBYOKKeys() {
+  if (process.env.ANTHROPIC_API_KEY) {
+    return { provider: "anthropic-api", key: process.env.ANTHROPIC_API_KEY, source: "env" };
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return { provider: "openai-api", key: process.env.OPENAI_API_KEY, source: "env" };
+  }
+  if (process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY) {
+    return { provider: "google-api", key: process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY, source: "env" };
+  }
+  const creds = loadCredentials();
+  if (creds.ANTHROPIC_API_KEY) {
+    process.env.ANTHROPIC_API_KEY = creds.ANTHROPIC_API_KEY;
+    return { provider: "anthropic-api", key: creds.ANTHROPIC_API_KEY, source: "credentials" };
+  }
+  if (creds.OPENAI_API_KEY) {
+    process.env.OPENAI_API_KEY = creds.OPENAI_API_KEY;
+    return { provider: "openai-api", key: creds.OPENAI_API_KEY, source: "credentials" };
+  }
+  if (creds.GOOGLE_API_KEY || creds.GEMINI_API_KEY) {
+    const key = creds.GOOGLE_API_KEY || creds.GEMINI_API_KEY;
+    process.env.GOOGLE_API_KEY = key;
+    return { provider: "google-api", key, source: "credentials" };
+  }
+  return null;
+}
+var CONFIG_DIR = path.join(process.env.HOME || "", ".ai-analyst");
+var PROVIDER_CONFIG_FILE = path.join(CONFIG_DIR, "provider.json");
+function loadProviderConfig() {
+  try {
+    if (fs.existsSync(PROVIDER_CONFIG_FILE)) {
+      return JSON.parse(fs.readFileSync(PROVIDER_CONFIG_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveProviderConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  const safeConfig = {
+    type: config.type,
+    model: config.model,
+    claudePath: config.claudePath
+  };
+  fs.writeFileSync(PROVIDER_CONFIG_FILE, JSON.stringify(safeConfig, null, 2));
+}
+
+// scripts/lib/secure-input.ts
+function askSecret(prompt) {
+  return new Promise((resolve, reject) => {
+    process.stdout.write(prompt);
+    const input = [];
+    if (!process.stdin.isTTY) {
+      let data = "";
+      process.stdin.setEncoding("utf-8");
+      process.stdin.on("data", (chunk) => {
+        data += chunk;
+      });
+      process.stdin.on("end", () => resolve(data.trim()));
+      process.stdin.resume();
+      return;
+    }
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    const onData = (ch) => {
+      const code = ch.charCodeAt(0);
+      if (ch === "\r" || ch === "\n") {
+        cleanup();
+        process.stdout.write("\n");
+        resolve(input.join(""));
+      } else if (code === 3) {
+        cleanup();
+        process.stdout.write("\n");
+        reject(new Error("User cancelled input"));
+      } else if (code === 127 || code === 8) {
+        if (input.length > 0) {
+          input.pop();
+          process.stdout.write("\b \b");
+        }
+      } else if (code >= 32) {
+        input.push(ch);
+        process.stdout.write("*");
+      }
+    };
+    const cleanup = () => {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdin.removeListener("data", onData);
+    };
+    process.stdin.on("data", onData);
+  });
+}
+
+// scripts/provider.ts
+var rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+function askChoice(question, options) {
+  return new Promise((resolve) => {
+    console.log(`
+${question}`);
+    options.forEach((opt, i) => console.log(`  ${i + 1}. ${opt}`));
+    rl.question(`Choice [1-${options.length}]: `, (answer) => {
+      const idx = parseInt(answer.trim(), 10) - 1;
+      resolve(idx >= 0 && idx < options.length ? idx : 0);
+    });
+  });
+}
+var PROVIDER_NAMES = {
+  "claude-cli": "Claude Code CLI",
+  "anthropic-api": "Anthropic API",
+  "openai-api": "OpenAI API",
+  "google-api": "Google AI API"
+};
+async function cmdStatus() {
+  const line = "\u2500".repeat(50);
+  console.log(`
+AI Provider`);
+  console.log(line);
+  const cli = detectClaudeCLI();
+  const byok = detectBYOKKeys();
+  const savedConfig = loadProviderConfig();
+  const activeProvider = cli.found ? "claude-cli" : byok?.provider || savedConfig?.type || null;
+  if (activeProvider) {
+    console.log(`  Provider:  ${PROVIDER_NAMES[activeProvider]}`);
+  } else {
+    console.log("  Provider:  None configured");
+  }
+  if (byok) {
+    console.log(`  Key:       ${maskApiKey(byok.key)}`);
+    console.log(`  Source:    ${byok.source === "env" ? "Environment variable" : "~/.vibebusiness/credentials.json"}`);
+    process.stdout.write("  Status:    ");
+    const result = await validateApiKey(byok.provider, byok.key);
+    if (result.valid) {
+      console.log("\u2713 Active");
+    } else {
+      console.log(`\u2717 ${result.error || "Invalid"}`);
+    }
+  } else if (!cli.found) {
+    console.log("  Key:       Not set");
+    console.log("  Status:    \u2717 No API key configured");
+  }
+  if (savedConfig?.model) {
+    console.log(`  Model:     ${savedConfig.model}`);
+  } else if (activeProvider === "anthropic-api") {
+    console.log("  Model:     claude-sonnet-4-6 (default)");
+  }
+  if (cli.found) {
+    console.log(`  CLI:       ${cli.version || "installed"}`);
+  }
+  console.log("");
+  console.log("  Capabilities:");
+  const hasKey = !!byok;
+  const hasCLI = cli.found;
+  const caps = [
+    { name: "Heartbeat reasoning", needs: "API key", available: hasKey || hasCLI },
+    { name: "Idea evaluation", needs: "API key", available: hasKey || hasCLI },
+    { name: "Idea decomposition", needs: "API key", available: hasKey || hasCLI },
+    { name: "Codebase analysis", needs: "Claude Code CLI", available: hasCLI },
+    { name: "Implementation", needs: "Claude Code CLI", available: hasCLI },
+    { name: "Interactive chat", needs: "Claude Code CLI", available: hasCLI }
+  ];
+  for (const cap of caps) {
+    const icon = cap.available ? "\u2713" : "\u2717";
+    const suffix = cap.available ? `(${cap.needs})` : `(needs ${cap.needs})`;
+    console.log(`    ${icon} ${cap.name.padEnd(24)} ${suffix}`);
+  }
+  console.log("");
+}
+async function cmdSetup() {
+  console.log("");
+  const choice = await askChoice("How would you like to connect AI?", [
+    "Enter Anthropic API key (recommended)",
+    "Enter OpenAI API key",
+    "Enter Google AI API key",
+    "Skip for now"
+  ]);
+  if (choice === 3) {
+    console.log("\n  Skipped. Run `vibebusiness provider setup` when ready.\n");
+    rl.close();
+    return;
+  }
+  const providerMap = {
+    0: { type: "anthropic-api", envVar: "ANTHROPIC_API_KEY" },
+    1: { type: "openai-api", envVar: "OPENAI_API_KEY" },
+    2: { type: "google-api", envVar: "GOOGLE_API_KEY" }
+  };
+  const selected = providerMap[choice];
+  let key = "";
+  let validated = false;
+  const MAX_ATTEMPTS = 3;
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      rl.pause();
+      key = await askSecret(`
+  Enter your ${selected.envVar}: `);
+      rl.resume();
+    } catch {
+      rl.resume();
+      console.log("\n  Cancelled.\n");
+      rl.close();
+      return;
+    }
+    if (!key.trim()) {
+      console.log("\n  No key entered. Skipping.\n");
+      rl.close();
+      return;
+    }
+    key = key.trim();
+    process.stdout.write("  Validating... ");
+    const result = await validateApiKey(selected.type, key);
+    if (result.valid) {
+      console.log("\u2713 API key is valid");
+      validated = true;
+      break;
+    } else {
+      console.log(`\u2717 ${result.error || "Invalid key"}`);
+      if (attempt < MAX_ATTEMPTS) {
+        console.log(`  Please try again (attempt ${attempt + 1}/${MAX_ATTEMPTS}).`);
+      } else {
+        console.log(`  Failed after ${MAX_ATTEMPTS} attempts.
+`);
+      }
+    }
+  }
+  if (validated && key) {
+    saveCredential(selected.envVar, key);
+    console.log("  \u2713 Key saved to ~/.vibebusiness/credentials.json (permissions: 600)");
+    const config = { type: selected.type };
+    saveProviderConfig(config);
+    console.log(`  \u2713 Provider set to ${PROVIDER_NAMES[selected.type]}
+`);
+  }
+  rl.close();
+}
+async function cmdValidate() {
+  const byok = detectBYOKKeys();
+  if (!byok) {
+    console.log("\n  No API key found. Run `vibebusiness provider setup` to configure one.\n");
+    return;
+  }
+  console.log(`
+  Provider: ${PROVIDER_NAMES[byok.provider]}`);
+  console.log(`  Key:      ${maskApiKey(byok.key)}`);
+  console.log(`  Source:   ${byok.source === "env" ? "Environment variable" : "~/.vibebusiness/credentials.json"}`);
+  process.stdout.write("  Result:   ");
+  const result = await validateApiKey(byok.provider, byok.key);
+  if (result.valid) {
+    console.log("\u2713 API key is valid\n");
+  } else {
+    console.log(`\u2717 ${result.error || "Invalid"}
+`);
+    process.exit(1);
+  }
+}
+function cmdClear() {
+  const creds = loadCredentials();
+  const hasKeys = Object.keys(creds).length > 0;
+  if (!hasKeys) {
+    console.log("\n  No stored credentials to remove.\n");
+    return;
+  }
+  clearCredentials();
+  console.log("\n  \u2713 Removed stored credentials from ~/.vibebusiness/credentials.json\n");
+  console.log("  Note: Environment variables (if set) are unaffected.");
+  console.log("  Run `vibebusiness provider` to verify status.\n");
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "setup":
+      await cmdSetup();
+      break;
+    case "validate":
+      await cmdValidate();
+      break;
+    case "clear":
+      cmdClear();
+      break;
+    case void 0:
+    case "status":
+      await cmdStatus();
+      break;
+    default:
+      console.error(`
+  Unknown provider subcommand: ${subcommand}`);
+      console.log("  Usage: vibebusiness provider [setup|validate|clear]\n");
+      process.exit(1);
+  }
+}
+main().finally(() => {
+  rl.close();
+});