clawkit-ai 1.0.0

package/src/dashboard.mjs

@@ -0,0 +1,69 @@
+import { createServer } from 'http';
+import { readFileSync, existsSync } from 'fs';
+import { join, extname } from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { c, log } from './utils.mjs';
+
+const MIME = {
+  '.html': 'text/html',
+  '.css': 'text/css',
+  '.js': 'application/javascript',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+};
+
+export function runDashboard(flags) {
+  const port = parseInt(flags.port) || 8080;
+  const thisDir = fileURLToPath(new URL('.', import.meta.url));
+  const dashDir = join(thisDir, '..', 'dashboard');
+
+  if (!existsSync(join(dashDir, 'index.html'))) {
+    log.err('Dashboard files not found. Reinstall ClawKit.');
+    process.exit(1);
+  }
+
+  const server = createServer((req, res) => {
+    let filePath = req.url === '/' ? '/index.html' : req.url;
+    filePath = filePath.split('?')[0]; // strip query
+    const full = join(dashDir, filePath);
+
+    if (!existsSync(full)) {
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('Not found');
+      return;
+    }
+
+    const ext = extname(full);
+    const mime = MIME[ext] || 'application/octet-stream';
+    try {
+      const data = readFileSync(full);
+      res.writeHead(200, { 'Content-Type': mime });
+      res.end(data);
+    } catch {
+      res.writeHead(500);
+      res.end('Error');
+    }
+  });
+
+  server.listen(port, () => {
+    const url = `http://localhost:${port}`;
+    console.log(`\n  ${c.green}⚡${c.reset} Dashboard running at ${c.cyan}${url}${c.reset}\n`);
+    console.log(`  ${c.dim}Press Ctrl+C to stop${c.reset}\n`);
+
+    // Open browser
+    try {
+      const platform = process.platform;
+      if (platform === 'darwin') execSync(`open ${url}`);
+      else if (platform === 'win32') execSync(`start ${url}`);
+      else execSync(`xdg-open ${url} 2>/dev/null || true`);
+    } catch {}
+  });
+
+  process.on('SIGINT', () => {
+    console.log(`\n  ${c.dim}Shutting down...${c.reset}`);
+    server.close();
+    process.exit(0);
+  });
+}

package/src/doctor.mjs

@@ -0,0 +1,69 @@
+import { existsSync, readFileSync, readdirSync, accessSync, constants } from 'fs';
+import { join } from 'path';
+import { c, log, detectWorkspace, cmdExists } from './utils.mjs';
+
+export function runDoctor() {
+  const checks = [];
+  const pass = (name) => checks.push({ name, ok: true });
+  const fail = (name, hint) => checks.push({ name, ok: false, hint });
+
+  // 1. OpenClaw installed
+  cmdExists('openclaw') ? pass('OpenClaw CLI installed') : fail('OpenClaw CLI installed', 'Install: npm i -g openclaw');
+
+  // 2. Workspace
+  const workspace = detectWorkspace();
+  if (workspace && existsSync(workspace)) {
+    pass('Workspace directory exists');
+  } else {
+    fail('Workspace directory exists', 'Set CLAWKIT_WORKSPACE env var');
+  }
+
+  if (workspace) {
+    // 3. AGENTS.md
+    existsSync(join(workspace, 'AGENTS.md')) ? pass('AGENTS.md present') : fail('AGENTS.md present', 'Run: clawkit init');
+
+    // 4. Config
+    const cfgPath = join(workspace, 'skills', '.clawkit', 'config.json');
+    if (existsSync(cfgPath)) {
+      try { JSON.parse(readFileSync(cfgPath, 'utf8')); pass('Config valid'); }
+      catch { fail('Config valid', 'config.json is corrupt — re-run clawkit init'); }
+    } else {
+      fail('Config valid', 'Run: clawkit init');
+    }
+
+    // 5. Skills
+    const sd = join(workspace, 'skills');
+    if (existsSync(sd)) {
+      const cnt = readdirSync(sd, { withFileTypes: true }).filter(d => d.isDirectory() && !d.name.startsWith('.')).length;
+      cnt > 0 ? pass(`Skills installed (${cnt})`) : fail('Skills installed', 'Run: clawkit init');
+    } else {
+      fail('Skills installed', 'Run: clawkit init');
+    }
+
+    // 6. Consolidation script
+    const cs = join(workspace, 'scripts/nightly-consolidation.sh');
+    if (existsSync(cs)) {
+      try { accessSync(cs, constants.X_OK); pass('Consolidation script executable'); }
+      catch { fail('Consolidation script executable', `Run: chmod +x ${cs}`); }
+    } else {
+      fail('Consolidation script present', 'Run: clawkit init');
+    }
+
+    // 7. Memory dirs
+    existsSync(join(workspace, 'memory/daily')) && existsSync(join(workspace, 'memory/knowledge'))
+      ? pass('Memory directories') : fail('Memory directories', 'Run: clawkit init');
+  }
+
+  // 5. API key
+  process.env.CLAWKIT_API_KEY ? pass('API key set') : fail('API key set', 'Set CLAWKIT_API_KEY env var');
+
+  console.log(`\n${c.bold}${c.cyan}🩺 ClawKit Doctor${c.reset}\n`);
+  for (const ch of checks) {
+    const icon = ch.ok ? `${c.green}✔${c.reset}` : `${c.red}✖${c.reset}`;
+    console.log(`  ${icon} ${ch.name}`);
+    if (!ch.ok && ch.hint) console.log(`    ${c.dim}→ ${ch.hint}${c.reset}`);
+  }
+
+  const passed = checks.filter(c => c.ok).length;
+  console.log(`\n  ${passed}/${checks.length} checks passed\n`);
+}

