profclaw 0.0.1-beta.3 → 2.0.0

package/dist/cli/commands/setup.js

@@ -11,14 +11,26 @@
 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 } from 'child_process';
+import { existsSync, mkdirSync, openSync } from 'node:fs';
+import { join } from 'node:path';
+import { createServer } from 'net';
+import { initStorage, getDb, 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 +134,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 +181,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 +248,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 +337,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 +483,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 +540,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 +586,111 @@ async function stepGitHubOAuth() {
     return true;
 }
 // Step 6: Summary
-function showSummary(results) {
-    const port = process.env.PORT || '3000';
+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));
+    // 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 +816,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
@@ -670,36 +830,79 @@ export function setupCommand() {
                 });
                 return;
             }
+            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,
             });
         }
         catch (err) {

package/dist/cli/index.js

@@ -23,17 +23,14 @@ import { sessionCommands } from './commands/session.js';
 import { doctorCommand } from './commands/doctor.js';
 import { providerCommands } from './commands/provider.js';
 import { mcpCommands } from './commands/mcp.js';
-import { browserCommands } from './commands/browser.js';
 import { devicesCommands } from './commands/devices.js';
 import { daemonCommand } from './commands/daemon.js';
 import { completionCommands } from './commands/completion.js';
-import { canvasCommands } from './commands/canvas.js';
 import { webhooksCommands } from './commands/webhooks.js';
 import { channelsCommands } from './commands/channels.js';
 import { securityCommands } from './commands/security.js';
 import { logsCommand } from './commands/logs.js';
 import { modelsCommands } from './commands/models.js';
-import { nodesCommands } from './commands/nodes.js';
 import { tuiCommand } from './commands/tui.js';
 const VERSION = '2.0.0';
 // ASCII Banner
@@ -77,17 +74,14 @@ program.addCommand(doctorCommand());
 program.addCommand(providerCommands());
 program.addCommand(mcpCommands());
 // Phase 9 - OpenClaw parity commands
-program.addCommand(browserCommands());
 program.addCommand(devicesCommands());
 program.addCommand(daemonCommand());
 program.addCommand(completionCommands());
-program.addCommand(canvasCommands());
 program.addCommand(webhooksCommands());
 program.addCommand(channelsCommands());
 program.addCommand(securityCommands());
 program.addCommand(logsCommand());
 program.addCommand(modelsCommands());
-program.addCommand(nodesCommands());
 program.addCommand(tuiCommand());
 // Default action (no command) - show banner and help
 program.action(() => {

package/dist/cli/providers.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared AI provider catalog for CLI wizards (onboard + setup).
+ */
+export interface ProviderEntry {
+    key: string;
+    name: string;
+    models: string;
+    envVar: string;
+    category: string;
+    tag: string;
+}
+export declare const PROVIDER_CATALOG: ProviderEntry[];
+/** All env var keys used by providers (for .env writing). */
+export declare const PROVIDER_ENV_KEYS: string[];
+//# sourceMappingURL=providers.d.ts.map

package/dist/cli/providers.js

@@ -0,0 +1,41 @@
+/**
+ * Shared AI provider catalog for CLI wizards (onboard + setup).
+ */
+export const PROVIDER_CATALOG = [
+    // Popular
+    { key: 'anthropic', name: 'Anthropic', models: 'Claude 4.x, 3.5 Sonnet', envVar: 'ANTHROPIC_API_KEY', category: 'Popular', tag: 'recommended' },
+    { key: 'openai', name: 'OpenAI', models: 'GPT-4o, o1, o3', envVar: 'OPENAI_API_KEY', category: 'Popular', tag: '' },
+    { key: 'google', name: 'Google AI', models: 'Gemini 2.x, Flash', envVar: 'GOOGLE_GENERATIVE_AI_API_KEY', category: 'Popular', tag: '' },
+    { key: 'ollama', name: 'Ollama', models: 'Llama, Mistral, Qwen', envVar: 'OLLAMA_BASE_URL', category: 'Popular', tag: 'free, local' },
+    // Fast Inference
+    { key: 'groq', name: 'Groq', models: 'Llama, Mixtral', envVar: 'GROQ_API_KEY', category: 'Fast Inference', tag: 'fast' },
+    { key: 'cerebras', name: 'Cerebras', models: 'Llama 3.3 70B', envVar: 'CEREBRAS_API_KEY', category: 'Fast Inference', tag: 'fast' },
+    { key: 'fireworks', name: 'Fireworks', models: 'Llama, Mixtral', envVar: 'FIREWORKS_API_KEY', category: 'Fast Inference', tag: '' },
+    { key: 'together', name: 'Together', models: 'Open models', envVar: 'TOGETHER_API_KEY', category: 'Fast Inference', tag: '' },
+    // Enterprise
+    { key: 'azure', name: 'Azure OpenAI', models: 'GPT-4o', envVar: 'AZURE_OPENAI_API_KEY', category: 'Enterprise', tag: 'enterprise' },
+    { key: 'bedrock', name: 'AWS Bedrock', models: 'Claude, Titan, Llama', envVar: 'AWS_ACCESS_KEY_ID', category: 'Enterprise', tag: 'enterprise' },
+    { key: 'watsonx', name: 'IBM Watsonx', models: 'Granite, Llama', envVar: 'WATSONX_API_KEY', category: 'Enterprise', tag: 'enterprise' },
+    // More Providers
+    { key: 'deepseek', name: 'DeepSeek', models: 'V3, R1 (reasoning)', envVar: 'DEEPSEEK_API_KEY', category: 'More Providers', tag: '' },
+    { key: 'mistral', name: 'Mistral', models: 'Large, Codestral', envVar: 'MISTRAL_API_KEY', category: 'More Providers', tag: '' },
+    { key: 'xai', name: 'xAI', models: 'Grok', envVar: 'XAI_API_KEY', category: 'More Providers', tag: '' },
+    { key: 'perplexity', name: 'Perplexity', models: 'Sonar (search)', envVar: 'PERPLEXITY_API_KEY', category: 'More Providers', tag: 'search' },
+    { key: 'cohere', name: 'Cohere', models: 'Command R+', envVar: 'COHERE_API_KEY', category: 'More Providers', tag: '' },
+    // Aggregators
+    { key: 'openrouter', name: 'OpenRouter', models: 'Any model (proxy)', envVar: 'OPENROUTER_API_KEY', category: 'Aggregators', tag: 'multi-model' },
+    { key: 'replicate', name: 'Replicate', models: 'Open-source models', envVar: 'REPLICATE_API_TOKEN', category: 'Aggregators', tag: '' },
+    { key: 'github-models', name: 'GitHub Models', models: 'Azure-backed', envVar: 'GITHUB_TOKEN', category: 'Aggregators', tag: '' },
+    { key: 'huggingface', name: 'HuggingFace', models: 'Inference API', envVar: 'HF_TOKEN', category: 'Aggregators', tag: '' },
+    { key: 'nvidia-nim', name: 'NVIDIA NIM', models: 'Llama, Nemotron', envVar: 'NVIDIA_NIM_API_KEY', category: 'Aggregators', tag: '' },
+    // Asia
+    { key: 'zhipu', name: 'Zhipu AI', models: 'GLM-4, GLM-5', envVar: 'ZHIPU_API_KEY', category: 'Asia', tag: '' },
+    { key: 'moonshot', name: 'Moonshot', models: 'Kimi (128K context)', envVar: 'MOONSHOT_API_KEY', category: 'Asia', tag: '' },
+    { key: 'qwen', name: 'Qwen', models: 'Qwen Max, Plus', envVar: 'QWEN_API_KEY', category: 'Asia', tag: '' },
+    { key: 'minimax', name: 'MiniMax', models: 'abab series', envVar: 'MINIMAX_API_KEY', category: 'Asia', tag: '' },
+    { key: 'volcengine', name: 'Volcengine', models: 'Doubao (Bytedance)', envVar: 'VOLCENGINE_API_KEY', category: 'Asia', tag: '' },
+    { key: 'qianfan', name: 'Qianfan', models: 'ERNIE (Baidu)', envVar: 'QIANFAN_API_KEY', category: 'Asia', tag: '' },
+];
+/** All env var keys used by providers (for .env writing). */
+export const PROVIDER_ENV_KEYS = PROVIDER_CATALOG.map(p => p.envVar);
+//# sourceMappingURL=providers.js.map

package/dist/core/deployment.js

@@ -9,6 +9,8 @@ const MODE_CAPABILITIES = {
         'agent',
         'tools',
         'chat_cli',
+        'chat_channels',
+        'cron',
     ]),
     mini: new Set([
         'agent',