profclaw 2.0.0 → 2.3.0

package/dist/cli/commands/init.js

@@ -0,0 +1,381 @@
+/**
+ * CLI Init Command
+ *
+ * Scans the current project directory and generates a `.profclaw/context.md`
+ * file describing the tech stack, structure, build/test commands, and conventions.
+ *
+ * Usage:
+ *   profclaw init          # interactive (asks before overwriting)
+ *   profclaw init --force  # overwrite without prompting
+ */
+import { Command } from 'commander';
+import { existsSync, readFileSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { confirm } from '@inquirer/prompts';
+import { success, error, info, spinner } from '../utils/output.js';
+// ── Manifest readers ──────────────────────────────────────────────────────────
+function readJson(filePath) {
+    try {
+        return JSON.parse(readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function readText(filePath) {
+    try {
+        return readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function fileExists(filePath) {
+    return existsSync(filePath);
+}
+// ── Detectors ─────────────────────────────────────────────────────────────────
+function detectLanguage(cwd) {
+    if (fileExists(path.join(cwd, 'Cargo.toml')))
+        return 'Rust';
+    if (fileExists(path.join(cwd, 'go.mod')))
+        return 'Go';
+    if (fileExists(path.join(cwd, 'pyproject.toml')) || fileExists(path.join(cwd, 'setup.py')))
+        return 'Python';
+    if (fileExists(path.join(cwd, 'tsconfig.json')))
+        return 'TypeScript';
+    if (fileExists(path.join(cwd, 'package.json')))
+        return 'JavaScript';
+    if (fileExists(path.join(cwd, 'pom.xml')) || fileExists(path.join(cwd, 'build.gradle')))
+        return 'Java';
+    if (fileExists(path.join(cwd, 'mix.exs')))
+        return 'Elixir';
+    if (fileExists(path.join(cwd, 'Gemfile')))
+        return 'Ruby';
+    return 'Unknown';
+}
+function detectPackageManager(cwd) {
+    if (fileExists(path.join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (fileExists(path.join(cwd, 'yarn.lock')))
+        return 'yarn';
+    if (fileExists(path.join(cwd, 'bun.lockb')))
+        return 'bun';
+    if (fileExists(path.join(cwd, 'package-lock.json')))
+        return 'npm';
+    return 'npm';
+}
+function detectFramework(cwd, pkg) {
+    const deps = {
+        ...(pkg?.dependencies ?? {}),
+        ...(pkg?.devDependencies ?? {}),
+    };
+    const hasDep = (name) => name in deps;
+    if (hasDep('next'))
+        return 'Next.js';
+    if (hasDep('nuxt'))
+        return 'Nuxt';
+    if (hasDep('astro'))
+        return 'Astro';
+    if (hasDep('remix'))
+        return 'Remix';
+    if (hasDep('@sveltejs/kit'))
+        return 'SvelteKit';
+    if (hasDep('svelte'))
+        return 'Svelte';
+    if (hasDep('react'))
+        return 'React';
+    if (hasDep('vue'))
+        return 'Vue';
+    if (hasDep('express'))
+        return 'Express';
+    if (hasDep('fastify'))
+        return 'Fastify';
+    if (hasDep('hono'))
+        return 'Hono';
+    if (hasDep('@nestjs/core'))
+        return 'NestJS';
+    if (hasDep('commander'))
+        return 'CLI (commander)';
+    if (hasDep('ink'))
+        return 'CLI (ink/TUI)';
+    if (fileExists(path.join(cwd, 'pyproject.toml'))) {
+        const content = readText(path.join(cwd, 'pyproject.toml')) ?? '';
+        if (content.includes('fastapi'))
+            return 'FastAPI';
+        if (content.includes('flask'))
+            return 'Flask';
+        if (content.includes('django'))
+            return 'Django';
+    }
+    if (fileExists(path.join(cwd, 'Cargo.toml'))) {
+        const content = readText(path.join(cwd, 'Cargo.toml')) ?? '';
+        if (content.includes('axum'))
+            return 'Axum';
+        if (content.includes('actix-web'))
+            return 'Actix-web';
+        if (content.includes('rocket'))
+            return 'Rocket';
+    }
+    if (fileExists(path.join(cwd, 'go.mod'))) {
+        const content = readText(path.join(cwd, 'go.mod')) ?? '';
+        if (content.includes('gin-gonic'))
+            return 'Gin';
+        if (content.includes('echo'))
+            return 'Echo';
+        if (content.includes('fiber'))
+            return 'Fiber';
+    }
+    return 'None detected';
+}
+function detectBuildAndTestCommands(cwd, pkg, pm, language) {
+    const scripts = pkg?.scripts ?? {};
+    const run = (script) => `${pm} run ${script}`;
+    const build = scripts['build'] ? run('build') :
+        language === 'Rust' ? 'cargo build --release' :
+            language === 'Go' ? 'go build ./...' :
+                language === 'Python' ? (fileExists(path.join(cwd, 'pyproject.toml')) ? 'python -m build' : 'python setup.py build') :
+                    scripts['compile'] ? run('compile') :
+                        'N/A';
+    const test = scripts['test'] ? run('test') :
+        language === 'Rust' ? 'cargo test' :
+            language === 'Go' ? 'go test ./...' :
+                language === 'Python' ? 'pytest' :
+                    scripts['check'] ? run('check') :
+                        'N/A';
+    const dev = scripts['dev'] ? run('dev') :
+        scripts['start'] ? run('start') :
+            scripts['serve'] ? run('serve') :
+                'N/A';
+    return { build, test, dev };
+}
+function detectKeyDirs(cwd) {
+    const candidates = [
+        { name: 'src', purpose: 'Source code' },
+        { name: 'app', purpose: 'Application code' },
+        { name: 'lib', purpose: 'Library / shared utilities' },
+        { name: 'packages', purpose: 'Monorepo packages' },
+        { name: 'apps', purpose: 'Monorepo applications' },
+        { name: 'tests', purpose: 'Test files' },
+        { name: 'test', purpose: 'Test files' },
+        { name: '__tests__', purpose: 'Jest test files' },
+        { name: 'docs', purpose: 'Documentation' },
+        { name: 'scripts', purpose: 'Build / utility scripts' },
+        { name: 'public', purpose: 'Static assets' },
+        { name: 'assets', purpose: 'Static assets' },
+        { name: 'api', purpose: 'API layer' },
+        { name: 'components', purpose: 'UI components' },
+        { name: 'pages', purpose: 'Page components / routes' },
+        { name: 'hooks', purpose: 'React hooks' },
+        { name: 'services', purpose: 'Service / business logic layer' },
+        { name: 'utils', purpose: 'Utility functions' },
+        { name: 'config', purpose: 'Configuration files' },
+        { name: 'migrations', purpose: 'Database migrations' },
+        { name: 'prisma', purpose: 'Prisma schema and migrations' },
+        { name: 'drizzle', purpose: 'Drizzle ORM schema' },
+        { name: '.github', purpose: 'GitHub Actions / workflows' },
+        { name: 'docker', purpose: 'Docker configuration' },
+        { name: 'infra', purpose: 'Infrastructure / IaC' },
+        { name: 'k8s', purpose: 'Kubernetes manifests' },
+    ];
+    return candidates
+        .filter(c => fileExists(path.join(cwd, c.name)))
+        .map(c => ({ path: c.name, purpose: c.purpose }));
+}
+function detectConventions(cwd, pkg) {
+    const conventions = [];
+    // Linting
+    if (fileExists(path.join(cwd, '.eslintrc.js')) ||
+        fileExists(path.join(cwd, '.eslintrc.json')) ||
+        fileExists(path.join(cwd, 'eslint.config.js')) ||
+        fileExists(path.join(cwd, 'eslint.config.ts'))) {
+        conventions.push('ESLint for linting');
+    }
+    if (fileExists(path.join(cwd, '.prettierrc')) ||
+        fileExists(path.join(cwd, '.prettierrc.json')) ||
+        fileExists(path.join(cwd, 'prettier.config.js')) ||
+        fileExists(path.join(cwd, 'prettier.config.ts'))) {
+        conventions.push('Prettier for formatting');
+    }
+    if (fileExists(path.join(cwd, 'biome.json')) || fileExists(path.join(cwd, 'biome.jsonc'))) {
+        conventions.push('Biome for linting and formatting');
+    }
+    // Editor config
+    if (fileExists(path.join(cwd, '.editorconfig'))) {
+        const content = readText(path.join(cwd, '.editorconfig')) ?? '';
+        const indentMatch = content.match(/indent_style\s*=\s*(\w+)/);
+        const sizeMatch = content.match(/indent_size\s*=\s*(\d+)/);
+        if (indentMatch && sizeMatch) {
+            conventions.push(`${indentMatch[1] === 'tab' ? 'Tabs' : `${sizeMatch[1]}-space`} indentation (from .editorconfig)`);
+        }
+    }
+    // TypeScript strictness
+    if (fileExists(path.join(cwd, 'tsconfig.json'))) {
+        const tsconfig = readJson(path.join(cwd, 'tsconfig.json'));
+        const co = tsconfig?.compilerOptions;
+        if (co?.strict === true)
+            conventions.push('TypeScript strict mode enabled');
+        if (co?.noUncheckedIndexedAccess === true)
+            conventions.push('noUncheckedIndexedAccess enforced');
+    }
+    // Git hooks
+    if (fileExists(path.join(cwd, '.husky')))
+        conventions.push('Husky git hooks');
+    // Commit conventions
+    if (fileExists(path.join(cwd, 'commitlint.config.js')) ||
+        fileExists(path.join(cwd, 'commitlint.config.ts'))) {
+        conventions.push('commitlint for conventional commits');
+    }
+    const scripts = pkg?.scripts ?? {};
+    if (scripts['lint'])
+        conventions.push(`Lint command: \`${scripts['lint']}\``);
+    if (scripts['format'])
+        conventions.push(`Format command: \`${scripts['format']}\``);
+    if (scripts['typecheck'] || scripts['type-check']) {
+        conventions.push(`Type-check command: \`${scripts['typecheck'] ?? scripts['type-check']}\``);
+    }
+    return conventions;
+}
+function detectRecentActivity(cwd) {
+    try {
+        const log = execSync('git log --oneline --no-merges -10', { cwd, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        if (!log)
+            return 'No git history found.';
+        return log;
+    }
+    catch {
+        return 'No git repository or git unavailable.';
+    }
+}
+function extractDescription(cwd, pkg) {
+    if (pkg?.description && typeof pkg.description === 'string' && pkg.description.trim()) {
+        return pkg.description.trim();
+    }
+    const readme = readText(path.join(cwd, 'README.md')) ?? readText(path.join(cwd, 'readme.md'));
+    if (readme) {
+        // Take the first non-heading paragraph (strip markdown headings)
+        const lines = readme.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('!') && trimmed.length > 20) {
+                return trimmed.replace(/[*_`]/g, '').slice(0, 200);
+            }
+        }
+    }
+    return 'No description found. Add one in README.md or package.json.';
+}
+// ── Main scan function ────────────────────────────────────────────────────────
+async function scanProject(cwd) {
+    const pkg = readJson(path.join(cwd, 'package.json'));
+    const language = detectLanguage(cwd);
+    const pm = detectPackageManager(cwd);
+    const framework = detectFramework(cwd, pkg);
+    const { build, test, dev } = detectBuildAndTestCommands(cwd, pkg, pm, language);
+    const keyDirs = detectKeyDirs(cwd);
+    const conventions = detectConventions(cwd, pkg);
+    const recentActivity = detectRecentActivity(cwd);
+    const description = extractDescription(cwd, pkg);
+    const name = pkg?.name ?? path.basename(cwd);
+    return {
+        name,
+        description,
+        language,
+        framework,
+        buildCommand: build,
+        testCommand: test,
+        devCommand: dev,
+        keyDirs,
+        conventions,
+        recentActivity,
+        packageManager: pm,
+    };
+}
+// ── Context file generator ────────────────────────────────────────────────────
+function generateContextMarkdown(info) {
+    const now = new Date().toISOString().slice(0, 10);
+    const structureLines = info.keyDirs.length > 0
+        ? info.keyDirs.map(d => `- \`${d.path}/\` — ${d.purpose}`).join('\n')
+        : '- No key directories detected automatically.';
+    const conventionLines = info.conventions.length > 0
+        ? info.conventions.map(c => `- ${c}`).join('\n')
+        : '- No convention files detected.';
+    return `# Project Context
+> Auto-generated by \`profclaw init\` on ${now}. Edit freely — this file is yours.
+
+## Overview
+
+${info.description}
+
+**Project name:** \`${info.name}\`
+
+## Tech Stack
+
+- **Language:** ${info.language}
+- **Framework:** ${info.framework}
+- **Package manager:** ${info.packageManager}
+- **Build:** \`${info.buildCommand}\`
+- **Test:** \`${info.testCommand}\`
+- **Dev server:** \`${info.devCommand}\`
+
+## Structure
+
+${structureLines}
+
+## Conventions
+
+${conventionLines}
+
+## Recent Activity
+
+\`\`\`
+${info.recentActivity}
+\`\`\`
+`;
+}
+// ── Command ───────────────────────────────────────────────────────────────────
+export function initCommand() {
+    const cmd = new Command('init')
+        .description('Scan the project and generate .profclaw/context.md')
+        .option('-f, --force', 'Overwrite existing context.md without prompting')
+        .option('--dir <path>', 'Project directory to scan (default: cwd)')
+        .action(async (options) => {
+        const cwd = options.dir ? path.resolve(options.dir) : process.cwd();
+        const outputDir = path.join(cwd, '.profclaw');
+        const outputPath = path.join(outputDir, 'context.md');
+        // Check for existing file
+        if (fileExists(outputPath) && !options.force) {
+            const overwrite = await confirm({
+                message: '.profclaw/context.md already exists. Overwrite?',
+                default: false,
+            });
+            if (!overwrite) {
+                info('Aborted. Use --force to overwrite without prompting.');
+                return;
+            }
+        }
+        const spin = spinner('Scanning project...').start();
+        try {
+            const projectInfo = await scanProject(cwd);
+            spin.stop();
+            const markdown = generateContextMarkdown(projectInfo);
+            await fs.mkdir(outputDir, { recursive: true });
+            await fs.writeFile(outputPath, markdown, 'utf-8');
+            success(`Context written to .profclaw/context.md`);
+            console.log('');
+            console.log(`  Project : ${projectInfo.name}`);
+            console.log(`  Language: ${projectInfo.language}`);
+            console.log(`  Framework: ${projectInfo.framework}`);
+            console.log(`  Dirs scanned: ${projectInfo.keyDirs.length}`);
+            console.log('');
+            info('Edit .profclaw/context.md to add your own notes and conventions.');
+        }
+        catch (err) {
+            spin.stop();
+            error(err instanceof Error ? err.message : 'Init failed');
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=init.js.map

package/dist/cli/commands/onboard.js

@@ -11,12 +11,40 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import figlet from 'figlet';
-import { select, search, input, Separator } from '@inquirer/prompts';
+import { select, search, input, confirm, Separator } from '@inquirer/prompts';
 import { existsSync, writeFileSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { execSync } from 'node:child_process';
 import { success, error, info, warn, spinner } from '../utils/output.js';
 import { PROVIDER_CATALOG, PROVIDER_ENV_KEYS } from '../providers.js';
+/** Returns true if an env var name should have its value masked. */
+function isSensitiveKey(key) {
+    return key.includes('KEY') || key.includes('TOKEN') || key.includes('SECRET');
+}
+/** Mask an API key for display — shows first 8 chars and last 4, dots in between. */
+function maskApiKey(key) {
+    if (key.length <= 12)
+        return key.slice(0, 4) + '•'.repeat(key.length - 4);
+    return key.slice(0, 8) + '•'.repeat(8) + key.slice(-4);
+}
+/** Format a generated env file for display with sensitive values masked. */
+function formatEnvPreview(content) {
+    return content.split('\n')
+        .map(line => {
+        if (line.startsWith('#') || line.trim() === '')
+            return chalk.dim(`  ${line}`);
+        const eqIndex = line.indexOf('=');
+        if (eqIndex === -1)
+            return chalk.dim(`  ${line}`);
+        const key = line.slice(0, eqIndex);
+        const value = line.slice(eqIndex + 1);
+        if (isSensitiveKey(key)) {
+            return `  ${chalk.cyan(key)}=${chalk.yellow(maskApiKey(value))}`;
+        }
+        return `  ${chalk.cyan(key)}=${chalk.white(value)}`;
+    })
+        .join('\n');
+}
 /** Render a step header with progress bar. */
 function stepHeader(step, total, title) {
     const barLen = 20;
@@ -148,6 +176,89 @@ function generateEnvFile(opts) {
     }
     return lines.join('\n');
 }
+const KEY_FORMAT_PREFIXES = {
+    anthropic: 'sk-ant-',
+    openai: 'sk-',
+    groq: 'gsk_',
+};
+async function validateProviderKey(providerKey, apiKey) {
+    // Fast-fail: format check for known prefix patterns
+    const expectedPrefix = KEY_FORMAT_PREFIXES[providerKey];
+    if (expectedPrefix && !apiKey.startsWith(expectedPrefix)) {
+        return {
+            valid: false,
+            error: `Key should start with "${expectedPrefix}"`,
+        };
+    }
+    // Ollama uses a local URL, no key validation needed
+    if (providerKey === 'ollama') {
+        return { valid: true };
+    }
+    // Lightweight API call to verify the key works
+    try {
+        let response;
+        if (providerKey === 'anthropic') {
+            response = await fetch('https://api.anthropic.com/v1/messages', {
+                method: 'POST',
+                signal: AbortSignal.timeout(5000),
+                headers: {
+                    'x-api-key': apiKey,
+                    'anthropic-version': '2023-06-01',
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify({
+                    model: 'claude-3-haiku-20240307',
+                    max_tokens: 1,
+                    messages: [{ role: 'user', content: 'hi' }],
+                }),
+            });
+        }
+        else if (providerKey === 'openai') {
+            response = await fetch('https://api.openai.com/v1/models', {
+                signal: AbortSignal.timeout(5000),
+                headers: { Authorization: `Bearer ${apiKey}` },
+            });
+        }
+        else if (providerKey === 'google') {
+            response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${encodeURIComponent(apiKey)}`, { signal: AbortSignal.timeout(5000) });
+        }
+        else if (providerKey === 'groq') {
+            response = await fetch('https://api.groq.com/openai/v1/models', {
+                signal: AbortSignal.timeout(5000),
+                headers: { Authorization: `Bearer ${apiKey}` },
+            });
+        }
+        else {
+            // Provider not supported for live validation — skip
+            return { valid: true };
+        }
+        if (response.ok) {
+            return { valid: true };
+        }
+        // Parse error message from response body when possible
+        let detail;
+        try {
+            const body = (await response.json());
+            detail = body?.error?.message ?? (typeof body?.message === 'string' ? body.message : undefined);
+        }
+        catch {
+            // ignore parse failure
+        }
+        return {
+            valid: false,
+            error: detail ?? `HTTP ${response.status}`,
+        };
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === 'TimeoutError') {
+            return { valid: false, error: 'Request timed out (5s)' };
+        }
+        return {
+            valid: false,
+            error: err instanceof Error ? err.message : 'Network error',
+        };
+    }
+}
 // Interactive Onboarding
 async function runInteractive() {
     const banner = figlet.textSync('profClaw', { font: 'Standard' });
@@ -364,28 +475,56 @@ async function runInteractive() {
                 success(`${chosen.name} already configured from ${chosen.envVar}`);
             }
             else {
-                try {
-                    const keyInput = await input({
-                        message: chosen.envVar,
-                        theme: { prefix: '  ' },
-                    });
-                    if (keyInput) {
+                let configured = false;
+                while (!configured) {
+                    let keyInput;
+                    try {
+                        keyInput = await input({
+                            message: chosen.envVar,
+                            theme: { prefix: '  ' },
+                        });
+                    }
+                    catch {
+                        warn('Input cancelled, skipping provider.');
+                        break;
+                    }
+                    if (!keyInput) {
+                        warn('No key provided, skipping.');
+                        break;
+                    }
+                    const verifySpin = spinner('Verifying API key...');
+                    verifySpin.start();
+                    const validation = await validateProviderKey(chosen.key, keyInput);
+                    verifySpin.stop();
+                    if (validation.valid) {
                         if (chosen.key === 'anthropic')
                             anthropicKey = keyInput;
                         else if (chosen.key === 'openai')
                             openaiKey = keyInput;
-                        else {
+                        else
                             process.env[chosen.envVar] = keyInput;
-                        }
                         success(`${chosen.name} configured.`);
+                        configured = true;
                     }
                     else {
-                        warn('No key provided, skipping.');
+                        error(`Invalid key: ${validation.error ?? 'verification failed'}`);
+                        let retry = false;
+                        try {
+                            retry = await confirm({
+                                message: 'Re-enter the key?',
+                                default: true,
+                                theme: { prefix: '  ' },
+                            });
+                        }
+                        catch {
+                            // cancelled
+                        }
+                        if (!retry) {
+                            warn(`Skipping ${chosen.name}.`);
+                            break;
+                        }
                     }
                 }
-                catch {
-                    warn('Input cancelled, skipping provider.');
-                }
             }
         }
         else {
@@ -411,13 +550,30 @@ async function runInteractive() {
             ollamaUrl,
             extraEnvVars,
         });
+        console.log(chalk.bold.white('\n  Configuration Preview:\n'));
+        console.log(formatEnvPreview(envContent));
+        console.log('');
+        let writeConfirmed = true;
         try {
-            writeFileSync(envPath, envContent, { mode: 0o600 });
-            success('.env file created.');
+            writeConfirmed = await confirm({
+                message: 'Write this configuration to .env?',
+                default: true,
+                theme: { prefix: '  ' },
+            });
         }
-        catch (err) {
-            error(`Failed to write .env: ${err instanceof Error ? err.message : 'unknown'}`);
-            info('Create .env manually with the values above.');
+        catch { /* Ctrl+C — keep default true */ }
+        if (!writeConfirmed) {
+            warn('Skipped .env write. You can create it manually.');
+        }
+        else {
+            try {
+                writeFileSync(envPath, envContent, { mode: 0o600 });
+                success('.env file created.');
+            }
+            catch (err) {
+                error(`Failed to write .env: ${err instanceof Error ? err.message : 'unknown'}`);
+                info('Create .env manually with the values above.');
+            }
         }
     }
     else {
@@ -437,21 +593,44 @@ async function runInteractive() {
             keysToWrite['OPENAI_API_KEY'] = openaiKey;
         if (ollamaUrl)
             keysToWrite['OLLAMA_BASE_URL'] = ollamaUrl;
-        for (const [key, value] of Object.entries(keysToWrite)) {
-            if (content.includes(`${key}=`)) {
-                content = content.replace(new RegExp(`${key}=.*`), `${key}=${value}`);
-            }
-            else {
-                content += `${key}=${value}\n`;
-            }
+        // Show preview of what will change
+        const allUpdates = { PROFCLAW_MODE: mode, ...keysToWrite };
+        console.log(chalk.bold.white('\n  Changes to existing .env:\n'));
+        for (const [key, value] of Object.entries(allUpdates)) {
+            const masked = isSensitiveKey(key) ? maskApiKey(value) : value;
+            const action = content.includes(`${key}=`) ? chalk.yellow('update') : chalk.green('add');
+            console.log(`  [${action}] ${chalk.cyan(key)}=${chalk.white(masked)}`);
+        }
+        console.log('');
+        let writeConfirmed = true;
+        try {
+            writeConfirmed = await confirm({
+                message: 'Apply these changes to .env?',
+                default: true,
+                theme: { prefix: '  ' },
+            });
         }
-        writeFileSync(envPath, content);
-        const keyCount = Object.keys(keysToWrite).length;
-        if (keyCount > 0) {
-            success(`PROFCLAW_MODE=${mode} + ${keyCount} provider key(s) saved to .env`);
+        catch { /* Ctrl+C — keep default true */ }
+        if (!writeConfirmed) {
+            warn('Skipped .env update. You can edit it manually.');
         }
         else {
-            success(`PROFCLAW_MODE=${mode} set in .env`);
+            for (const [key, value] of Object.entries(keysToWrite)) {
+                if (content.includes(`${key}=`)) {
+                    content = content.replace(new RegExp(`${key}=.*`), `${key}=${value}`);
+                }
+                else {
+                    content += `${key}=${value}\n`;
+                }
+            }
+            writeFileSync(envPath, content);
+            const keyCount = Object.keys(keysToWrite).length;
+            if (keyCount > 0) {
+                success(`PROFCLAW_MODE=${mode} + ${keyCount} provider key(s) saved to .env`);
+            }
+            else {
+                success(`PROFCLAW_MODE=${mode} set in .env`);
+            }
         }
     }
     // Steps 5-6: Delegate to setup wizard for admin account + registration
@@ -523,6 +702,7 @@ export function onboardCommand() {
             else {
                 await runInteractive();
             }
+            process.exit(0);
         }
         catch (err) {
             error(err instanceof Error ? err.message : 'Onboarding failed');