package/src/init.mjs

@@ -0,0 +1,137 @@
+import { createInterface } from 'readline';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { c, log, detectWorkspace, detectTimezone, today } from './utils.mjs';
+import { readApiKey, parseTier, validateKey } from './validate.mjs';
+import { scaffoldWorkspace, backupWorkspace } from './scaffold.mjs';
+import { installSkills } from './skills.mjs';
+
+function ask(rl, question, defaultVal) {
+  return new Promise((resolve) => {
+    rl.question(`${c.cyan}?${c.reset} ${question} ${c.dim}(${defaultVal})${c.reset} `, (answer) => {
+      resolve(answer.trim() || defaultVal);
+    });
+  });
+}
+
+export async function runInit(flags) {
+  const yes = flags.yes || flags.y;
+  const force = flags.force;
+
+  console.log(`\n${c.bold}${c.magenta}🧰 ClawKit Init${c.reset}\n`);
+
+  // Step 1: Detect workspace
+  log.step(1, 'Detecting workspace...');
+  let workspace = detectWorkspace();
+
+  const rl = !yes ? createInterface({ input: process.stdin, output: process.stdout }) : null;
+
+  if (!workspace && !yes) {
+    workspace = await ask(rl, 'Workspace path:', join(process.env.HOME || '~', '.openclaw', 'workspace'));
+  }
+  if (!workspace) {
+    workspace = join(process.env.HOME || '/tmp', '.openclaw', 'workspace');
+  }
+  mkdirSync(workspace, { recursive: true });
+  log.ok(`Workspace: ${workspace}`);
+
+  // Step 2: Check existing
+  log.step(2, 'Checking existing files...');
+  if (existsSync(join(workspace, 'AGENTS.md'))) {
+    if (!yes && !force) {
+      const overwrite = await ask(rl, 'Existing workspace detected. Backup & overwrite? (y/n):', 'y');
+      if (overwrite.toLowerCase() !== 'y') {
+        log.info('Aborted.');
+        rl?.close();
+        return;
+      }
+    }
+    const bk = backupWorkspace(workspace);
+    log.ok(`Backed up to ${bk}`);
+  } else {
+    log.ok('Clean workspace');
+  }
+
+  // Step 3: Read API key
+  log.step(3, 'Reading API key...');
+  let apiKey = readApiKey();
+  if (!apiKey && !yes) {
+    apiKey = await ask(rl, 'Enter your ClawKit API key (or press enter to skip):', '');
+  }
+  const tier = parseTier(apiKey);
+  if (apiKey) {
+    log.ok(`API key found (tier: ${tier})`);
+  } else {
+    log.warn('No API key — using free tier');
+  }
+
+  // Step 4: Validate
+  log.step(4, 'Validating...');
+  const validation = await validateKey(apiKey);
+  if (!validation.valid && !validation.offline) {
+    log.err(`Validation failed: ${validation.error}`);
+    log.info('Continuing with free tier...');
+  } else if (validation.offline) {
+    log.warn('Offline mode — continuing with key prefix tier');
+  } else {
+    log.ok('API key validated');
+  }
+
+  const effectiveTier = validation.tier || tier;
+
+  // Step 5: Prompts
+  log.step(5, 'Configuration...');
+  const agentName = yes ? 'Atlas' : await ask(rl, 'What should your agent be called?', 'Atlas');
+  const userName = yes ? 'Human' : await ask(rl, "What's your name?", 'Human');
+  const timezone = yes ? detectTimezone() : await ask(rl, 'Your timezone?', detectTimezone());
+
+  rl?.close();
+
+  const vars = { agentName, userName, timezone, tier: effectiveTier, date: today() };
+
+  // Step 6: Scaffold
+  log.step(6, 'Scaffolding workspace...');
+  scaffoldWorkspace(workspace, vars);
+  log.ok('Template files written');
+
+  // Step 7: Skills
+  log.step(7, 'Installing skills...');
+  const skillCount = installSkills(workspace, effectiveTier);
+
+  // Step 8: Config
+  log.step(8, 'Writing config...');
+  const configDir = join(workspace, 'skills', '.clawkit');
+  mkdirSync(configDir, { recursive: true });
+  const config = {
+    version: '1.0.0',
+    tier: effectiveTier,
+    apiKey: apiKey || '',
+    installedAt: new Date().toISOString(),
+    agentName,
+    userName,
+    timezone,
+    features: validation.features || {},
+  };
+  writeFileSync(join(configDir, 'config.json'), JSON.stringify(config, null, 2), 'utf8');
+  log.ok('Config saved');
+
+  // Step 9: Success
+  console.log(`
+${c.green}╔══════════════════════════════════════════════╗
+║  🧰 ClawKit initialized successfully!       ║
+╠══════════════════════════════════════════════╣
+║                                              ║
+║  Agent: ${(agentName + '                    ').slice(0, 36)}║
+║  Tier: ${(effectiveTier + '                     ').slice(0, 37)}║
+║  Skills: ${(skillCount + ' installed              ').slice(0, 35)}║
+║  Memory: 3-layer system active               ║
+║                                              ║
+║  Next steps:                                 ║
+║  1. openclaw gateway restart                 ║
+║  2. Start chatting — your agent is ready!    ║
+║                                              ║
+║  Run clawkit status to check health          ║
+║  Run clawkit upgrade to go Pro               ║
+╚══════════════════════════════════════════════╝${c.reset}
+`);
+}

