clawzempic 1.0.5 → 1.0.7

package/bin/clawzempic.js

@@ -12,6 +12,11 @@
  *   npx clawzempic test         Verify your connection works
  *   npx clawzempic status       Check usage and savings
  *   npx clawzempic doctor       Diagnose common issues
+ *
+ * Flags:
+ *   --key <key>                 Provide API key (skip interactive prompt)
+ *   --yes, -y                   Auto-confirm all prompts (non-interactive)
+ *   --no-test                   Skip connection test after init
  */
 
 import { createInterface } from 'node:readline/promises';
@@ -22,7 +27,8 @@ import { join, basename } from 'node:path';
 // ── Constants ─────────────────────────────────────────────────────────────────
 
 const API_BASE = 'https://api.clawzempic.ai';
-const VERSION = '1.0.5';
+const VERSION = '1.0.7';
+const OPENCLAW_DIR_NAME = '.openclaw';
 
 // ── ANSI Colors (no dependencies) ─────────────────────────────────────────────
 
@@ -191,6 +197,8 @@ async function ask(question, opts = {}) {
 }
 
 async function confirm(question, defaultYes = true) {
+  // --yes flag auto-confirms everything
+  if (globalArgs?.yes) return true;
   const hint = defaultYes ? 'Y/n' : 'y/N';
   const answer = await ask(`${question} ${c.dim}(${hint})${c.reset}`, { required: false });
   if (!answer) return defaultYes;
@@ -280,7 +288,7 @@ const FRAMEWORKS = [
       return false;
     },
     envFile: '.env',
-    envVars: { ANTHROPIC_API_KEY: null, ANTHROPIC_BASE_URL: API_BASE },
+    envVars: { LLM_API_KEY: null, LLM_BASE_URL: API_BASE },
   },
   {
     id: 'nanobot',
@@ -296,11 +304,11 @@ const FRAMEWORKS = [
       return false;
     },
     envFile: '.env',
-    envVars: { ANTHROPIC_API_KEY: null, ANTHROPIC_BASE_URL: API_BASE },
+    envVars: { LLM_API_KEY: null, LLM_BASE_URL: API_BASE },
   },
   {
     id: 'python',
-    name: 'Python (Anthropic SDK)',
+    name: 'Python (Anthropic/OpenRouter SDK)',
     detect: (dir) => {
       for (const f of ['requirements.txt', 'pyproject.toml', 'Pipfile']) {
         if (existsSync(join(dir, f))) {
@@ -313,7 +321,7 @@ const FRAMEWORKS = [
       return false;
     },
     envFile: '.env',
-    envVars: { ANTHROPIC_API_KEY: null, ANTHROPIC_BASE_URL: API_BASE },
+    envVars: { LLM_API_KEY: null, LLM_BASE_URL: API_BASE },
   },
   {
     id: 'langchain',
@@ -330,11 +338,11 @@ const FRAMEWORKS = [
       return false;
     },
     envFile: '.env',
-    envVars: { ANTHROPIC_API_KEY: null, ANTHROPIC_BASE_URL: API_BASE },
+    envVars: { LLM_API_KEY: null, LLM_BASE_URL: API_BASE },
   },
   {
     id: 'node',
-    name: 'Node.js (Anthropic SDK)',
+    name: 'Node.js (Anthropic/OpenRouter SDK)',
     detect: (dir) => {
       if (existsSync(join(dir, 'package.json'))) {
         try {
@@ -345,7 +353,7 @@ const FRAMEWORKS = [
       return false;
     },
     envFile: '.env',
-    envVars: { ANTHROPIC_API_KEY: null, ANTHROPIC_BASE_URL: API_BASE },
+    envVars: { LLM_API_KEY: null, LLM_BASE_URL: API_BASE },
   },
 ];
 
@@ -357,17 +365,26 @@ function detectFramework(dir) {
 }
 
 function detectExistingConfig(dir) {
-  // Check if already configured
+  // Check OpenClaw auth-profiles.json first
+  const openclawDir = findOpenClawDir(dir);
+  if (openclawDir) {
+    const key = findKeyInAuthProfiles(openclawDir);
+    if (key) {
+      return { configured: true, envPath: join(openclawDir, 'auth-profiles.json'), isOpenClaw: true };
+    }
+  }
+
+  // Check .env file
   const envPath = join(dir, '.env');
   if (existsSync(envPath)) {
     try {
       const content = readFileSync(envPath, 'utf8');
       if (content.includes('clawzempic.ai') || content.includes('sk-clwz-') || content.includes('CLAWZEMPIC_API_KEY')) {
-        return { configured: true, envPath };
+        return { configured: true, envPath, isOpenClaw: false };
       }
     } catch {}
   }
-  return { configured: false, envPath };
+  return { configured: false, envPath, isOpenClaw: false };
 }
 
 // ── Config Patching ───────────────────────────────────────────────────────────
@@ -412,6 +429,175 @@ function patchEnvFile(envPath, vars) {
   return changes;
 }
 
+// ── OpenClaw v2026.2+ Helpers ─────────────────────────────────────────────────
+
+/**
+ * Find the .openclaw directory. Checks cwd first, then home dir.
+ */
+function findOpenClawDir(dir) {
+  const local = join(dir, OPENCLAW_DIR_NAME);
+  if (existsSync(local)) return local;
+  const home = join(process.env.HOME || process.env.USERPROFILE || '', OPENCLAW_DIR_NAME);
+  if (existsSync(home)) return home;
+  return null;
+}
+
+/**
+ * Check if this is OpenClaw v2026.2+ (has auth-profiles.json).
+ */
+function isModernOpenClaw(openclawDir) {
+  return existsSync(join(openclawDir, 'auth-profiles.json'));
+}
+
+/**
+ * Read and patch auth-profiles.json to add/update a clawzempic provider profile.
+ */
+function patchAuthProfiles(openclawDir, apiKey) {
+  const profilesPath = join(openclawDir, 'auth-profiles.json');
+  let profiles = { version: 1, profiles: {} };
+
+  if (existsSync(profilesPath)) {
+    // Back up
+    const backupPath = profilesPath + '.bak.clawzempic';
+    if (!existsSync(backupPath)) {
+      copyFileSync(profilesPath, backupPath);
+      bullet(info, `Backed up ${c.dim}auth-profiles.json${c.reset} ${arrow} ${c.dim}auth-profiles.json.bak.clawzempic${c.reset}`);
+    }
+    try {
+      profiles = JSON.parse(readFileSync(profilesPath, 'utf8'));
+    } catch {
+      bullet(warn, 'Could not parse auth-profiles.json, creating fresh one.');
+    }
+  }
+
+  const hadClawzempic = !!profiles.profiles?.clawzempic;
+
+  if (!profiles.profiles) profiles.profiles = {};
+  profiles.profiles.clawzempic = {
+    type: 'api_key',
+    provider: 'anthropic',
+    key: apiKey,
+    baseUrl: API_BASE,
+    createdAt: new Date().toISOString(),
+  };
+
+  writeFileSync(profilesPath, JSON.stringify(profiles, null, 2) + '\n', 'utf8');
+  return { action: hadClawzempic ? 'updated' : 'added', profilesPath };
+}
+
+/**
+ * Read and patch openclaw.json to set model to use clawzempic provider.
+ */
+function patchOpenClawConfig(openclawDir) {
+  const configPath = join(openclawDir, 'openclaw.json');
+  if (!existsSync(configPath)) return { patched: false, reason: 'no openclaw.json' };
+
+  let config;
+  try {
+    config = JSON.parse(readFileSync(configPath, 'utf8'));
+  } catch {
+    return { patched: false, reason: 'could not parse openclaw.json' };
+  }
+
+  // Back up
+  const backupPath = configPath + '.bak.clawzempic';
+  if (!existsSync(backupPath)) {
+    copyFileSync(configPath, backupPath);
+  }
+
+  // Update model to use clawzempic provider
+  if (!config.agents) config.agents = {};
+  if (!config.agents.defaults) config.agents.defaults = {};
+  if (!config.agents.defaults.model) config.agents.defaults.model = {};
+
+  const oldModel = config.agents.defaults.model.primary || 'none';
+  config.agents.defaults.model.primary = 'clawzempic/claude-sonnet-4-5-20250929';
+
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+  return { patched: true, oldModel, configPath };
+}
+
+/**
+ * Check OpenClaw gateway auth status.
+ */
+function checkGatewayAuth(openclawDir) {
+  // Check openclaw.json for gateway.auth
+  const configPath = join(openclawDir, 'openclaw.json');
+  if (!existsSync(configPath)) return { hasAuth: false, mode: 'unknown' };
+
+  try {
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    const auth = config.gateway?.auth;
+    if (!auth || !auth.mode || auth.mode === 'none') {
+      return { hasAuth: false, mode: auth?.mode || 'none' };
+    }
+    return { hasAuth: true, mode: auth.mode };
+  } catch {
+    return { hasAuth: false, mode: 'unknown' };
+  }
+}
+
+/**
+ * Find a Clawzempic API key from OpenClaw auth-profiles.json.
+ */
+function findKeyInAuthProfiles(openclawDir) {
+  if (!openclawDir) return null;
+  const profilesPath = join(openclawDir, 'auth-profiles.json');
+  if (!existsSync(profilesPath)) return null;
+
+  try {
+    const profiles = JSON.parse(readFileSync(profilesPath, 'utf8'));
+    // Check clawzempic profile first
+    if (profiles.profiles?.clawzempic?.key) {
+      return profiles.profiles.clawzempic.key;
+    }
+    // Check any profile that points to clawzempic.ai
+    for (const [, profile] of Object.entries(profiles.profiles || {})) {
+      if (profile.baseUrl?.includes('clawzempic.ai') && profile.key) {
+        return profile.key;
+      }
+    }
+  } catch {}
+  return null;
+}
+
+/**
+ * Find API key from all possible locations.
+ */
+function findApiKey(dir) {
+  // 1. Environment variables (check new names first, fall back to old)
+  const envKey = process.env.CLAWZEMPIC_API_KEY || process.env.LLM_API_KEY || process.env.ANTHROPIC_API_KEY;
+  if (envKey && (envKey.startsWith('sk-clwz-') || envKey.startsWith('sr_'))) {
+    return { key: envKey, source: 'environment variable' };
+  }
+
+  // 2. OpenClaw auth-profiles.json
+  const openclawDir = findOpenClawDir(dir);
+  if (openclawDir) {
+    const authKey = findKeyInAuthProfiles(openclawDir);
+    if (authKey && (authKey.startsWith('sk-clwz-') || authKey.startsWith('sr_'))) {
+      return { key: authKey, source: 'OpenClaw auth-profiles.json' };
+    }
+  }
+
+  // 3. .env file in cwd
+  const envPath = join(dir, '.env');
+  if (existsSync(envPath)) {
+    try {
+      const content = readFileSync(envPath, 'utf8');
+      const match = content.match(/^(?:CLAWZEMPIC_API_KEY|LLM_API_KEY|ANTHROPIC_API_KEY)\s*=\s*(.+)$/m);
+      if (match) {
+        const val = match[1].trim();
+        if (val.startsWith('sk-clwz-') || val.startsWith('sr_')) {
+          return { key: val, source: '.env file' };
+        }
+      }
+    } catch {}
+  }
+
+  return null;
+}
+
 // ── Commands ──────────────────────────────────────────────────────────────────
 
 async function cmdInit(args) {
@@ -536,86 +722,160 @@ async function cmdInit(args) {
 
   heading('Configuration');
 
-  const envFile = framework?.envFile || '.env';
-  const envPath = join(dir, envFile);
-
-  // Build env vars: proxy key + base URL. Keep provider key separate.
-  const envVars = {
-    CLAWZEMPIC_API_KEY: clawzempicKey,
-    ANTHROPIC_BASE_URL: API_BASE,
-  };
+  // OpenClaw v2026.2+ gets special treatment: patch auth-profiles.json + openclaw.json
+  const openclawDir = findOpenClawDir(dir);
+  const useOpenClawPath = framework?.id === 'openclaw' && openclawDir && isModernOpenClaw(openclawDir);
 
-  // Show what we'll do
-  bullet(info, `Will update ${c.bold}${envFile}${c.reset}:`);
-  for (const [key, value] of Object.entries(envVars)) {
-    const display = key.includes('KEY') ? value.substring(0, 12) + '...' : value;
-    console.log(`    ${c.green}+${c.reset} ${key}=${display}`);
-  }
-  blank();
+  if (useOpenClawPath) {
+    bullet(ok, `OpenClaw v2026.2+ detected at ${c.dim}${openclawDir}${c.reset}`);
+    blank();
 
-  const applyChanges = await confirm('Apply these changes?');
-  if (!applyChanges) {
-    bullet(info, 'No changes made. You can set these manually:');
+    // Show what we'll do
+    bullet(info, `Will update ${c.bold}auth-profiles.json${c.reset}:`);
+    console.log(`    ${c.green}+${c.reset} Add "clawzempic" provider (baseUrl: ${API_BASE})`);
+    console.log(`    ${c.green}+${c.reset} API key: ${clawzempicKey.substring(0, 12)}...`);
+    blank();
+    bullet(info, `Will update ${c.bold}openclaw.json${c.reset}:`);
+    console.log(`    ${c.green}+${c.reset} Set default model to clawzempic/claude-sonnet-4-5-20250929`);
     blank();
+
+    const applyChanges = await confirm('Apply these changes?');
+    if (!applyChanges) {
+      bullet(info, 'No changes made. You can configure manually:');
+      blank();
+      bullet(info, `Add to ${c.bold}auth-profiles.json${c.reset} → profiles.clawzempic:`);
+      console.log(`    { "type": "api_key", "provider": "anthropic", "key": "${clawzempicKey}", "baseUrl": "${API_BASE}" }`);
+      blank();
+      bullet(info, `Set in ${c.bold}openclaw.json${c.reset} → agents.defaults.model.primary:`);
+      console.log(`    "clawzempic/claude-sonnet-4-5-20250929"`);
+      blank();
+      return cleanup();
+    }
+
+    // Patch auth profiles
+    const profileResult = patchAuthProfiles(openclawDir, clawzempicKey);
+    bullet(ok, `${profileResult.action === 'updated' ? 'Updated' : 'Added'} clawzempic profile in ${c.bold}auth-profiles.json${c.reset}`);
+
+    // Patch openclaw.json model config
+    const configResult = patchOpenClawConfig(openclawDir);
+    if (configResult.patched) {
+      bullet(ok, `Set default model to ${c.bold}clawzempic/claude-sonnet-4-5-20250929${c.reset}`);
+      if (configResult.oldModel !== 'none') {
+        bullet(info, `Previous model: ${c.dim}${configResult.oldModel}${c.reset}`);
+      }
+    } else {
+      bullet(warn, `Could not update openclaw.json: ${configResult.reason}`);
+    }
+
+    // Check gateway auth
+    const gwAuth = checkGatewayAuth(openclawDir);
+    if (!gwAuth.hasAuth) {
+      blank();
+      bullet(warn, `Gateway auth is ${c.bold}${gwAuth.mode}${c.reset} — v2026.2+ requires a password or token.`);
+      bullet(info, `Set gateway.auth in openclaw.json to "password" or "token" mode.`);
+      bullet(info, `Example: ${c.dim}{ "gateway": { "auth": { "mode": "password" } } }${c.reset}`);
+    } else {
+      bullet(ok, `Gateway auth: ${c.bold}${gwAuth.mode}${c.reset}`);
+    }
+  } else {
+    // Generic .env path (non-OpenClaw frameworks)
+    const envFile = framework?.envFile || '.env';
+    const envPath = join(dir, envFile);
+
+    // Build env vars: proxy key + base URL. Keep provider key separate.
+    const envVars = {
+      CLAWZEMPIC_API_KEY: clawzempicKey,
+      LLM_BASE_URL: API_BASE,
+    };
+
+    // Show what we'll do
+    bullet(info, `Will update ${c.bold}${envFile}${c.reset}:`);
     for (const [key, value] of Object.entries(envVars)) {
-      console.log(`    ${key}=${value}`);
+      const display = key.includes('KEY') ? value.substring(0, 12) + '...' : value;
+      console.log(`    ${c.green}+${c.reset} ${key}=${display}`);
     }
     blank();
-    return cleanup();
-  }
 
-  // Clean up v1.0.3 bug: it wrote Clawzempic keys into ANTHROPIC_API_KEY.
-  // Only remove if the value is clearly not an Anthropic key (sr_ or sk-clwz- prefix).
-  if (existsSync(envPath)) {
-    const existing = readFileSync(envPath, 'utf8');
-    const badMatch = existing.match(/^ANTHROPIC_API_KEY\s*=\s*(.+)$/m);
-    if (badMatch) {
-      const badVal = badMatch[1].trim();
-      if (badVal.startsWith('sr_') || badVal.startsWith('sk-clwz-')) {
-        const cleaned = existing.replace(/^ANTHROPIC_API_KEY\s*=\s*(?:sr_|sk-clwz-).+\n?/m, '');
-        writeFileSync(envPath, cleaned, 'utf8');
-        bullet(warn, `Removed stale ANTHROPIC_API_KEY (had a Clawzempic key from v1.0.3 bug)`);
+    const applyChanges = await confirm('Apply these changes?');
+    if (!applyChanges) {
+      bullet(info, 'No changes made. You can set these manually:');
+      blank();
+      for (const [key, value] of Object.entries(envVars)) {
+        console.log(`    ${key}=${value}`);
       }
+      blank();
+      return cleanup();
     }
-  }
 
-  // Apply
-  const changes = patchEnvFile(envPath, envVars);
-  for (const change of changes) {
-    if (change.action === 'updated') {
-      bullet(ok, `Updated ${c.bold}${change.key}${c.reset}`);
-    } else {
-      bullet(ok, `Added ${c.bold}${change.key}${c.reset}`);
+    // Clean up legacy: remove Clawzempic keys from ANTHROPIC_API_KEY (v1.0.3 bug + old naming)
+    if (existsSync(envPath)) {
+      const existing = readFileSync(envPath, 'utf8');
+      const badMatch = existing.match(/^ANTHROPIC_API_KEY\s*=\s*(.+)$/m);
+      if (badMatch) {
+        const badVal = badMatch[1].trim();
+        if (badVal.startsWith('sr_') || badVal.startsWith('sk-clwz-')) {
+          const cleaned = existing.replace(/^ANTHROPIC_API_KEY\s*=\s*(?:sr_|sk-clwz-).+\n?/m, '');
+          writeFileSync(envPath, cleaned, 'utf8');
+          bullet(warn, `Removed stale ANTHROPIC_API_KEY (had a Clawzempic key — use CLAWZEMPIC_API_KEY instead)`);
+        }
+      }
+      // Also clean up old ANTHROPIC_BASE_URL pointing to clawzempic
+      const oldBaseMatch = existing.match(/^ANTHROPIC_BASE_URL\s*=\s*(.+)$/m);
+      if (oldBaseMatch && oldBaseMatch[1].includes('clawzempic.ai')) {
+        const cleaned2 = existing.replace(/^ANTHROPIC_BASE_URL\s*=\s*.+clawzempic\.ai.+\n?/m, '');
+        writeFileSync(envPath, cleaned2, 'utf8');
+        bullet(warn, `Migrated ANTHROPIC_BASE_URL → LLM_BASE_URL`);
+      }
+    }
+
+    // Apply
+    const changes = patchEnvFile(envPath, envVars);
+    for (const change of changes) {
+      if (change.action === 'updated') {
+        bullet(ok, `Updated ${c.bold}${change.key}${c.reset}`);
+      } else {
+        bullet(ok, `Added ${c.bold}${change.key}${c.reset}`);
+      }
     }
   }
 
   // ── Test Connection ──────────────────────────────────────────────────────
 
   blank();
-  const runTest = await confirm('Test the connection?');
-  let testPassed = !runTest; // skip = assume ok
-  if (runTest) {
-    testPassed = await runConnectionTest(clawzempicKey);
+  let testPassed = true;
+  if (args.noTest) {
+    bullet(info, 'Skipping connection test (--no-test)');
+  } else {
+    const runTest = await confirm('Test the connection?');
+    testPassed = !runTest; // skip = assume ok
+    if (runTest) {
+      testPassed = await runConnectionTest(clawzempicKey);
+    }
   }
 
   // ── Done ─────────────────────────────────────────────────────────────────
 
   blank();
   if (testPassed) {
-    box([
+    const doneLines = [
       `${c.green}${c.bold}Setup complete!${c.reset}`,
       '',
       `${c.dim}Dashboard:${c.reset}  ${API_BASE}/v1/auth/portal`,
       `${c.dim}Insights:${c.reset}   ${API_BASE}/v1/insights`,
       `${c.dim}Docs:${c.reset}       ${API_BASE}/docs`,
       '',
-      `${c.yellow}Restart your app to start saving.${c.reset}`,
-    ]);
+    ];
+    if (useOpenClawPath) {
+      doneLines.push(`${c.yellow}Restart your gateway:${c.reset} ${c.cyan}openclaw gateway restart${c.reset}`);
+    } else {
+      doneLines.push(`${c.yellow}Restart your app to start saving.${c.reset}`);
+    }
+    box(doneLines);
   } else {
     box([
       `${c.red}${c.bold}Setup incomplete${c.reset} — connection test failed.`,
       '',
-      `${c.dim}Config was written to ${envFile}, but your key didn't authenticate.${c.reset}`,
+      `${c.dim}Config was written, but your key didn't authenticate.${c.reset}`,
       `${c.dim}Check your key and run:${c.reset} ${c.cyan}npx clawzempic test${c.reset}`,
     ]);
   }
@@ -656,19 +916,14 @@ async function runConnectionTest(apiKey) {
 async function cmdTest(args) {
   banner();
 
-  // Find API key: arg > env > .env file
+  // Find API key: arg > env > auth-profiles > .env
   let apiKey = args.key;
 
   if (!apiKey) {
-    apiKey = process.env.CLAWZEMPIC_API_KEY || process.env.ANTHROPIC_API_KEY;
-  }
-
-  if (!apiKey) {
-    const envPath = join(process.cwd(), '.env');
-    if (existsSync(envPath)) {
-      const content = readFileSync(envPath, 'utf8');
-      const match = content.match(/^(?:CLAWZEMPIC_API_KEY|ANTHROPIC_API_KEY)\s*=\s*(.+)$/m);
-      if (match) apiKey = match[1].trim();
+    const found = findApiKey(process.cwd());
+    if (found) {
+      apiKey = found.key;
+      bullet(info, `Found key in ${c.dim}${found.source}${c.reset}`);
     }
   }
 
@@ -694,15 +949,8 @@ async function cmdStatus(args) {
   // Find API key
   let apiKey = args.key;
   if (!apiKey) {
-    apiKey = process.env.CLAWZEMPIC_API_KEY || process.env.ANTHROPIC_API_KEY;
-  }
-  if (!apiKey) {
-    const envPath = join(process.cwd(), '.env');
-    if (existsSync(envPath)) {
-      const content = readFileSync(envPath, 'utf8');
-      const match = content.match(/^(?:CLAWZEMPIC_API_KEY|ANTHROPIC_API_KEY)\s*=\s*(.+)$/m);
-      if (match) apiKey = match[1].trim();
-    }
+    const found = findApiKey(process.cwd());
+    if (found) apiKey = found.key;
   }
 
   if (!apiKey || (!apiKey.startsWith('sk-clwz-') && !apiKey.startsWith('sr_'))) {
@@ -766,66 +1014,152 @@ async function cmdDoctor() {
 
   const dir = process.cwd();
 
-  // 1. Check .env exists
-  const envPath = join(dir, '.env');
-  if (existsSync(envPath)) {
-    bullet(ok, `.env file found`);
-  } else {
-    bullet(fail, `No .env file in current directory`);
-    bullet(info, 'Run `npx clawzempic` to set up.');
-    return cleanup(1);
-  }
+  // Check if OpenClaw v2026.2+
+  const openclawDir = findOpenClawDir(dir);
+  const fw = detectFramework(dir);
 
-  // 2. Check for Clawzempic config
-  const content = readFileSync(envPath, 'utf8');
-  const keyMatch = content.match(/^(?:CLAWZEMPIC_API_KEY|ANTHROPIC_API_KEY)\s*=\s*(.+)$/m);
-  if (keyMatch && (keyMatch[1].startsWith('sk-clwz-') || keyMatch[1].startsWith('sr_'))) {
-    bullet(ok, `Clawzempic API key found`);
-  } else if (keyMatch) {
-    bullet(warn, `API key found but does not look like a Clawzempic key (expected sk-clwz-... or sr_...)`);
-    bullet(info, 'You may be using a direct provider key. Run `npx clawzempic` to set up proxy routing.');
-  } else {
-    bullet(fail, 'No API key found in .env');
-    return cleanup(1);
-  }
+  if (openclawDir && isModernOpenClaw(openclawDir)) {
+    // ── OpenClaw v2026.2+ Doctor ──────────────────────────────────────────
+    bullet(ok, `OpenClaw v2026.2+ detected at ${c.dim}${openclawDir}${c.reset}`);
 
-  // 3. Check base URL
-  const baseUrlMatch = content.match(/^ANTHROPIC_BASE_URL\s*=\s*(.+)$/m);
-  if (baseUrlMatch && baseUrlMatch[1].includes('clawzempic.ai')) {
-    bullet(ok, `Base URL pointing to Clawzempic`);
-  } else if (baseUrlMatch) {
-    bullet(warn, `Base URL set to ${baseUrlMatch[1]} — not pointing to Clawzempic`);
-  } else {
-    bullet(fail, `ANTHROPIC_BASE_URL not set — requests go directly to Anthropic, bypassing Clawzempic`);
-  }
+    // Check auth-profiles.json for clawzempic profile
+    const profilesPath = join(openclawDir, 'auth-profiles.json');
+    let profiles;
+    try {
+      profiles = JSON.parse(readFileSync(profilesPath, 'utf8'));
+    } catch {
+      bullet(fail, 'Could not parse auth-profiles.json');
+      return cleanup(1);
+    }
 
-  // 4. Check framework
-  const fw = detectFramework(dir);
-  if (fw) {
-    bullet(ok, `Framework detected: ${fw.name}`);
-  } else {
-    bullet(info, 'No specific framework detected (generic setup)');
-  }
+    const clawzempicProfile = profiles.profiles?.clawzempic;
+    if (clawzempicProfile) {
+      bullet(ok, `Clawzempic provider profile found`);
+      if (clawzempicProfile.baseUrl?.includes('clawzempic.ai')) {
+        bullet(ok, `Base URL: ${c.dim}${clawzempicProfile.baseUrl}${c.reset}`);
+      } else {
+        bullet(fail, `Base URL is ${c.dim}${clawzempicProfile.baseUrl}${c.reset} — should be ${API_BASE}`);
+      }
+    } else {
+      // Check if any profile points to clawzempic
+      let foundClawzempic = false;
+      for (const [name, profile] of Object.entries(profiles.profiles || {})) {
+        if (profile.baseUrl?.includes('clawzempic.ai')) {
+          bullet(ok, `Clawzempic configured in "${name}" profile (baseUrl: ${c.dim}${profile.baseUrl}${c.reset})`);
+          foundClawzempic = true;
+          break;
+        }
+      }
+      if (!foundClawzempic) {
+        bullet(fail, 'No Clawzempic provider in auth-profiles.json');
+        bullet(info, 'Run `npx clawzempic` to add it.');
+      }
+    }
 
-  // 5. Check docker-compose for OpenClaw
-  for (const f of ['docker-compose.yml', 'docker-compose.yaml']) {
-    if (existsSync(join(dir, f))) {
-      const dcContent = readFileSync(join(dir, f), 'utf8');
-      if (dcContent.includes('env_file') && dcContent.includes('.env')) {
-        bullet(ok, `docker-compose uses .env file`);
-      } else if (dcContent.includes('ANTHROPIC_API_KEY')) {
-        bullet(warn, `docker-compose has hardcoded ANTHROPIC_API_KEY — should use env_file instead`);
+    // Check openclaw.json model config
+    const configPath = join(openclawDir, 'openclaw.json');
+    if (existsSync(configPath)) {
+      try {
+        const config = JSON.parse(readFileSync(configPath, 'utf8'));
+        const model = config.agents?.defaults?.model?.primary || 'not set';
+        if (model.startsWith('clawzempic/')) {
+          bullet(ok, `Default model: ${c.bold}${model}${c.reset}`);
+        } else {
+          bullet(info, `Default model: ${c.dim}${model}${c.reset} (not using clawzempic provider)`);
+        }
+      } catch {
+        bullet(warn, 'Could not parse openclaw.json');
       }
     }
-  }
 
-  // 6. Test connection
-  blank();
-  if (keyMatch && (keyMatch[1].startsWith('sk-clwz-') || keyMatch[1].startsWith('sr_'))) {
-    const success = await runConnectionTest(keyMatch[1]);
-    if (success) {
+    // Check gateway auth
+    const gwAuth = checkGatewayAuth(openclawDir);
+    if (gwAuth.hasAuth) {
+      bullet(ok, `Gateway auth: ${c.bold}${gwAuth.mode}${c.reset}`);
+    } else {
+      bullet(warn, `Gateway auth is ${c.bold}${gwAuth.mode}${c.reset} — v2026.2+ requires a password or token`);
+    }
+
+    // Test connection
+    const apiKeyResult = findApiKey(dir);
+    if (apiKeyResult) {
+      blank();
+      const success = await runConnectionTest(apiKeyResult.key);
+      if (success) {
+        blank();
+        bullet(ok, `${c.green}Everything looks good!${c.reset}`);
+      }
+    } else {
       blank();
-      bullet(ok, `${c.green}Everything looks good!${c.reset}`);
+      bullet(warn, 'No Clawzempic API key found to test connection.');
+    }
+
+  } else {
+    // ── Generic Doctor ────────────────────────────────────────────────────
+
+    // 1. Check .env exists
+    const envPath = join(dir, '.env');
+    if (existsSync(envPath)) {
+      bullet(ok, `.env file found`);
+    } else {
+      bullet(fail, `No .env file in current directory`);
+      if (openclawDir) {
+        bullet(info, `OpenClaw detected but no auth-profiles.json — may be an older version.`);
+      }
+      bullet(info, 'Run `npx clawzempic` to set up.');
+      return cleanup(1);
+    }
+
+    // 2. Check for Clawzempic config
+    const content = readFileSync(envPath, 'utf8');
+    const keyMatch = content.match(/^(?:CLAWZEMPIC_API_KEY|LLM_API_KEY|ANTHROPIC_API_KEY)\s*=\s*(.+)$/m);
+    if (keyMatch && (keyMatch[1].startsWith('sk-clwz-') || keyMatch[1].startsWith('sr_'))) {
+      bullet(ok, `Clawzempic API key found`);
+    } else if (keyMatch) {
+      bullet(warn, `API key found but does not look like a Clawzempic key (expected sk-clwz-... or sr_...)`);
+      bullet(info, 'You may be using a direct provider key. Run `npx clawzempic` to set up proxy routing.');
+    } else {
+      bullet(fail, 'No API key found in .env');
+      return cleanup(1);
+    }
+
+    // 3. Check base URL (check LLM_BASE_URL first, fall back to ANTHROPIC_BASE_URL)
+    const baseUrlMatch = content.match(/^(?:LLM_BASE_URL|ANTHROPIC_BASE_URL)\s*=\s*(.+)$/m);
+    if (baseUrlMatch && baseUrlMatch[1].includes('clawzempic.ai')) {
+      bullet(ok, `Base URL pointing to Clawzempic`);
+    } else if (baseUrlMatch) {
+      bullet(warn, `Base URL set to ${baseUrlMatch[1]} — not pointing to Clawzempic`);
+    } else {
+      bullet(fail, `LLM_BASE_URL not set — requests go directly to your provider, bypassing Clawzempic`);
+    }
+
+    // 4. Check framework
+    if (fw) {
+      bullet(ok, `Framework detected: ${fw.name}`);
+    } else {
+      bullet(info, 'No specific framework detected (generic setup)');
+    }
+
+    // 5. Check docker-compose for OpenClaw
+    for (const f of ['docker-compose.yml', 'docker-compose.yaml']) {
+      if (existsSync(join(dir, f))) {
+        const dcContent = readFileSync(join(dir, f), 'utf8');
+        if (dcContent.includes('env_file') && dcContent.includes('.env')) {
+          bullet(ok, `docker-compose uses .env file`);
+        } else if (dcContent.includes('ANTHROPIC_API_KEY')) {
+          bullet(warn, `docker-compose has hardcoded ANTHROPIC_API_KEY — should use env_file instead`);
+        }
+      }
+    }
+
+    // 6. Test connection
+    blank();
+    if (keyMatch && (keyMatch[1].startsWith('sk-clwz-') || keyMatch[1].startsWith('sr_'))) {
+      const success = await runConnectionTest(keyMatch[1]);
+      if (success) {
+        blank();
+        bullet(ok, `${c.green}Everything looks good!${c.reset}`);
+      }
     }
   }
 
@@ -874,13 +1208,15 @@ function cmdHelp() {
 // ── Arg Parsing ───────────────────────────────────────────────────────────────
 
 function parseArgs(argv) {
-  const args = { command: null, key: null, help: false, version: false };
+  const args = { command: null, key: null, help: false, version: false, yes: false, noTest: false };
   const positional = [];
 
   for (let i = 2; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === '--help' || arg === '-h') args.help = true;
     else if (arg === '--version' || arg === '-v') args.version = true;
+    else if (arg === '--yes' || arg === '-y') args.yes = true;
+    else if (arg === '--no-test') args.noTest = true;
     else if (arg === '--key' && argv[i + 1]) { args.key = argv[++i]; }
     else if (!arg.startsWith('-')) positional.push(arg);
   }
@@ -907,38 +1243,48 @@ process.on('SIGINT', () => {
 
 // ── Main ──────────────────────────────────────────────────────────────────────
 
-const args = parseArgs(process.argv);
-
-if (args.version) {
-  console.log(`clawzempic ${VERSION}`);
-  process.exit(0);
-}
+let globalArgs = null;
 
-if (args.help && !args.command) {
-  cmdHelp();
-  process.exit(0);
-}
+async function main() {
+  const args = parseArgs(process.argv);
+  globalArgs = args;
 
-const command = args.command || 'init';
+  if (args.version) {
+    console.log(`clawzempic ${VERSION}`);
+    process.exit(0);
+  }
 
-switch (command) {
-  case 'init':
-    await cmdInit(args);
-    break;
-  case 'test':
-    await cmdTest(args);
-    break;
-  case 'status':
-    await cmdStatus(args);
-    break;
-  case 'doctor':
-    await cmdDoctor();
-    break;
-  case 'help':
+  if (args.help && !args.command) {
     cmdHelp();
     process.exit(0);
-    break;
-  default:
-    console.error(`Unknown command: ${command}. Run 'npx clawzempic --help' for usage.`);
-    process.exit(1);
+  }
+
+  const command = args.command || 'init';
+
+  switch (command) {
+    case 'init':
+      await cmdInit(args);
+      break;
+    case 'test':
+      await cmdTest(args);
+      break;
+    case 'status':
+      await cmdStatus(args);
+      break;
+    case 'doctor':
+      await cmdDoctor();
+      break;
+    case 'help':
+      cmdHelp();
+      process.exit(0);
+      break;
+    default:
+      console.error(`Unknown command: ${command}. Run 'npx clawzempic --help' for usage.`);
+      process.exit(1);
+  }
 }
+
+main().catch(err => {
+  console.error(`\n  ${c.red}Fatal:${c.reset} ${err.message}\n`);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawzempic",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Intelligent LLM API proxy — prompt caching, smart routing, memory. Drop-in replacement that cuts your Claude API costs 70-95%.",
   "license": "UNLICENSED",
   "type": "module",