profclaw 0.0.1-beta.3 → 2.3.0

package/dist/cli/commands/setup.js

@@ -11,14 +11,28 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import figlet from 'figlet';
-import { select, input, password as passwordPrompt, confirm } from '@inquirer/prompts';
+import { select, search, input, password as passwordPrompt, confirm, Separator } from '@inquirer/prompts';
 import { randomUUID } from 'crypto';
 import { eq } from 'drizzle-orm';
-import { initStorage, getDb, saveProviderConfig } from '../../storage/index.js';
+import { spawn, execFile } from 'child_process';
+import { existsSync, mkdirSync, openSync } from 'node:fs';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import * as os from 'os';
+import { createServer } from 'net';
+import { initStorage, getDb, closeStorage, saveProviderConfig, loadAllProviderConfigs } from '../../storage/index.js';
 import { users, inviteCodes } from '../../storage/schema.js';
+import { PROVIDER_CATALOG } from '../providers.js';
 import { hashPassword, validatePasswordStrength, generateRecoveryCodes, hashRecoveryCodes, generateInviteCode, hashInviteCode, } from '../../auth/password.js';
 import { updateSettings } from '../../settings/index.js';
 import { success, error, info, warn, spinner } from '../utils/output.js';
+/** Render a step header with progress bar. */
+function stepHeader(step, total, title) {
+    const barLen = 20;
+    const filled = Math.round((step / total) * barLen);
+    const bar = chalk.cyan('━'.repeat(filled)) + chalk.dim('━'.repeat(barLen - filled));
+    console.log(`\n  ${bar}  ${chalk.dim(`${step}/${total}`)}  ${chalk.bold.white(title)}\n`);
+}
 // Helpers
 function showBanner() {
     const banner = figlet.textSync('profClaw', {
@@ -122,32 +136,46 @@ function hasEnvKey(key) {
     return !!val && val !== '' && !val.startsWith('sk-ant-xxxx') && !val.startsWith('sk-xxxx');
 }
 // Step 1: System Check
+async function detectConfiguredProvider() {
+    // Check env vars first
+    for (const p of PROVIDER_CATALOG) {
+        if (hasEnvKey(p.envVar))
+            return p.name;
+    }
+    // Check database (saved via saveProviderConfig)
+    try {
+        const saved = await loadAllProviderConfigs();
+        const enabled = saved.find(s => s.enabled);
+        if (enabled) {
+            const match = PROVIDER_CATALOG.find(p => p.key === enabled.type);
+            return match ? `${match.name} (saved)` : enabled.type;
+        }
+    }
+    catch { /* db not ready yet */ }
+    return null;
+}
 async function stepSystemCheck(db) {
-    console.log(chalk.bold.white('\n  Step 1: System Check\n'));
     const spin = spinner('Checking system...');
     spin.start();
     const redisOk = await checkRedis();
     const hasAdmin = await checkAdminExists(db);
-    const hasAnthropicKey = hasEnvKey('ANTHROPIC_API_KEY');
-    const hasOpenAIKey = hasEnvKey('OPENAI_API_KEY');
+    const providerName = await detectConfiguredProvider();
+    const hasProvider = !!providerName;
     spin.stop();
-    const mark = (ok) => (ok ? chalk.green('  ✓') : chalk.red('  ✗'));
+    const mark = (ok) => (ok ? chalk.green('  \u2713') : chalk.red('  \u2717'));
     console.log(`${mark(redisOk)} Redis: ${redisOk ? 'connected' : 'not reachable'}`);
     console.log(`${mark(hasAdmin)} Admin account: ${hasAdmin ? 'exists' : 'not created'}`);
-    console.log(`${mark(hasAnthropicKey || hasOpenAIKey)} AI provider: ${hasAnthropicKey ? 'Anthropic key found' :
-        hasOpenAIKey ? 'OpenAI key found' :
-            'not configured'}`);
+    console.log(`${mark(hasProvider)} AI provider: ${providerName || 'not configured'}`);
     if (!redisOk) {
         warn('Redis is required for task processing.');
         info('Start Redis: docker compose up redis -d');
     }
-    return { redisOk, hasAdmin, hasAnthropicKey, hasOpenAIKey };
+    return { redisOk, hasAdmin, hasProvider, providerName };
 }
 // Step 2: AI Provider
 async function stepAiProvider(status) {
-    if (status.hasAnthropicKey || status.hasOpenAIKey) {
-        const provider = status.hasAnthropicKey ? 'Anthropic' : 'OpenAI';
-        info(`AI provider already configured (${provider} from env).`);
+    if (status.hasProvider) {
+        info(`AI provider already configured (${status.providerName}).`);
         try {
             const reconfigure = await confirm({
                 message: 'Reconfigure AI provider?',
@@ -155,22 +183,63 @@ async function stepAiProvider(status) {
                 theme,
             });
             if (!reconfigure)
-                return 'skip';
+                return status.providerName || 'configured';
         }
         catch {
-            return 'skip';
+            return status.providerName || 'configured';
         }
     }
+    // Detect which providers already have keys
+    const detected = new Set();
+    for (const p of PROVIDER_CATALOG) {
+        if (process.env[p.envVar])
+            detected.add(p.key);
+    }
+    // Check Ollama service
+    const ollamaRunning = await checkOllama(process.env.OLLAMA_BASE_URL || 'http://localhost:11434');
+    if (ollamaRunning)
+        detected.add('ollama');
     let choice;
     try {
-        choice = await select({
-            message: 'Select AI Provider',
-            choices: [
-                { name: `Anthropic ${chalk.green('(recommended)')}`, value: 'anthropic', description: 'Claude 4.x, 3.5 Sonnet' },
-                { name: 'OpenAI', value: 'openai', description: 'GPT-4o, o1, o3' },
-                { name: `Ollama ${chalk.cyan('(free, local)')}`, value: 'ollama', description: 'Llama, Mistral, Qwen - runs on your machine' },
-                { name: chalk.dim('Skip for now'), value: 'skip', description: 'Configure later in Settings' },
-            ],
+        choice = await search({
+            message: 'Select AI provider (type to filter, arrows to navigate)',
+            pageSize: 15,
+            source: (term) => {
+                const results = [];
+                const filter = (term || '').toLowerCase();
+                let lastCategory = '';
+                for (const p of PROVIDER_CATALOG) {
+                    if (filter && ![p.name, p.key, p.models, p.category, p.tag]
+                        .some(s => s.toLowerCase().includes(filter))) {
+                        continue;
+                    }
+                    if (p.category !== lastCategory) {
+                        if (results.length > 0)
+                            results.push(new Separator());
+                        results.push(new Separator(chalk.bold.cyan(` ${p.category} `)));
+                        lastCategory = p.category;
+                    }
+                    const det = detected.has(p.key) ? chalk.green(' *') : '';
+                    const ollamaTag = p.key === 'ollama' && ollamaRunning ? 'detected' : p.tag;
+                    const tag = ollamaTag ? ` ${chalk.dim(`[${ollamaTag}]`)}` : '';
+                    results.push({
+                        name: `${p.name.padEnd(16)} ${chalk.dim(p.models)}${tag}${det}`,
+                        value: p.key,
+                        description: p.envVar,
+                        short: p.name,
+                    });
+                }
+                if (!filter || 'skip'.includes(filter)) {
+                    results.push(new Separator());
+                    results.push({
+                        name: chalk.dim('Skip for now'),
+                        value: 'skip',
+                        description: 'Configure later in Settings',
+                        short: 'Skip',
+                    });
+                }
+                return results;
+            },
             theme,
         });
     }
@@ -181,58 +250,61 @@ async function stepAiProvider(status) {
         info('AI provider skipped. You can configure it later in Settings.');
         return 'skip';
     }
-    if (choice === 'anthropic') {
-        try {
-            const apiKey = await input({ message: 'Anthropic API Key', theme });
-            if (!apiKey) {
-                warn('No key provided, skipping.');
-                return 'skip';
-            }
-            await saveProviderConfig({ type: 'anthropic', apiKey, enabled: true });
-            success('Anthropic provider configured.');
-            return 'anthropic';
+    const chosen = PROVIDER_CATALOG.find(p => p.key === choice);
+    if (!chosen)
+        return 'skip';
+    console.log(`\n  ${chalk.bold(chosen.name)} selected`);
+    console.log(chalk.dim(`  Env var: ${chosen.envVar}`));
+    // Ollama special case
+    if (chosen.key === 'ollama') {
+        const ollamaUrl = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+        const spin = spinner(`Checking Ollama at ${ollamaUrl}...`);
+        spin.start();
+        const ollamaOk = await checkOllama(ollamaUrl);
+        spin.stop();
+        if (ollamaOk) {
+            success(`Ollama reachable at ${ollamaUrl}`);
+            await saveProviderConfig({ type: 'ollama', apiKey: ollamaUrl, enabled: true });
+            await updateSettings({
+                integrations: { ollamaEndpoint: ollamaUrl },
+                plugins: { ollama: { enabled: true, autoStart: false } },
+            });
+            success('Ollama provider configured.');
         }
-        catch {
-            return 'skip';
+        else {
+            warn(`Ollama not reachable at ${ollamaUrl}`);
+            info('Start Ollama: docker compose --profile ai up -d');
+            info('Then re-run: profclaw setup');
+            await saveProviderConfig({ type: 'ollama', apiKey: ollamaUrl, enabled: true });
         }
+        return 'ollama';
     }
-    if (choice === 'openai') {
-        try {
-            const apiKey = await input({ message: 'OpenAI API Key', theme });
-            if (!apiKey) {
-                warn('No key provided, skipping.');
-                return 'skip';
-            }
-            await saveProviderConfig({ type: 'openai', apiKey, enabled: true });
-            success('OpenAI provider configured.');
-            return 'openai';
-        }
-        catch {
-            return 'skip';
-        }
+    // Already detected
+    if (detected.has(chosen.key)) {
+        success(`${chosen.name} already configured from ${chosen.envVar}`);
+        return chosen.key;
     }
-    // Ollama
-    const ollamaUrl = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
-    const spin = spinner(`Checking Ollama at ${ollamaUrl}...`);
-    spin.start();
-    const ollamaOk = await checkOllama(ollamaUrl);
-    spin.stop();
-    if (ollamaOk) {
-        success(`Ollama reachable at ${ollamaUrl}`);
-        await saveProviderConfig({ type: 'ollama', apiKey: ollamaUrl, enabled: true });
-        await updateSettings({
-            integrations: { ollamaEndpoint: ollamaUrl },
-            plugins: { ollama: { enabled: true, autoStart: false } },
-        });
-        success('Ollama provider configured.');
+    // Prompt for API key
+    let apiKey;
+    try {
+        apiKey = await input({ message: chosen.envVar, theme });
     }
-    else {
-        warn(`Ollama not reachable at ${ollamaUrl}`);
-        info('Start Ollama: docker compose --profile ai up -d');
-        info('Then re-run: profclaw setup');
-        await saveProviderConfig({ type: 'ollama', apiKey: ollamaUrl, enabled: true });
+    catch {
+        return 'skip';
+    }
+    if (!apiKey) {
+        warn('No key provided, skipping.');
+        return 'skip';
+    }
+    try {
+        await saveProviderConfig({ type: chosen.key, apiKey, enabled: true });
+        success(`${chosen.name} provider configured.`);
+        return chosen.key;
+    }
+    catch (err) {
+        error(`Failed to save: ${err instanceof Error ? err.message : 'unknown'}`);
+        return 'skip';
     }
-    return 'ollama';
 }
 // Step 3: Admin Account
 async function createAdminUser(db, name, email, password) {
@@ -267,7 +339,6 @@ async function stepAdminAccount(db) {
         error('Database not available. Cannot create admin account.');
         return null;
     }
-    console.log(chalk.bold.white('\n  Step 3: Admin Account\n'));
     const existingAdmins = await getExistingAdmins(db);
     if (existingAdmins.length > 0) {
         console.log(chalk.dim('  Existing admin accounts:'));
@@ -414,7 +485,6 @@ async function stepAdminAccount(db) {
 }
 // Step 4: Registration Mode
 async function stepRegistrationMode(db) {
-    console.log(chalk.bold.white('\n  Step 4: Registration Mode\n'));
     let mode;
     try {
         mode = await select({
@@ -472,7 +542,6 @@ async function stepRegistrationMode(db) {
 }
 // Step 5: GitHub OAuth (optional)
 async function stepGitHubOAuth() {
-    console.log(chalk.bold.white('\n  Step 5: GitHub OAuth (Optional)\n'));
     let configure;
     try {
         configure = await confirm({
@@ -519,19 +588,186 @@ async function stepGitHubOAuth() {
     return true;
 }
 // Step 6: Summary
-function showSummary(results) {
-    const port = process.env.PORT || '3000';
+const execFileAsync = promisify(execFile);
+async function runQuickHealthCheck() {
+    const results = [];
+    // 1. Node.js version
+    const nodeVersion = process.version;
+    const nodeMajor = parseInt(nodeVersion.slice(1).split('.')[0], 10);
+    results.push({
+        label: 'Node.js',
+        status: nodeMajor >= 20 ? 'pass' : 'warn',
+        detail: nodeMajor >= 20 ? nodeVersion : `${nodeVersion} (v20+ recommended)`,
+    });
+    // 2. Config files
+    const cwd = process.cwd();
+    const settingsExists = existsSync(join(cwd, 'config', 'settings.yml'));
+    const envExists = existsSync(join(cwd, '.env'));
+    const configStatus = settingsExists && envExists ? 'pass' : settingsExists || envExists ? 'warn' : 'fail';
+    const configDetail = settingsExists && envExists
+        ? 'settings.yml + .env found'
+        : settingsExists
+            ? 'settings.yml found, .env missing'
+            : envExists
+                ? '.env found, settings.yml missing'
+                : 'settings.yml and .env not found';
+    results.push({ label: 'Config', status: configStatus, detail: configDetail });
+    // 3. Database — initStorage() already ran, so if we get here the DB is initialized
+    results.push({ label: 'Database', status: 'pass', detail: 'Initialized' });
+    // 4. Memory
+    const freeBytes = os.freemem();
+    const freeMb = freeBytes / 1024 / 1024;
+    const freeGb = freeBytes / 1024 / 1024 / 1024;
+    const memDetail = freeGb >= 1 ? `${freeGb.toFixed(1)} GB free` : `${Math.round(freeMb)} MB free`;
+    results.push({
+        label: 'Memory',
+        status: freeMb >= 256 ? 'pass' : 'warn',
+        detail: freeMb >= 256 ? memDetail : `${memDetail} (low)`,
+    });
+    // 5. Disk — df on cwd
+    let diskDetail = 'unavailable';
+    let diskStatus = 'warn';
+    try {
+        const { stdout } = await execFileAsync('df', ['-k', cwd]);
+        const lines = stdout.trim().split('\n');
+        if (lines.length >= 2) {
+            const parts = lines[1].trim().split(/\s+/);
+            // df -k columns: Filesystem 1K-blocks Used Available Use% Mounted (macOS/Linux may vary)
+            const availIdx = parts.length >= 4 ? (parts.length === 6 ? 3 : parts.length - 3) : -1;
+            const useIdx = parts.length >= 5 ? parts.length - 2 : -1;
+            if (availIdx !== -1 && useIdx !== -1) {
+                const availKb = parseInt(parts[availIdx], 10);
+                const usePercent = parts[useIdx];
+                const availGb = availKb / 1024 / 1024;
+                diskDetail = `${availGb.toFixed(0)} GB free (${usePercent} used)`;
+                diskStatus = availGb >= 1 ? 'pass' : 'warn';
+            }
+        }
+    }
+    catch { /* df not available */ }
+    results.push({ label: 'Disk', status: diskStatus, detail: diskDetail });
+    // Render
+    const icon = (s) => s === 'pass' ? chalk.green('\u2713') : s === 'warn' ? chalk.yellow('\u26a0') : chalk.red('\u2717');
+    const labelWidth = 12;
+    console.log('');
+    console.log(chalk.bold.white('  Quick Health Check'));
+    console.log('  ' + '\u2500'.repeat(44));
+    for (const r of results) {
+        const label = r.label.padEnd(labelWidth);
+        console.log(`  ${icon(r.status)} ${chalk.dim(label)} ${r.detail}`);
+    }
+    console.log('  ' + '\u2500'.repeat(44));
+    const passed = results.filter(r => r.status === 'pass').length;
+    const total = results.length;
+    const summary = passed === total ? chalk.green(`${passed}/${total} checks passed`) : chalk.yellow(`${passed}/${total} checks passed`);
+    console.log(`  ${summary}`);
+}
+function checkPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once('error', () => resolve(false));
+        server.once('listening', () => { server.close(); resolve(true); });
+        server.listen(port);
+    });
+}
+async function showSummaryAndOffer(results) {
+    const port = parseInt(process.env.PORT || '3000', 10);
     console.log(chalk.bold.white('\n  Setup Complete!\n'));
-    console.log('  ' + '─'.repeat(44));
-    const mark = (ok) => (ok ? chalk.green('✓') : chalk.yellow('✗'));
+    console.log('  ' + '\u2500'.repeat(44));
+    const mark = (ok) => (ok ? chalk.green('\u2713') : chalk.yellow('\u2717'));
     console.log(`  ${mark(results.redisOk)} Redis: ${results.redisOk ? 'connected' : 'not connected'}`);
     console.log(`  ${mark(results.aiProvider !== 'skip')} AI: ${results.aiProvider === 'skip' ? 'not configured' : results.aiProvider}`);
     console.log(`  ${mark(!!results.adminEmail)} Admin: ${results.adminEmail || 'not created'}`);
     console.log(`  ${mark(true)} Registration: ${results.registrationMode}${results.inviteCodes.length ? ` (${results.inviteCodes.length} codes)` : ''}`);
     console.log(`  ${mark(results.githubOAuth)} GitHub OAuth: ${results.githubOAuth ? 'configured' : 'skipped'}`);
-    console.log('  ' + '─'.repeat(44));
+    console.log('  ' + '\u2500'.repeat(44));
+    await runQuickHealthCheck();
+    // Check if server is already running
+    const portFree = await checkPortAvailable(port);
+    const serverRunning = !portFree;
+    if (serverRunning) {
+        // Server already running - just show the URL
+        console.log('');
+        success(`Server already running on port ${port}`);
+        console.log(`\n  ${chalk.cyan.bold(`http://localhost:${port}`)}\n`);
+    }
+    else {
+        // Offer to start the server
+        console.log('');
+        let startServer = false;
+        try {
+            startServer = await confirm({
+                message: 'Start the server now?',
+                default: true,
+                theme,
+            });
+        }
+        catch { /* Ctrl+C */ }
+        if (startServer) {
+            console.log('');
+            const startSpin = spinner('Starting server...');
+            startSpin.start();
+            // Determine runtime
+            const distPath = 'dist/server.js';
+            const useCompiled = existsSync(distPath);
+            const cmd = useCompiled ? 'node' : 'npx';
+            const args = useCompiled ? [distPath] : ['tsx', 'src/server.ts'];
+            // Redirect server output to log file (keep terminal clean)
+            const logDir = join(process.cwd(), 'data');
+            if (!existsSync(logDir))
+                mkdirSync(logDir, { recursive: true });
+            const logPath = join(logDir, 'server.log');
+            const logFd = openSync(logPath, 'a');
+            const child = spawn(cmd, args, {
+                stdio: ['ignore', logFd, logFd],
+                detached: true,
+                env: { ...process.env, PORT: String(port) },
+            });
+            child.unref();
+            // Wait for server to start, polling health check
+            let serverOk = false;
+            for (let i = 0; i < 5; i++) {
+                await new Promise(r => setTimeout(r, 1000));
+                try {
+                    const res = await fetch(`http://localhost:${port}/health`, {
+                        signal: AbortSignal.timeout(2000),
+                    });
+                    if (res.ok) {
+                        serverOk = true;
+                        break;
+                    }
+                }
+                catch { /* not ready yet */ }
+            }
+            startSpin.stop();
+            if (serverOk) {
+                success(`Server running on port ${port}`);
+            }
+            else {
+                warn('Server starting in background (health check pending)');
+            }
+            console.log(`\n  ${chalk.cyan.bold(`http://localhost:${port}`)}`);
+            console.log('');
+            console.log(chalk.dim('  Server is running in the background.'));
+            console.log(chalk.dim(`  Stop:    ${chalk.white('profclaw daemon stop')}  or  ${chalk.white(`kill $(lsof -ti :${port})`)}`));
+            console.log(chalk.dim(`  Logs:    ${chalk.white(`tail -f ${logPath}`)}`));
+            console.log(chalk.dim(`  Status:  ${chalk.white('profclaw doctor')}`));
+        }
+        else {
+            console.log('');
+            console.log(`  Start later with: ${chalk.cyan.bold('profclaw serve')}`);
+        }
+    }
+    // Always show helpful next steps
     console.log('');
-    console.log(`  Open ${chalk.cyan.bold(`http://localhost:${port}`)} to get started.`);
+    console.log(chalk.bold.white('  Next Steps'));
+    console.log('  ' + '\u2500'.repeat(44));
+    console.log(`  ${chalk.cyan('profclaw doctor')}          Health check (12 tests)`);
+    console.log(`  ${chalk.cyan('profclaw chat quick')} ${chalk.dim('"hi"')}  Chat with AI`);
+    console.log(`  ${chalk.cyan('profclaw task list')}        View agent tasks`);
+    console.log(`  ${chalk.cyan('profclaw tools list')}       Available tools`);
+    console.log(`  ${chalk.cyan('profclaw provider test')}    Test AI provider`);
+    console.log(`  ${chalk.cyan('profclaw --help')}           All commands`);
     console.log('');
 }
 // Non-Interactive Mode
@@ -657,6 +893,7 @@ export function setupCommand() {
         .option('--admin-name <name>', 'Admin display name (non-interactive)')
         .option('--ai-provider <provider>', 'AI provider: anthropic, openai, ollama, skip (non-interactive)')
         .option('--registration-mode <mode>', 'Registration mode: invite, open (non-interactive)')
+        .option('--from-onboard', 'Called from onboard wizard (skip AI provider)')
         .action(async (options) => {
         try {
             // Non-interactive mode
@@ -668,42 +905,89 @@ export function setupCommand() {
                     aiProvider: options.aiProvider,
                     registrationMode: options.registrationMode,
                 });
-                return;
+                await closeStorage();
+                process.exit(0);
             }
+            const fromOnboard = !!options.fromOnboard;
             // Interactive mode
-            showBanner();
+            if (!fromOnboard)
+                showBanner();
+            // Suppress initialization noise ([INFO] Initializing LibSQL storage, etc.)
+            const _origLog = console.log;
+            console.log = (...args) => {
+                const msg = String(args[0] || '');
+                if (msg.includes('[INFO]') || msg.includes('[DEBUG]'))
+                    return;
+                _origLog.apply(console, args);
+            };
             const spin = spinner('Initializing...');
             spin.start();
             await initStorage();
             const db = getDb();
             spin.stop();
+            // Restore console
+            console.log = _origLog;
             if (!db) {
                 error('Failed to initialize database.');
                 process.exit(1);
             }
-            // Step 1: System Check
-            const status = await stepSystemCheck(db);
-            // Step 2: AI Provider
-            console.log(chalk.bold.white('\n  Step 2: AI Provider\n'));
-            const aiProvider = await stepAiProvider(status);
-            // Step 3: Admin Account
+            // Dynamic step numbering
+            // Standalone: 5 steps (System Check, AI Provider, Admin, Registration, GitHub OAuth)
+            // From onboard: continues at step 5 of 6 (onboard did 1-4)
+            const totalSteps = fromOnboard ? 6 : 5;
+            let step = fromOnboard ? 4 : 0;
+            // System Check (skip if from onboard - already done)
+            let status;
+            if (fromOnboard) {
+                // Quick silent check
+                const redisOk = await checkRedis();
+                const hasAdmin = await checkAdminExists(db);
+                const providerName = await detectConfiguredProvider();
+                status = { redisOk, hasAdmin, hasProvider: !!providerName, providerName };
+            }
+            else {
+                step++;
+                stepHeader(step, totalSteps, 'System Check');
+                status = await stepSystemCheck(db);
+            }
+            // AI Provider (skip if from onboard - already configured)
+            let aiProvider = 'skip';
+            if (!fromOnboard) {
+                step++;
+                stepHeader(step, totalSteps, 'AI Provider');
+                aiProvider = await stepAiProvider(status);
+            }
+            // Admin Account
+            step++;
+            stepHeader(step, totalSteps, 'Admin Account');
             const adminEmail = await stepAdminAccount(db);
-            // Step 4: Registration Mode
+            // Registration Mode
+            step++;
+            stepHeader(step, totalSteps, 'Registration Mode');
             const regResult = await stepRegistrationMode(db);
-            // Step 5: GitHub OAuth
-            const githubOAuth = await stepGitHubOAuth();
-            // Step 6: Summary
-            showSummary({
+            // GitHub OAuth (skip if from onboard to keep it shorter)
+            let githubOAuth = false;
+            if (!fromOnboard) {
+                step++;
+                stepHeader(step, totalSteps, 'GitHub OAuth');
+                githubOAuth = await stepGitHubOAuth();
+            }
+            // Summary + offer to start server
+            await showSummaryAndOffer({
                 redisOk: status.redisOk,
                 aiProvider,
                 adminEmail,
                 registrationMode: regResult.mode,
                 inviteCodes: regResult.codes,
                 githubOAuth,
+                fromOnboard,
             });
+            await closeStorage();
+            process.exit(0);
         }
         catch (err) {
             error(err instanceof Error ? err.message : 'Setup failed');
+            await closeStorage();
             process.exit(1);
         }
     });

package/dist/cli/commands/status.js

@@ -2,6 +2,25 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import { api } from '../utils/api.js';
 import { spinner } from '../utils/output.js';
+import { isServerRunning } from '../../utils/pid-file.js';
+function formatUptime(seconds) {
+    if (seconds < 60) {
+        return `${seconds}s`;
+    }
+    if (seconds < 3600) {
+        const m = Math.floor(seconds / 60);
+        const s = seconds % 60;
+        return `${m}m ${s}s`;
+    }
+    if (seconds < 86400) {
+        const h = Math.floor(seconds / 3600);
+        const m = Math.floor((seconds % 3600) / 60);
+        return `${h}h ${m}m`;
+    }
+    const d = Math.floor(seconds / 86400);
+    const h = Math.floor((seconds % 86400) / 3600);
+    return `${d}d ${h}h`;
+}
 export function statusCommand() {
     const cmd = new Command('status')
         .description('System status overview')
@@ -35,6 +54,41 @@ export function statusCommand() {
             ? chalk.green('healthy')
             : chalk.red('unhealthy');
         console.log(`\nprofClaw v${version} | Mode: ${mode} | Status: ${statusText}\n`);
+        // PID / port from PID file (fast local read) or health endpoint
+        const pidInfo = isServerRunning();
+        const pid = health.data?.process?.pid ?? pidInfo.pid;
+        const port = health.data?.process?.port ?? pidInfo.port;
+        if (pid !== undefined) {
+            console.log(`${chalk.bold('Process')}      PID ${pid}${port ? `, port ${port}` : ''}`);
+        }
+        // Uptime
+        if (health.data?.uptime !== undefined) {
+            console.log(`${chalk.bold('Uptime')}       ${formatUptime(health.data.uptime)}`);
+        }
+        // SSE clients
+        if (health.data?.sseClients !== undefined) {
+            console.log(`${chalk.bold('SSE Clients')}  ${health.data.sseClients}`);
+        }
+        // Active agent sessions
+        if (health.data?.activeSessions !== undefined) {
+            console.log(`${chalk.bold('Sessions')}     ${health.data.activeSessions} active`);
+        }
+        // Queue depth
+        if (health.data?.queueDepth !== undefined) {
+            const q = health.data.queueDepth;
+            console.log(`${chalk.bold('Queue')}        ${q.pending} pending, ${q.running} running`);
+        }
+        // Memory and CPU
+        if (health.data?.process !== undefined) {
+            const p = health.data.process;
+            const load = p.cpuLoadAvg.length > 0 ? p.cpuLoadAvg[0].toFixed(2) : '?';
+            console.log(`${chalk.bold('Resources')}    ${p.memoryMb} MB RSS | CPU load ${load}`);
+        }
+        // Last error
+        if (health.data?.lastError) {
+            console.log(`${chalk.bold('Last error')}   ${chalk.red(health.data.lastError)}`);
+        }
+        console.log('');
         if (providers.ok && providers.data) {
             const active = providers.data.providers.filter((p) => p.enabled || p.configured);
             const healthySummary = active