package/src/scaffold.mjs

@@ -0,0 +1,57 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, cpSync, chmodSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = join(__dirname, '..');
+
+export function replaceVars(text, vars) {
+  return text
+    .replace(/\{\{AGENT_NAME\}\}/g, vars.agentName || 'Atlas')
+    .replace(/\{\{USER_NAME\}\}/g, vars.userName || 'Human')
+    .replace(/\{\{TIMEZONE\}\}/g, vars.timezone || 'UTC')
+    .replace(/\{\{TIER\}\}/g, vars.tier || 'free')
+    .replace(/\{\{DATE\}\}/g, vars.date || new Date().toISOString().slice(0, 10));
+}
+
+const TEMPLATE_FILES = [
+  'AGENTS.md', 'SOUL.md', 'IDENTITY.md', 'USER.md', 'TOOLS.md', 'HEARTBEAT.md',
+  'MEMORY.md', 'LEARNINGS.md', 'PROTOCOL_COST_EFFICIENCY.md', 'SKILLS-INDEX.md',
+  'memory/knowledge/about-me.md', 'tasks/QUEUE.md', 'scripts/nightly-consolidation.sh',
+];
+
+export function scaffoldWorkspace(workspace, vars) {
+  for (const d of ['memory/daily', 'memory/knowledge', 'memory/para', 'tasks', 'scripts', 'skills']) {
+    mkdirSync(join(workspace, d), { recursive: true });
+  }
+
+  for (const f of TEMPLATE_FILES) {
+    const src = join(PKG_ROOT, 'templates', f);
+    const dest = join(workspace, f);
+    mkdirSync(dirname(dest), { recursive: true });
+    const content = readFileSync(src, 'utf8');
+    writeFileSync(dest, replaceVars(content, vars), 'utf8');
+  }
+
+  // Make consolidation script executable
+  const scriptPath = join(workspace, 'scripts/nightly-consolidation.sh');
+  if (existsSync(scriptPath)) {
+    chmodSync(scriptPath, 0o755);
+  }
+}
+
+export function backupWorkspace(workspace) {
+  const backupDir = join(workspace, '.clawkit-backup');
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  const dest = join(backupDir, ts);
+  mkdirSync(dest, { recursive: true });
+  for (const f of TEMPLATE_FILES) {
+    const src = join(workspace, f);
+    if (existsSync(src)) {
+      const d = join(dest, f);
+      mkdirSync(dirname(d), { recursive: true });
+      cpSync(src, d);
+    }
+  }
+  return dest;
+}

