profclaw 0.0.1-beta.1

package/dist/cli/commands/provider.js

@@ -0,0 +1,320 @@
+/**
+ * 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';
+import * as readline from 'readline';
+import chalk from 'chalk';
+import { api } from '../utils/api.js';
+import { createTable, success, error, info, spinner, truncate } from '../utils/output.js';
+function confirm(message) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(`${message} (y/N) `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y');
+        });
+    });
+}
+function promptSecret(message) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        process.stdout.write(message);
+        const stdin = process.stdin;
+        const wasRaw = stdin.isRaw;
+        if (stdin.isTTY)
+            stdin.setRawMode(true);
+        let input = '';
+        const onData = (char) => {
+            const c = char.toString();
+            if (c === '\n' || c === '\r') {
+                if (stdin.isTTY)
+                    stdin.setRawMode(wasRaw ?? false);
+                stdin.removeListener('data', onData);
+                process.stdout.write('\n');
+                rl.close();
+                resolve(input);
+            }
+            else if (c === '\u0003') {
+                rl.close();
+                process.exit(0);
+            }
+            else if (c === '\u007f') {
+                input = input.slice(0, -1);
+            }
+            else {
+                input += c;
+            }
+        };
+        stdin.on('data', onData);
+    });
+}
+export function providerCommands() {
+    const cmd = new Command('provider')
+        .description('Manage AI providers');
+    // profclaw provider list
+    cmd
+        .command('list')
+        .alias('ls')
+        .description('List configured AI providers')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spin = spinner('Fetching providers...').start();
+        const result = await api.get('/api/chat/providers');
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to fetch providers');
+            process.exit(1);
+        }
+        const { default: defaultProvider, providers } = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(result.data, null, 2));
+            return;
+        }
+        if (providers.length === 0) {
+            info('No providers configured.');
+            info('Add one: profclaw provider add <type>');
+            return;
+        }
+        const table = createTable(['Type', 'Enabled', 'Default', 'Status']);
+        for (const p of providers) {
+            const isDefault = p.type === defaultProvider;
+            const typeDisplay = isDefault ? chalk.cyan(p.type) + chalk.yellow(' *') : p.type;
+            const enabledDisplay = p.enabled ? chalk.green('yes') : chalk.dim('no');
+            const defaultDisplay = isDefault ? chalk.yellow('yes') : chalk.dim('no');
+            let statusDisplay;
+            if (p.healthy) {
+                const latency = p.latencyMs != null ? chalk.dim(` ${p.latencyMs}ms`) : '';
+                statusDisplay = chalk.green('● healthy') + latency;
+            }
+            else {
+                statusDisplay = chalk.red('● unhealthy');
+            }
+            table.push([typeDisplay, enabledDisplay, defaultDisplay, statusDisplay]);
+        }
+        console.log(table.toString());
+        console.log(chalk.dim(`\nDefault: ${defaultProvider || 'none'}`));
+    });
+    // profclaw provider add <type>
+    cmd
+        .command('add <type>')
+        .description('Add and configure an AI provider')
+        .option('--json', 'Output as JSON')
+        .action(async (type, options) => {
+        const apiKey = await promptSecret(`Enter API key for ${chalk.cyan(type)}: `);
+        if (!apiKey.trim()) {
+            error('API key cannot be empty');
+            process.exit(1);
+        }
+        const spin = spinner(`Configuring ${type}...`).start();
+        const configResult = await api.post(`/api/chat/providers/${type}/configure`, { type, apiKey });
+        spin.stop();
+        if (!configResult.ok) {
+            error(configResult.error || `Failed to configure ${type}`);
+            process.exit(1);
+        }
+        success(`Provider ${chalk.cyan(type)} configured`);
+        const healthSpin = spinner(`Testing ${type}...`).start();
+        const healthResult = await api.post(`/api/chat/providers/${type}/health`);
+        healthSpin.stop();
+        if (!healthResult.ok) {
+            error(healthResult.error || 'Health check failed');
+            return;
+        }
+        const health = healthResult.data;
+        if (options.json) {
+            console.log(JSON.stringify({ type, configured: true, ...health }, null, 2));
+            return;
+        }
+        if (health.healthy) {
+            const latency = health.latencyMs != null ? chalk.dim(` (${health.latencyMs}ms)`) : '';
+            success(`Health check passed${latency}`);
+        }
+        else {
+            error(`Health check failed: ${health.error || 'Unknown error'}`);
+        }
+    });
+    // profclaw provider remove <type>
+    cmd
+        .command('remove <type>')
+        .description('Remove a provider configuration')
+        .option('--yes', 'Skip confirmation')
+        .option('--json', 'Output as JSON')
+        .action(async (type, options) => {
+        if (!options.yes) {
+            const ok = await confirm(`Remove provider ${chalk.cyan(type)}?`);
+            if (!ok) {
+                info('Aborted.');
+                return;
+            }
+        }
+        const spin = spinner(`Removing ${type}...`).start();
+        const result = await api.patch('/api/settings', {
+            providers: { [type]: null },
+        });
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || `Failed to remove ${type}`);
+            process.exit(1);
+        }
+        if (options.json) {
+            console.log(JSON.stringify({ removed: type }, null, 2));
+            return;
+        }
+        success(`Provider ${chalk.cyan(type)} removed`);
+    });
+    // profclaw provider test [type]
+    cmd
+        .command('test [type]')
+        .description('Test provider health (all or a specific type)')
+        .option('--json', 'Output as JSON')
+        .action(async (type, options) => {
+        if (type) {
+            const spin = spinner(`Testing ${type}...`).start();
+            const result = await api.post(`/api/chat/providers/${type}/health`);
+            spin.stop();
+            if (!result.ok) {
+                error(result.error || `Failed to test ${type}`);
+                process.exit(1);
+            }
+            const health = result.data;
+            if (options.json) {
+                console.log(JSON.stringify({ type, ...health }, null, 2));
+                return;
+            }
+            if (health.healthy) {
+                const latency = health.latencyMs != null ? ` (${health.latencyMs}ms)` : '';
+                success(`${chalk.cyan(type)} is healthy${latency}`);
+            }
+            else {
+                error(`${chalk.cyan(type)} is unhealthy: ${health.error || 'Unknown error'}`);
+            }
+            return;
+        }
+        // Test all configured providers
+        const listSpin = spinner('Fetching providers...').start();
+        const listResult = await api.get('/api/chat/providers');
+        listSpin.stop();
+        if (!listResult.ok) {
+            error(listResult.error || 'Failed to fetch providers');
+            process.exit(1);
+        }
+        const active = listResult.data.providers.filter((p) => p.enabled);
+        if (active.length === 0) {
+            info('No configured providers to test.');
+            return;
+        }
+        const results = [];
+        for (const p of active) {
+            const spin = spinner(`Testing ${p.type}...`).start();
+            const healthResult = await api.post(`/api/chat/providers/${p.type}/health`);
+            spin.stop();
+            if (healthResult.ok && healthResult.data) {
+                results.push({ type: p.type, ...healthResult.data });
+            }
+            else {
+                results.push({ type: p.type, healthy: false, error: healthResult.error || 'Failed' });
+            }
+        }
+        if (options.json) {
+            console.log(JSON.stringify(results, null, 2));
+            return;
+        }
+        const table = createTable(['Provider', 'Status', 'Latency']);
+        for (const r of results) {
+            const statusDisplay = r.healthy ? chalk.green('● healthy') : chalk.red('● unhealthy');
+            const latencyDisplay = r.latencyMs != null ? `${r.latencyMs}ms` : chalk.dim('-');
+            table.push([r.type, statusDisplay, latencyDisplay]);
+        }
+        console.log(table.toString());
+    });
+    // profclaw provider default [type]
+    cmd
+        .command('default [type]')
+        .description('Get or set the default provider')
+        .option('--json', 'Output as JSON')
+        .action(async (type, options) => {
+        if (!type) {
+            const spin = spinner('Fetching providers...').start();
+            const result = await api.get('/api/chat/providers');
+            spin.stop();
+            if (!result.ok) {
+                error(result.error || 'Failed to fetch providers');
+                process.exit(1);
+            }
+            const defaultProvider = result.data.default;
+            if (options.json) {
+                console.log(JSON.stringify({ default: defaultProvider }, null, 2));
+                return;
+            }
+            if (defaultProvider) {
+                info(`Default provider: ${chalk.cyan(defaultProvider)}`);
+            }
+            else {
+                info('No default provider set.');
+            }
+            return;
+        }
+        const spin = spinner(`Setting default to ${type}...`).start();
+        const result = await api.post('/api/chat/providers/default', { provider: type });
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || `Failed to set default provider`);
+            process.exit(1);
+        }
+        if (options.json) {
+            console.log(JSON.stringify(result.data, null, 2));
+            return;
+        }
+        success(`Default provider set to ${chalk.cyan(type)}`);
+    });
+    // profclaw provider models [type]
+    cmd
+        .command('models [type]')
+        .description('List available models (optionally filtered by provider)')
+        .option('--json', 'Output as JSON')
+        .action(async (type, options) => {
+        const path = type ? `/api/chat/models?provider=${encodeURIComponent(type)}` : '/api/chat/models';
+        const spin = spinner('Fetching models...').start();
+        const result = await api.get(path);
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to fetch models');
+            process.exit(1);
+        }
+        const { models } = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(result.data, null, 2));
+            return;
+        }
+        if (models.length === 0) {
+            info('No models available.');
+            return;
+        }
+        const table = createTable(['Model', 'Provider', 'Context Window', 'Cost (in/out)']);
+        for (const m of models) {
+            const context = m.contextWindow != null
+                ? m.contextWindow >= 1000000
+                    ? `${(m.contextWindow / 1000000).toFixed(1)}M`
+                    : `${(m.contextWindow / 1000).toFixed(0)}K`
+                : chalk.dim('-');
+            const cost = m.costPer1MInput != null && m.costPer1MOutput != null
+                ? `$${m.costPer1MInput.toFixed(2)}/$${m.costPer1MOutput.toFixed(2)}`
+                : chalk.dim('-');
+            table.push([truncate(m.id, 40), m.provider, context, cost]);
+        }
+        console.log(table.toString());
+        console.log(chalk.dim(`\n${models.length} model${models.length !== 1 ? 's' : ''}`));
+    });
+    return cmd;
+}
+//# sourceMappingURL=provider.js.map

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

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function securityCommands(): Command;
+//# sourceMappingURL=security.d.ts.map

package/dist/cli/commands/security.js

@@ -0,0 +1,180 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { api } from '../utils/api.js';
+import { spinner, success, error, info, createTable, formatRelativeTime, truncate } from '../utils/output.js';
+const VALID_POLICIES = ['permissive', 'standard', 'strict'];
+function policyColor(level) {
+    if (level === 'permissive')
+        return chalk.green(level);
+    if (level === 'standard')
+        return chalk.yellow(level);
+    return chalk.red(level);
+}
+export function securityCommands() {
+    const cmd = new Command('security')
+        .description('Manage security policies and audit logs');
+    cmd
+        .command('status')
+        .description('Show current security status')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spin = spinner('Fetching security status...').start();
+        try {
+            const result = await api.get('/api/security/status');
+            spin.stop();
+            if (!result.ok) {
+                error(result.error || 'Failed to fetch security status');
+                process.exit(1);
+            }
+            const data = result.data;
+            if (options.json) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            console.log(`\n${chalk.bold('Security Status')}`);
+            console.log(`  ${chalk.dim('Policy:')}           ${policyColor(data.policy)}`);
+            console.log(`  ${chalk.dim('Pending Approvals:')} ${data.pendingApprovals > 0 ? chalk.yellow(data.pendingApprovals) : chalk.dim('0')}`);
+            console.log(`  ${chalk.dim('Last Audit:')}       ${formatRelativeTime(data.lastAudit)}`);
+            if (data.pendingApprovals > 0) {
+                info(`\n${data.pendingApprovals} item${data.pendingApprovals !== 1 ? 's' : ''} pending review. Run: profclaw security audit`);
+            }
+            console.log();
+        }
+        catch (err) {
+            spin.stop();
+            error(err instanceof Error ? err.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+    cmd
+        .command('set-policy <level>')
+        .description(`Set security policy level (${VALID_POLICIES.join('|')})`)
+        .option('--json', 'Output as JSON')
+        .action(async (level, options) => {
+        if (!VALID_POLICIES.includes(level)) {
+            error(`Invalid policy. Must be one of: ${VALID_POLICIES.join(', ')}`);
+            process.exit(1);
+        }
+        const spin = spinner(`Setting policy to ${level}...`).start();
+        try {
+            const result = await api.post('/api/security/policy', { level });
+            spin.stop();
+            if (!result.ok) {
+                error(result.error || 'Failed to set policy');
+                process.exit(1);
+            }
+            if (options.json) {
+                console.log(JSON.stringify(result.data, null, 2));
+                return;
+            }
+            success(`Security policy set to ${policyColor(level)}`);
+        }
+        catch (err) {
+            spin.stop();
+            error(err instanceof Error ? err.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+    cmd
+        .command('audit')
+        .description('Show security audit log')
+        .option('-l, --limit <n>', 'Max entries to show', '20')
+        .option('--pending', 'Show only pending approvals')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spin = spinner('Fetching audit log...').start();
+        try {
+            const params = new URLSearchParams({ limit: options.limit });
+            if (options.pending)
+                params.set('result', 'pending');
+            const result = await api.get(`/api/security/audit?${params}`);
+            spin.stop();
+            if (!result.ok) {
+                error(result.error || 'Failed to fetch audit log');
+                process.exit(1);
+            }
+            const { entries } = result.data;
+            if (options.json) {
+                console.log(JSON.stringify(entries, null, 2));
+                return;
+            }
+            if (entries.length === 0) {
+                info('No audit entries found.');
+                return;
+            }
+            const table = createTable(['ID', 'Action', 'Actor', 'Target', 'Result', 'Time']);
+            for (const e of entries) {
+                const resultColor = e.result === 'approved' ? chalk.green
+                    : e.result === 'denied' ? chalk.red
+                        : chalk.yellow;
+                table.push([
+                    chalk.dim(truncate(e.id, 12)),
+                    truncate(e.action, 20),
+                    truncate(e.actor, 16),
+                    truncate(e.target, 20),
+                    resultColor(e.result),
+                    formatRelativeTime(e.createdAt),
+                ]);
+            }
+            console.log(table.toString());
+        }
+        catch (err) {
+            spin.stop();
+            error(err instanceof Error ? err.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+    cmd
+        .command('approve <id>')
+        .description('Approve a pending security request')
+        .option('--json', 'Output as JSON')
+        .action(async (id, options) => {
+        const spin = spinner(`Approving request ${id}...`).start();
+        try {
+            const result = await api.post(`/api/security/approve/${id}`);
+            spin.stop();
+            if (!result.ok) {
+                error(result.error || 'Failed to approve request');
+                process.exit(1);
+            }
+            if (options.json) {
+                console.log(JSON.stringify(result.data, null, 2));
+                return;
+            }
+            success(`Request ${id} approved`);
+        }
+        catch (err) {
+            spin.stop();
+            error(err instanceof Error ? err.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+    cmd
+        .command('deny <id>')
+        .description('Deny a pending security request')
+        .option('--reason <reason>', 'Reason for denial')
+        .option('--json', 'Output as JSON')
+        .action(async (id, options) => {
+        const spin = spinner(`Denying request ${id}...`).start();
+        try {
+            const result = await api.post(`/api/security/deny/${id}`, { reason: options.reason });
+            spin.stop();
+            if (!result.ok) {
+                error(result.error || 'Failed to deny request');
+                process.exit(1);
+            }
+            if (options.json) {
+                console.log(JSON.stringify(result.data, null, 2));
+                return;
+            }
+            success(`Request ${id} denied`);
+        }
+        catch (err) {
+            spin.stop();
+            error(err instanceof Error ? err.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=security.js.map

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

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function serveCommand(): Command;
+//# sourceMappingURL=serve.d.ts.map

package/dist/cli/commands/serve.js

@@ -0,0 +1,179 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import figlet from 'figlet';
+import { spawn } from 'child_process';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+import { createServer } from 'net';
+import { success, error, info, warn } from '../utils/output.js';
+const MAX_RESTART_ATTEMPTS = 5;
+const BASE_BACKOFF_MS = 1000;
+const MAX_BACKOFF_MS = 30000;
+const CRASH_WINDOW_MS = 10000;
+const HEALTH_CHECK_DELAY_MS = 3000;
+const HEALTH_CHECK_TIMEOUT_MS = 5000;
+function checkPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve(false);
+            }
+            else {
+                resolve(true);
+            }
+        });
+        server.once('listening', () => {
+            server.close();
+            resolve(true);
+        });
+        server.listen(port, '127.0.0.1');
+    });
+}
+async function healthCheck(port) {
+    try {
+        const res = await fetch(`http://localhost:${port}/health`, {
+            signal: AbortSignal.timeout(HEALTH_CHECK_TIMEOUT_MS),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function getBackoffMs(attempt) {
+    const backoff = BASE_BACKOFF_MS * Math.pow(2, attempt);
+    return Math.min(backoff, MAX_BACKOFF_MS);
+}
+export function serveCommand() {
+    const serve = new Command('serve')
+        .description('Start the profClaw API server')
+        .option('-p, --port <port>', 'Port to listen on', '3000')
+        .option('--no-cron', 'Disable cron jobs')
+        .option('--dev', 'Run in development mode with watch')
+        .option('--no-restart', 'Disable auto-restart on crash')
+        .action(async (options) => {
+        // Show banner
+        const banner = figlet.textSync('profClaw', { font: 'Standard' });
+        console.log(chalk.cyan(banner));
+        console.log(chalk.dim('  AI Agent Task Orchestrator\n'));
+        const port = parseInt(options.port, 10);
+        // Pre-flight: check port availability
+        const portAvailable = await checkPortAvailable(port);
+        if (!portAvailable) {
+            error(`Port ${port} is already in use.`);
+            info('Options:');
+            console.log(`  1. Stop the existing process: ${chalk.cyan(`lsof -ti:${port} | xargs kill`)}`);
+            console.log(`  2. Use a different port: ${chalk.cyan(`profclaw serve -p ${port + 1}`)}`);
+            process.exit(1);
+        }
+        // Set environment variables
+        const env = {
+            ...process.env,
+            PORT: options.port,
+            ENABLE_CRON: options.cron === false ? 'false' : 'true',
+        };
+        // Determine the project root
+        const projectRoot = process.cwd();
+        let command;
+        let args;
+        if (options.dev) {
+            console.log(chalk.blue('Starting in development mode with watch...\n'));
+            command = 'npx';
+            args = ['tsx', 'watch', 'src/server.ts'];
+        }
+        else {
+            const hasDistServer = existsSync(resolve(projectRoot, 'dist/server.js'));
+            if (hasDistServer) {
+                command = 'node';
+                args = [resolve(projectRoot, 'dist/server.js')];
+            }
+            else {
+                command = 'npx';
+                args = ['tsx', 'src/server.ts'];
+            }
+            console.log(chalk.blue(`Starting server on port ${options.port}...\n`));
+        }
+        const autoRestart = options.restart !== false && !options.dev;
+        const state = {
+            attempts: 0,
+            lastCrashTime: 0,
+            shuttingDown: false,
+        };
+        function spawnServer() {
+            const child = spawn(command, args, {
+                cwd: projectRoot,
+                env,
+                stdio: 'inherit',
+            });
+            child.on('exit', (code, signal) => {
+                if (state.shuttingDown) {
+                    process.exit(code || 0);
+                    return;
+                }
+                // Signal-based exit (user Ctrl+C forwarded) - clean exit
+                if (signal === 'SIGINT' || signal === 'SIGTERM') {
+                    process.exit(0);
+                    return;
+                }
+                // Clean exit
+                if (code === 0) {
+                    process.exit(0);
+                    return;
+                }
+                // Crash detected
+                const now = Date.now();
+                // Reset attempt counter if the server ran for a while before crashing
+                if (now - state.lastCrashTime > CRASH_WINDOW_MS * MAX_RESTART_ATTEMPTS) {
+                    state.attempts = 0;
+                }
+                state.lastCrashTime = now;
+                state.attempts++;
+                if (!autoRestart) {
+                    error(`Server exited with code ${code}. Auto-restart is disabled.`);
+                    process.exit(code || 1);
+                    return;
+                }
+                if (state.attempts > MAX_RESTART_ATTEMPTS) {
+                    error(`Server crashed ${state.attempts} times in quick succession. Giving up.`);
+                    info('Check logs and fix the issue, then run: profclaw serve');
+                    process.exit(1);
+                    return;
+                }
+                const backoff = getBackoffMs(state.attempts - 1);
+                warn(`Server crashed (exit code ${code}). Restart attempt ${state.attempts}/${MAX_RESTART_ATTEMPTS} in ${Math.round(backoff / 1000)}s...`);
+                setTimeout(() => {
+                    if (state.shuttingDown)
+                        return;
+                    info('Restarting server...');
+                    spawnServer();
+                }, backoff);
+            });
+            // Run health check after startup delay (not in dev mode)
+            if (!options.dev) {
+                setTimeout(async () => {
+                    if (state.shuttingDown)
+                        return;
+                    const healthy = await healthCheck(port);
+                    if (healthy) {
+                        success(`Server healthy on port ${port}`);
+                    }
+                    else {
+                        warn('Server may not be fully ready yet. Check logs above.');
+                    }
+                }, HEALTH_CHECK_DELAY_MS);
+            }
+            return child;
+        }
+        const currentChild = spawnServer();
+        // Handle signals - forward to child, prevent restart
+        const shutdown = (sig) => {
+            state.shuttingDown = true;
+            currentChild.kill(sig);
+        };
+        process.on('SIGINT', () => shutdown('SIGINT'));
+        process.on('SIGTERM', () => shutdown('SIGTERM'));
+    });
+    return serve;
+}
+//# sourceMappingURL=serve.js.map

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

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function sessionCommands(): Command;
+//# sourceMappingURL=session.d.ts.map