profclaw 0.0.1-beta.1

package/dist/cli/commands/onboard.js

@@ -0,0 +1,360 @@
+/**
+ * CLI Onboard Command
+ *
+ * Zero-to-running in one command. Detects environment, recommends deployment mode,
+ * generates .env, runs setup wizard, starts server.
+ *
+ * Usage:
+ *   profclaw onboard                                    # Interactive
+ *   profclaw onboard --non-interactive --mode mini      # CI/Docker
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import figlet from 'figlet';
+import { createInterface } from 'readline/promises';
+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';
+const DETECT_TIMEOUT_MS = 5000;
+/** Wrap a detection check with a timeout so a hung service doesn't block onboarding. */
+async function withTimeout(promise, fallback, timeoutMs = DETECT_TIMEOUT_MS) {
+    return Promise.race([
+        promise,
+        new Promise((resolve) => setTimeout(() => resolve(fallback), timeoutMs)),
+    ]);
+}
+async function detectRedis() {
+    try {
+        const IORedis = (await import('ioredis')).default;
+        const redisUrl = process.env.REDIS_URL || 'redis://localhost:6379';
+        const redis = new IORedis(redisUrl, {
+            maxRetriesPerRequest: 1,
+            connectTimeout: 2000,
+            lazyConnect: true,
+        });
+        await redis.connect();
+        await redis.ping();
+        await redis.disconnect();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function detectOllama() {
+    try {
+        const url = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+        const res = await fetch(`${url}/api/tags`, { signal: AbortSignal.timeout(2000) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function detectBinary(name) {
+    try {
+        execSync(`which ${name}`, { stdio: 'ignore', timeout: 3000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function detectEnvironment() {
+    const os = await import('node:os');
+    const isDocker = existsSync('/.dockerenv') || existsSync('/run/.containerenv');
+    const totalMemoryMb = Math.round(os.totalmem() / (1024 * 1024));
+    // Run network checks in parallel with timeouts
+    const [hasRedis, hasOllama] = await Promise.all([
+        withTimeout(detectRedis(), false),
+        withTimeout(detectOllama(), false),
+    ]);
+    // Binary checks are fast, no timeout needed
+    const hasClaude = detectBinary('claude');
+    const hasGit = detectBinary('git');
+    return {
+        os: `${os.platform()} ${os.release()}`,
+        arch: os.arch(),
+        nodeVersion: process.version,
+        totalMemoryMb,
+        isDocker,
+        hasRedis,
+        hasOllama,
+        hasClaude,
+        hasGit,
+        existingEnv: existsSync(join(process.cwd(), '.env')),
+        existingDb: existsSync(join(process.cwd(), 'data', 'profclaw.db')),
+    };
+}
+function recommendMode(env) {
+    // Low memory or no Redis: pico
+    if (env.totalMemoryMb < 512)
+        return 'pico';
+    // Has Redis and plenty of RAM: pro
+    if (env.hasRedis && env.totalMemoryMb >= 2048)
+        return 'pro';
+    // Default: mini
+    return 'mini';
+}
+// .env Generation
+function generateEnvFile(opts) {
+    const lines = [
+        '# profClaw Configuration',
+        `# Generated by: profclaw onboard`,
+        `# Date: ${new Date().toISOString()}`,
+        '',
+        '# Deployment Mode',
+        `PROFCLAW_MODE=${opts.mode}`,
+        '',
+        `PORT=${opts.port || '3000'}`,
+        '',
+    ];
+    if (opts.anthropicKey) {
+        lines.push('# AI Provider');
+        lines.push(`ANTHROPIC_API_KEY=${opts.anthropicKey}`);
+        lines.push('');
+    }
+    else if (opts.openaiKey) {
+        lines.push('# AI Provider');
+        lines.push(`OPENAI_API_KEY=${opts.openaiKey}`);
+        lines.push('');
+    }
+    else if (opts.ollamaUrl) {
+        lines.push('# AI Provider (Ollama - free local AI)');
+        lines.push(`OLLAMA_BASE_URL=${opts.ollamaUrl}`);
+        lines.push('');
+    }
+    if (opts.mode === 'pro') {
+        lines.push('# Redis (required for pro mode)');
+        lines.push('REDIS_URL=redis://localhost:6379');
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+// Interactive Onboarding
+async function prompt(rl, question) {
+    const answer = await rl.question(chalk.bold(question));
+    return answer.trim();
+}
+async function promptChoice(rl, question, options) {
+    console.log('');
+    console.log(chalk.bold(question));
+    for (const opt of options) {
+        console.log(`  ${chalk.cyan(opt.key)}) ${opt.label}`);
+    }
+    const validKeys = options.map(o => o.key);
+    while (true) {
+        const answer = await prompt(rl, `Choice [${validKeys.join('/')}]: `);
+        if (validKeys.includes(answer))
+            return answer;
+        console.log(chalk.red(`  Invalid choice. Options: ${validKeys.join(', ')}`));
+    }
+}
+async function runInteractive() {
+    const banner = figlet.textSync('profClaw', { font: 'Standard' });
+    console.log(chalk.cyan(banner));
+    console.log(chalk.dim('  Onboarding Wizard\n'));
+    // Step 1: Detect environment
+    console.log(chalk.bold.white('  Step 1: Environment Detection\n'));
+    const spin = spinner('Scanning environment...');
+    spin.start();
+    const env = await detectEnvironment();
+    spin.stop();
+    const mark = (ok) => (ok ? chalk.green('  +') : chalk.dim('  -'));
+    console.log(`${mark(true)} OS: ${env.os} (${env.arch})`);
+    console.log(`${mark(true)} Node: ${env.nodeVersion}`);
+    console.log(`${mark(true)} RAM: ${env.totalMemoryMb} MB`);
+    console.log(`${mark(env.isDocker)} Docker: ${env.isDocker ? 'yes' : 'no'}`);
+    console.log(`${mark(env.hasRedis)} Redis: ${env.hasRedis ? 'connected' : 'not found'}`);
+    console.log(`${mark(env.hasOllama)} Ollama: ${env.hasOllama ? 'running' : 'not found'}`);
+    console.log(`${mark(env.hasClaude)} Claude CLI: ${env.hasClaude ? 'found' : 'not found'}`);
+    console.log(`${mark(env.hasGit)} Git: ${env.hasGit ? 'found' : 'not found'}`);
+    const recommended = recommendMode(env);
+    console.log(`\n  ${chalk.cyan('Recommended mode:')} ${chalk.bold(recommended)}`);
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    // Step 2: Choose mode
+    console.log(chalk.bold.white('\n  Step 2: Deployment Mode\n'));
+    const modeChoice = await promptChoice(rl, '  Select deployment mode:', [
+        { key: '1', label: `Pico -- Agent + tools only, ~50MB RAM${recommended === 'pico' ? chalk.green(' (recommended)') : ''}` },
+        { key: '2', label: `Mini -- + Dashboard, cron, integrations, ~150MB RAM${recommended === 'mini' ? chalk.green(' (recommended)') : ''}` },
+        { key: '3', label: `Pro -- Everything, Redis required, ~300MB RAM${recommended === 'pro' ? chalk.green(' (recommended)') : ''}` },
+    ]);
+    const mode = modeChoice === '1' ? 'pico' : modeChoice === '2' ? 'mini' : 'pro';
+    success(`Mode: ${mode}`);
+    // Step 3: AI Provider
+    console.log(chalk.bold.white('\n  Step 3: AI Provider\n'));
+    let anthropicKey;
+    let openaiKey;
+    let ollamaUrl;
+    const hasExistingProvider = !!process.env.ANTHROPIC_API_KEY || !!process.env.OPENAI_API_KEY;
+    if (hasExistingProvider) {
+        info('AI provider already configured from environment.');
+    }
+    else {
+        const providerChoice = await promptChoice(rl, '  Select AI provider:', [
+            { key: '1', label: 'Anthropic (Claude) -- recommended' },
+            { key: '2', label: 'OpenAI (GPT-4o)' },
+            { key: '3', label: `Ollama (free, local)${env.hasOllama ? chalk.green(' -- detected!') : ''}` },
+            { key: '4', label: 'Skip for now' },
+        ]);
+        if (providerChoice === '1') {
+            anthropicKey = await prompt(rl, '  Anthropic API Key: ');
+            if (anthropicKey)
+                success('Anthropic key saved.');
+        }
+        else if (providerChoice === '2') {
+            openaiKey = await prompt(rl, '  OpenAI API Key: ');
+            if (openaiKey)
+                success('OpenAI key saved.');
+        }
+        else if (providerChoice === '3') {
+            ollamaUrl = env.hasOllama
+                ? (process.env.OLLAMA_BASE_URL || 'http://localhost:11434')
+                : await prompt(rl, '  Ollama URL [http://localhost:11434]: ') || 'http://localhost:11434';
+            success(`Ollama: ${ollamaUrl}`);
+        }
+    }
+    // Step 4: Generate .env
+    console.log(chalk.bold.white('\n  Step 4: Configuration\n'));
+    if (!env.existingEnv) {
+        const envContent = generateEnvFile({
+            mode,
+            anthropicKey,
+            openaiKey,
+            ollamaUrl,
+        });
+        const envPath = join(process.cwd(), '.env');
+        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 {
+        info('.env file already exists. Updating PROFCLAW_MODE...');
+        const envPath = join(process.cwd(), '.env');
+        let content = readFileSync(envPath, 'utf-8');
+        if (content.includes('PROFCLAW_MODE=')) {
+            content = content.replace(/PROFCLAW_MODE=\w+/, `PROFCLAW_MODE=${mode}`);
+        }
+        else {
+            content += `\nPROFCLAW_MODE=${mode}\n`;
+        }
+        writeFileSync(envPath, content);
+        success(`PROFCLAW_MODE=${mode} set in .env`);
+    }
+    rl.close();
+    // Step 5: Run setup wizard
+    console.log(chalk.bold.white('\n  Step 5: Setup\n'));
+    info('Launching setup wizard for admin account and provider configuration...\n');
+    try {
+        const { setupCommand } = await import('./setup.js');
+        const setupCmd = setupCommand();
+        await setupCmd.parseAsync(['node', 'setup']);
+    }
+    catch (err) {
+        error(`Setup wizard failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
+        info('You can run it again later: profclaw setup');
+        return;
+    }
+    // Step 6: Post-setup validation
+    console.log(chalk.bold.white('\n  Step 6: Validation\n'));
+    const postSpin = spinner('Validating installation...');
+    postSpin.start();
+    const checks = [];
+    // Check .env exists
+    const envExists = existsSync(join(process.cwd(), '.env'));
+    checks.push({ label: '.env file', ok: envExists });
+    // Check config exists
+    const configExists = existsSync(join(process.cwd(), 'config', 'settings.yml'));
+    checks.push({ label: 'config/settings.yml', ok: configExists });
+    // Check database was created
+    const dbExists = existsSync(join(process.cwd(), 'data', 'profclaw.db'));
+    checks.push({ label: 'Database', ok: dbExists });
+    postSpin.stop();
+    for (const check of checks) {
+        const icon = check.ok ? chalk.green('  +') : chalk.red('  -');
+        console.log(`${icon} ${check.label}: ${check.ok ? 'OK' : 'missing'}`);
+    }
+    const allPassed = checks.every((c) => c.ok);
+    if (allPassed) {
+        console.log('');
+        success('Onboarding complete! Start the server:');
+        console.log(`\n  ${chalk.cyan.bold('profclaw serve')}\n`);
+    }
+    else {
+        console.log('');
+        warn('Some checks did not pass. You may need to run setup again:');
+        console.log(`\n  ${chalk.cyan('profclaw setup')}\n`);
+    }
+}
+// Non-Interactive Onboarding
+async function runNonInteractive(options) {
+    console.log(chalk.dim('  Running onboard in non-interactive mode...\n'));
+    const spin = spinner('Detecting environment...');
+    spin.start();
+    const env = await detectEnvironment();
+    spin.stop();
+    const mode = (options.mode || recommendMode(env));
+    success(`Mode: ${mode}`);
+    // Generate .env if it doesn't exist
+    if (!env.existingEnv) {
+        try {
+            const envPath = join(process.cwd(), '.env');
+            const envContent = generateEnvFile({ mode, port: options.port });
+            writeFileSync(envPath, envContent, { mode: 0o600 }); // Restrict permissions
+            success('.env created');
+        }
+        catch (err) {
+            error(`Failed to write .env: ${err instanceof Error ? err.message : 'permission denied'}`);
+            info('Create .env manually with PROFCLAW_MODE=' + mode);
+        }
+    }
+    // Delegate to setup --non-interactive
+    try {
+        const { setupCommand } = await import('./setup.js');
+        const setupCmd = setupCommand();
+        const args = ['node', 'setup', '--non-interactive'];
+        if (options.provider)
+            args.push('--ai-provider', options.provider);
+        await setupCmd.parseAsync(args);
+    }
+    catch (err) {
+        error(`Setup failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
+        info('Run setup manually: profclaw setup');
+    }
+    success('Non-interactive onboarding complete.');
+}
+// Command Registration
+export function onboardCommand() {
+    const cmd = new Command('onboard')
+        .description('Zero-to-running onboarding wizard (environment detection + setup + start)')
+        .option('--non-interactive', 'Run without prompts')
+        .option('--mode <mode>', 'Deployment mode: pico, mini, pro')
+        .option('--provider <provider>', 'AI provider: anthropic, openai, ollama')
+        .option('--port <port>', 'Server port (default: 3000)')
+        .action(async (options) => {
+        try {
+            if (options.nonInteractive) {
+                await runNonInteractive({
+                    mode: options.mode,
+                    provider: options.provider,
+                    port: options.port,
+                });
+            }
+            else {
+                await runInteractive();
+            }
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : 'Onboarding failed');
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=onboard.js.map

package/dist/cli/commands/plugin.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Plugin CLI Commands
+ *
+ * Manage profClaw plugins from the command line.
+ *
+ * Usage:
+ *   profclaw plugin create <name> --type tool
+ *   profclaw plugin list
+ *   profclaw plugin install <package>
+ *   profclaw plugin uninstall <package>
+ *   profclaw plugin search <query>
+ */
+import { Command } from 'commander';
+export declare function pluginCommands(): Command;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/cli/commands/plugin.js

@@ -0,0 +1,226 @@
+/**
+ * Plugin CLI Commands
+ *
+ * Manage profClaw plugins from the command line.
+ *
+ * Usage:
+ *   profclaw plugin create <name> --type tool
+ *   profclaw plugin list
+ *   profclaw plugin install <package>
+ *   profclaw plugin uninstall <package>
+ *   profclaw plugin search <query>
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { scaffoldPlugin } from '../../plugins/scaffolder.js';
+import { getMarketplace } from '../../plugins/marketplace.js';
+import { getClawHubClient } from '../../plugins/clawhub.js';
+import { success, error, info } from '../utils/output.js';
+export function pluginCommands() {
+    const cmd = new Command('plugin')
+        .description('Manage profClaw plugins');
+    // profclaw plugin create <name>
+    cmd
+        .command('create <name>')
+        .description('Scaffold a new plugin project')
+        .option('-t, --type <type>', 'Plugin type: tool, channel, integration, skill', 'tool')
+        .option('-d, --description <desc>', 'Plugin description')
+        .option('-a, --author <author>', 'Plugin author')
+        .option('-o, --output <dir>', 'Output directory')
+        .action((name, opts) => {
+        const validTypes = ['tool', 'channel', 'integration', 'skill'];
+        const pluginType = opts.type;
+        if (!validTypes.includes(pluginType)) {
+            error(`Invalid plugin type: ${opts.type}. Must be one of: ${validTypes.join(', ')}`);
+            process.exit(1);
+        }
+        const result = scaffoldPlugin({
+            name,
+            type: pluginType,
+            description: opts.description,
+            author: opts.author,
+            outputDir: opts.output,
+        });
+        if (result.success) {
+            success(`Plugin scaffolded at ${chalk.cyan(`profclaw-plugin-${name}/`)}`);
+            console.log('');
+            info('Files created:');
+            for (const file of result.files) {
+                console.log(`  ${file}`);
+            }
+            console.log('');
+            info('Next steps:');
+            console.log(`  cd profclaw-plugin-${name}`);
+            console.log('  npm install');
+            console.log('  npm run dev');
+            console.log(`  # Copy to ~/.profclaw/plugins/${name}/ to test`);
+        }
+        else {
+            error(`Failed to scaffold plugin: ${result.error ?? 'Unknown error'}`);
+            process.exit(1);
+        }
+    });
+    // profclaw plugin list
+    cmd
+        .command('list')
+        .description('List installed plugins')
+        .option('--clawhub', 'Also show ClawHub installed skills')
+        .action(async (opts) => {
+        try {
+            // Show locally loaded plugins via plugin loader
+            const { loadPlugins } = await import('../../plugins/loader.js');
+            const loaded = await loadPlugins();
+            if (loaded.length === 0) {
+                info('No plugins loaded from plugin directories.');
+            }
+            else {
+                console.log(chalk.bold('\nLoaded Plugins:\n'));
+                for (const { plugin, source, path } of loaded) {
+                    const meta = plugin.metadata;
+                    const features = [];
+                    if (plugin.tools?.length)
+                        features.push(`${plugin.tools.length} tools`);
+                    if (plugin.searchProvider)
+                        features.push('search');
+                    if (plugin.skills?.length)
+                        features.push(`${plugin.skills.length} skills`);
+                    console.log(`  ${chalk.cyan(meta.name)} ${chalk.dim(`v${meta.version}`)}`);
+                    console.log(`    ${chalk.dim(meta.description)}`);
+                    console.log(`    Source: ${source} | Features: ${features.join(', ') || 'none'}`);
+                    console.log(`    Path: ${chalk.dim(path)}`);
+                    console.log('');
+                }
+            }
+            // Show marketplace-tracked plugins
+            const marketplace = getMarketplace();
+            const installed = marketplace.listInstalled();
+            if (installed.length > 0) {
+                console.log(chalk.bold('Marketplace Plugins:\n'));
+                for (const p of installed) {
+                    const status = p.enabled ? chalk.green('enabled') : chalk.dim('disabled');
+                    console.log(`  ${chalk.cyan(p.name)}@${p.version} [${status}] (${p.source})`);
+                }
+                console.log('');
+            }
+            if (opts.clawhub) {
+                const hub = getClawHubClient();
+                const hubInstalled = hub.listInstalled();
+                if (hubInstalled.length > 0) {
+                    console.log(chalk.bold(`ClawHub Skills (${hubInstalled.length}):\n`));
+                    for (const s of hubInstalled) {
+                        console.log(`  ${chalk.cyan(s.name)} from ${chalk.dim(s.repo)}`);
+                    }
+                    console.log('');
+                }
+                else {
+                    info('No ClawHub skills installed.');
+                }
+            }
+            if (loaded.length === 0 && installed.length === 0) {
+                info('Install plugins: profclaw plugin install <name>');
+                info('Create a plugin: profclaw plugin create <name>');
+            }
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : 'Failed to list plugins');
+        }
+    });
+    // profclaw plugin install <package>
+    cmd
+        .command('install <package>')
+        .description('Install a plugin from npm (e.g., profclaw-plugin-github or just "github")')
+        .option('-v, --version <version>', 'Specific version to install')
+        .action(async (packageName, opts) => {
+        const fullName = packageName.startsWith('profclaw-plugin-') || packageName.startsWith('@profclaw/')
+            ? packageName
+            : `profclaw-plugin-${packageName}`;
+        const marketplace = getMarketplace();
+        try {
+            info(`Installing ${fullName}...`);
+            const result = await marketplace.install(fullName, opts.version);
+            success(`Installed ${result.name}@${result.version}`);
+            info('Restart profClaw to load the plugin.');
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : `Failed to install ${fullName}`);
+            info('Check that the package exists on npm: https://www.npmjs.com');
+            process.exit(1);
+        }
+    });
+    // profclaw plugin uninstall <package>
+    cmd
+        .command('uninstall <package>')
+        .description('Uninstall a plugin')
+        .action(async (packageName) => {
+        const fullName = packageName.startsWith('profclaw-plugin-') || packageName.startsWith('@profclaw/')
+            ? packageName
+            : `profclaw-plugin-${packageName}`;
+        const marketplace = getMarketplace();
+        try {
+            await marketplace.uninstall(fullName);
+            success(`Uninstalled ${fullName}`);
+            info('Restart profClaw for changes to take effect.');
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : `Failed to uninstall ${fullName}`);
+            process.exit(1);
+        }
+    });
+    // profclaw plugin search [query]
+    cmd
+        .command('search [query]')
+        .description('Search for plugins on npm and ClawHub')
+        .option('--npm-only', 'Search npm only')
+        .option('--clawhub-only', 'Search ClawHub only')
+        .action(async (query, opts) => {
+        if (!opts.clawhubOnly) {
+            info('Searching npm...');
+            const marketplace = getMarketplace();
+            try {
+                const results = await marketplace.search(query);
+                if (results.length > 0) {
+                    console.log(chalk.bold(`\nnpm results (${results.length}):\n`));
+                    for (const p of results) {
+                        const cat = chalk.dim(`[${p.category}]`);
+                        console.log(`  ${chalk.cyan(p.name)} ${cat}`);
+                        if (p.description)
+                            console.log(`    ${p.description}`);
+                    }
+                    console.log('');
+                }
+                else {
+                    info('No npm results found.');
+                }
+            }
+            catch {
+                info('npm search unavailable (no network or npm not installed).');
+            }
+        }
+        if (!opts.npmOnly) {
+            info('Searching ClawHub...');
+            const hub = getClawHubClient();
+            try {
+                const results = await hub.search(query);
+                if (results.length > 0) {
+                    console.log(chalk.bold(`\nClawHub results (${results.length}):\n`));
+                    for (const s of results.slice(0, 20)) {
+                        const stars = s.stars > 0 ? chalk.dim(` (${s.stars} stars)`) : '';
+                        console.log(`  ${chalk.cyan(`${s.author}/${s.name}`)}${stars}`);
+                        if (s.description)
+                            console.log(`    ${s.description}`);
+                    }
+                    console.log('');
+                    info('Install a ClawHub skill: profclaw plugin install --clawhub <author/name>');
+                }
+                else {
+                    info('No ClawHub results found.');
+                }
+            }
+            catch {
+                info('ClawHub search unavailable.');
+            }
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=plugin.js.map

package/dist/cli/commands/provider.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Provider CLI Commands
+ *
+ * Manage AI providers from the command line.
+ *
+ * Usage:
+ *   profclaw provider list
+ *   profclaw provider add <type>
+ *   profclaw provider remove <type>
+ *   profclaw provider test [type]
+ *   profclaw provider default [type]
+ *   profclaw provider models [type]
+ */
+import { Command } from 'commander';
+export declare function providerCommands(): Command;
+//# sourceMappingURL=provider.d.ts.map