package/src/skills.mjs

@@ -0,0 +1,52 @@
+import { readdirSync, readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import { log, cmdExists } from './utils.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = join(__dirname, '..');
+const BUNDLED_DIR = join(PKG_ROOT, 'skills');
+
+const PRO_SKILLS = [
+  'reminder', 'data-analyst', 'automation-workflows', 'sales',
+  'security-monitor', 'nano-pdf', 'pdf-to-structured',
+];
+
+export function installSkills(workspace, tier) {
+  const skillsDir = join(workspace, 'skills');
+  mkdirSync(skillsDir, { recursive: true });
+
+  // Install bundled free skills
+  let count = 0;
+  const entries = readdirSync(BUNDLED_DIR, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const srcSkill = join(BUNDLED_DIR, entry.name, 'SKILL.md');
+    if (!existsSync(srcSkill)) continue;
+    const destDir = join(skillsDir, entry.name);
+    mkdirSync(destDir, { recursive: true });
+    const content = readFileSync(srcSkill, 'utf8');
+    writeFileSync(join(destDir, 'SKILL.md'), content, 'utf8');
+    count++;
+  }
+  log.ok(`Installed ${count} free-tier skills`);
+
+  // Pro skills via clawhub
+  if (tier === 'pro') {
+    if (cmdExists('clawhub')) {
+      for (const slug of PRO_SKILLS) {
+        try {
+          execSync(`clawhub install ${slug} --force`, { cwd: workspace, stdio: 'ignore', timeout: 30000 });
+          log.ok(`Installed pro skill: ${slug}`);
+        } catch {
+          log.warn(`Could not install pro skill: ${slug}`);
+        }
+      }
+    } else {
+      log.warn('clawhub CLI not found — skipping pro skill installation. Run: npm i -g clawhub');
+    }
+  }
+
+  return count;
+}

package/src/status.mjs

@@ -0,0 +1,43 @@
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { c, log, detectWorkspace } from './utils.mjs';
+
+export function runStatus() {
+  const workspace = detectWorkspace();
+  if (!workspace) {
+    log.err('No workspace detected. Set CLAWKIT_WORKSPACE or run from ~/.openclaw/workspace');
+    process.exit(1);
+  }
+
+  const configPath = join(workspace, 'skills', '.clawkit', 'config.json');
+  let config = {};
+  if (existsSync(configPath)) {
+    try { config = JSON.parse(readFileSync(configPath, 'utf8')); } catch { /* ignore */ }
+  }
+
+  const hasAgents = existsSync(join(workspace, 'AGENTS.md'));
+  const hasMemory = existsSync(join(workspace, 'MEMORY.md'));
+  const hasCron = existsSync(join(workspace, 'scripts/nightly-consolidation.sh'));
+
+  let skillCount = 0;
+  const skillsDir = join(workspace, 'skills');
+  if (existsSync(skillsDir)) {
+    skillCount = readdirSync(skillsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory() && d.name !== '.clawkit' && d.name !== '.clawhub')
+      .length;
+  }
+
+  const check = (ok) => ok ? `${c.green}✔${c.reset}` : `${c.red}✖${c.reset}`;
+
+  console.log(`\n${c.bold}${c.cyan}🧰 ClawKit Status${c.reset}\n`);
+  console.log(`  Workspace:  ${workspace}`);
+  console.log(`  Agent:      ${config.agentName || 'Unknown'}`);
+  console.log(`  Tier:       ${config.tier || 'free'}`);
+  console.log(`  Version:    ${config.version || 'unknown'}`);
+  console.log(`  Installed:  ${config.installedAt || 'unknown'}\n`);
+  console.log(`  ${check(hasAgents)} AGENTS.md`);
+  console.log(`  ${check(hasMemory)} Memory system`);
+  console.log(`  ${check(hasCron)} Nightly consolidation`);
+  console.log(`  ${check(skillCount > 0)} Skills (${skillCount} installed)`);
+  console.log();
+}

package/src/update.mjs

@@ -0,0 +1,100 @@
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { createHash } from 'crypto';
+import https from 'https';
+import { c, log, detectWorkspace } from './utils.mjs';
+import { fileURLToPath } from 'url';
+
+function httpGet(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      let body = '';
+      res.on('data', d => body += d);
+      res.on('end', () => resolve(body));
+    }).on('error', reject).setTimeout(8000, function() { this.destroy(); reject(new Error('timeout')); });
+  });
+}
+
+function fileHash(path) {
+  try {
+    return createHash('md5').update(readFileSync(path)).digest('hex');
+  } catch { return null; }
+}
+
+export async function runUpdate(flags) {
+  const pkgDir = join(fileURLToPath(new URL('.', import.meta.url)), '..');
+  let localPkg;
+  try { localPkg = JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf8')); } catch {
+    log.err('Cannot read package.json');
+    process.exit(1);
+  }
+  const currentVersion = localPkg.version;
+
+  console.log(`\n  ${c.cyan}⚡ ClawKit Update Check${c.reset}\n`);
+  console.log(`  Current: v${currentVersion}`);
+
+  // Check latest from npm
+  let latestVersion = null;
+  try {
+    const data = JSON.parse(await httpGet('https://registry.npmjs.org/clawkit/latest'));
+    latestVersion = data.version;
+  } catch {
+    log.warn('Could not check npm registry (offline?)');
+  }
+
+  if (latestVersion) {
+    console.log(`  Latest:  v${latestVersion}`);
+    if (latestVersion !== currentVersion) {
+      console.log(`\n  ${c.yellow}⚠${c.reset} Update available! Run:`);
+      console.log(`  ${c.cyan}npm update -g clawkit${c.reset}\n`);
+    } else {
+      console.log(`  ${c.green}✔${c.reset} You're on the latest version!\n`);
+    }
+  }
+
+  // Check workspace template files
+  const ws = detectWorkspace();
+  if (!ws) {
+    log.warn('No workspace detected. Skipping template check.');
+    return;
+  }
+
+  console.log(`  ${c.dim}Checking workspace templates...${c.reset}`);
+
+  // Template files that ship with clawkit init
+  const templateDir = join(pkgDir, 'templates');
+  const templateFiles = [
+    { template: 'SOUL.md', dest: 'SOUL.md' },
+    { template: 'AGENTS.md', dest: 'AGENTS.md' },
+    { template: 'LEARNINGS.md', dest: 'LEARNINGS.md' },
+  ];
+
+  for (const { template, dest } of templateFiles) {
+    const templatePath = join(templateDir, template);
+    const destPath = join(ws, dest);
+
+    if (!existsSync(templatePath)) continue;
+    if (!existsSync(destPath)) {
+      log.info(`${dest} — missing, would scaffold`);
+      continue;
+    }
+
+    const origHash = fileHash(templatePath);
+    const currentHash = fileHash(destPath);
+
+    if (origHash === currentHash) {
+      log.ok(`${dest} — unchanged, can update`);
+    } else {
+      console.log(`  ${c.yellow}⏭${c.reset}  Skipping ${dest} (customized)`);
+    }
+  }
+
+  // Check skills
+  const skillsDir = join(ws, 'skills');
+  if (existsSync(skillsDir)) {
+    const skills = readdirSync(skillsDir).filter(f => !f.startsWith('.'));
+    console.log(`\n  ${c.dim}Skills installed: ${skills.length}${c.reset}`);
+  }
+
+  console.log('');
+}

package/src/upgrade.mjs

@@ -0,0 +1,104 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { c, log, detectWorkspace } from './utils.mjs';
+
+export async function runUpgrade(flags) {
+  const ws = detectWorkspace();
+  const configDir = ws ? join(ws, 'skills', '.clawkit') : null;
+  const configPath = configDir ? join(configDir, 'config.json') : null;
+
+  let config = {};
+  if (configPath && existsSync(configPath)) {
+    try { config = JSON.parse(readFileSync(configPath, 'utf8')); } catch {}
+  }
+
+  const currentKey = process.env.CLAWKIT_API_KEY || config.apiKey || '';
+  const isPro = currentKey.includes('_pro_');
+
+  // If --key provided, activate pro
+  if (flags.key) {
+    const key = flags.key;
+    if (!key.startsWith('clk_pro_')) {
+      log.err('Invalid Pro key. Keys start with clk_pro_');
+      process.exit(1);
+    }
+
+    // Validate key (basic format check + API call)
+    log.info('Validating Pro key...');
+    let valid = false;
+    try {
+      // Try API validation
+      const https = await import('https');
+      valid = await new Promise((resolve) => {
+        const req = https.request('https://clawkit-api.vercel.app/api/validate-key?key=' + encodeURIComponent(key), (res) => {
+          let body = '';
+          res.on('data', d => body += d);
+          res.on('end', () => {
+            try { resolve(JSON.parse(body).valid === true); } catch { resolve(false); }
+          });
+        });
+        req.on('error', () => resolve(false));
+        req.setTimeout(5000, () => { req.destroy(); resolve(false); });
+        req.end();
+      });
+    } catch {
+      // Offline — accept format-valid keys
+      valid = key.startsWith('clk_pro_');
+    }
+
+    if (!valid) {
+      log.err('Key validation failed. Check your key and try again.');
+      process.exit(1);
+    }
+
+    // Update config
+    if (configDir) {
+      mkdirSync(configDir, { recursive: true });
+      config.apiKey = key;
+      config.tier = 'pro';
+      config.upgradedAt = new Date().toISOString();
+      writeFileSync(configPath, JSON.stringify(config, null, 2));
+    }
+
+    console.log(`\n  ${c.green}🎉 Upgraded to Pro!${c.reset}\n`);
+    console.log(`  ${c.cyan}Key:${c.reset} ${key.slice(0, 12)}...`);
+    console.log(`  ${c.cyan}Features unlocked:${c.reset} Dashboard chat, file editing, premium skills\n`);
+    return;
+  }
+
+  // Already pro?
+  if (isPro) {
+    console.log(`\n  ${c.green}✔${c.reset} You're already on ${c.yellow}Pro${c.reset}!\n`);
+    console.log(`  Key: ${currentKey.slice(0, 12)}...`);
+    return;
+  }
+
+  // Show upgrade pitch
+  console.log(`
+  ${c.yellow}⚡ Upgrade to ClawKit Pro${c.reset}
+
+  ${c.green}What you get:${c.reset}
+  ✔ Full dashboard with live chat
+  ✔ Task management & file editing
+  ✔ Premium skill templates
+  ✔ Priority support
+  ✔ Advanced memory management
+
+  ${c.cyan}Pricing:${c.reset} $10/month
+
+  ${c.dim}Get your Pro key at:${c.reset}
+  ${c.cyan}https://clawkit.net/get-started${c.reset}
+
+  Then run: ${c.bold}clawkit upgrade --key clk_pro_...${c.reset}
+`);
+
+  // Open browser
+  try {
+    const url = 'https://clawkit.net/get-started';
+    const platform = process.platform;
+    if (platform === 'darwin') execSync(`open ${url}`);
+    else if (platform === 'win32') execSync(`start ${url}`);
+    else execSync(`xdg-open ${url} 2>/dev/null || true`);
+  } catch {}
+}