profclaw 0.0.1-beta.1

package/dist/cli/commands/doctor.js

@@ -0,0 +1,295 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as os from 'os';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { api } from '../utils/api.js';
+import { success, error, info, spinner } from '../utils/output.js';
+const execFileAsync = promisify(execFile);
+async function checkNode() {
+    const version = process.version;
+    const major = parseInt(version.slice(1).split('.')[0], 10);
+    if (major >= 22) {
+        return { name: 'Node.js', status: 'pass', message: `${version}` };
+    }
+    return {
+        name: 'Node.js',
+        status: 'fail',
+        message: `${version} (requires >= 22)`,
+        fix: 'nvm install 22',
+    };
+}
+async function checkRedis() {
+    const redisUrl = process.env.REDIS_URL;
+    if (!redisUrl) {
+        return {
+            name: 'Redis',
+            status: 'warn',
+            message: 'REDIS_URL not set (optional for pico/mini mode)',
+            fix: 'docker compose up redis -d',
+        };
+    }
+    try {
+        const url = new URL(redisUrl);
+        const net = await import('net');
+        return new Promise((resolve) => {
+            const socket = net.createConnection({ host: url.hostname, port: parseInt(url.port || '6379', 10), timeout: 3000 }, () => {
+                socket.destroy();
+                resolve({ name: 'Redis', status: 'pass', message: `Connected (${url.hostname}:${url.port || '6379'})` });
+            });
+            socket.on('error', () => {
+                socket.destroy();
+                resolve({ name: 'Redis', status: 'fail', message: `Cannot connect to ${redisUrl}`, fix: 'docker compose up redis -d' });
+            });
+            socket.on('timeout', () => {
+                socket.destroy();
+                resolve({ name: 'Redis', status: 'fail', message: `Connection timeout to ${redisUrl}`, fix: 'docker compose up redis -d' });
+            });
+        });
+    }
+    catch {
+        return { name: 'Redis', status: 'fail', message: 'Invalid REDIS_URL', fix: 'Set REDIS_URL=redis://localhost:6379' };
+    }
+}
+async function checkOllama() {
+    try {
+        const response = await fetch('http://localhost:11434/api/tags', { signal: AbortSignal.timeout(3000) });
+        if (response.ok) {
+            const data = await response.json();
+            const count = Array.isArray(data?.models) ? data.models.length : 0;
+            return { name: 'Ollama', status: 'pass', message: `Running (${count} models)` };
+        }
+        return { name: 'Ollama', status: 'warn', message: 'Responding but unhealthy' };
+    }
+    catch {
+        return {
+            name: 'Ollama',
+            status: 'warn',
+            message: 'Not running (optional)',
+            fix: 'https://ollama.com/download',
+        };
+    }
+}
+async function checkServer() {
+    const result = await api.get('/health');
+    if (result.ok) {
+        return { name: 'Server', status: 'pass', message: 'Running and healthy' };
+    }
+    return {
+        name: 'Server',
+        status: 'fail',
+        message: result.error || 'Not reachable',
+        fix: 'profclaw serve',
+    };
+}
+async function checkDatabase() {
+    const result = await api.get('/api/setup/status');
+    if (result.ok && result.data?.configured) {
+        return { name: 'Database', status: 'pass', message: 'Configured and accessible' };
+    }
+    if (result.ok) {
+        return { name: 'Database', status: 'warn', message: 'Not fully configured', fix: 'profclaw setup' };
+    }
+    return {
+        name: 'Database',
+        status: 'warn',
+        message: 'Cannot check (server not running)',
+        fix: 'profclaw serve && profclaw setup',
+    };
+}
+async function checkProvider() {
+    const result = await api.get('/api/chat/providers');
+    if (!result.ok) {
+        return { name: 'AI Provider', status: 'warn', message: 'Cannot check (server not running)', fix: 'profclaw serve' };
+    }
+    const active = result.data?.providers?.filter((p) => p.enabled) || [];
+    if (active.length === 0) {
+        return { name: 'AI Provider', status: 'fail', message: 'No providers configured', fix: 'profclaw provider add anthropic' };
+    }
+    const healthy = active.filter((p) => p.healthy);
+    if (healthy.length === 0) {
+        return { name: 'AI Provider', status: 'warn', message: `${active.length} configured but none healthy` };
+    }
+    return { name: 'AI Provider', status: 'pass', message: `${healthy.length}/${active.length} healthy` };
+}
+async function checkMemory() {
+    const freeBytes = os.freemem();
+    const freeMB = Math.round(freeBytes / 1024 / 1024);
+    const freeGB = (freeBytes / 1024 / 1024 / 1024).toFixed(1);
+    if (freeMB > 512) {
+        return { name: 'Memory', status: 'pass', message: `${freeGB} GB free` };
+    }
+    if (freeMB > 256) {
+        return { name: 'Memory', status: 'warn', message: `${freeGB} GB free (low)` };
+    }
+    return { name: 'Memory', status: 'fail', message: `${freeGB} GB free (critically low)`, fix: 'Close unused applications' };
+}
+async function checkCloudflared() {
+    const result = await api.get('/api/tunnels/status');
+    if (!result.ok) {
+        // Try local check
+        try {
+            const { execSync } = await import('child_process');
+            execSync('which cloudflared', { stdio: 'ignore' });
+            return { name: 'Cloudflared', status: 'pass', message: 'Installed (server not running for full check)' };
+        }
+        catch {
+            return { name: 'Cloudflared', status: 'warn', message: 'Not found (optional)', fix: 'brew install cloudflared' };
+        }
+    }
+    if (result.data?.cloudflare?.available) {
+        return { name: 'Cloudflared', status: 'pass', message: `Installed${result.data.cloudflare.version ? ` (${result.data.cloudflare.version})` : ''}` };
+    }
+    return { name: 'Cloudflared', status: 'warn', message: 'Not installed (optional)', fix: 'brew install cloudflared' };
+}
+async function checkPort() {
+    const port = parseInt(process.env.PORT || '3000', 10);
+    const net = await import('net');
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve({ name: 'Port', status: 'pass', message: `Port ${port} in use (server likely running)` });
+            }
+            else {
+                resolve({ name: 'Port', status: 'warn', message: `Port ${port}: ${err.message}` });
+            }
+        });
+        server.once('listening', () => {
+            server.close();
+            resolve({ name: 'Port', status: 'pass', message: `Port ${port} available` });
+        });
+        server.listen(port, '127.0.0.1');
+    });
+}
+async function checkConfigFiles() {
+    const cwd = process.cwd();
+    const required = ['config/settings.yml'];
+    const optional = ['config/pricing.yml', '.env'];
+    const missing = required.filter((f) => !existsSync(join(cwd, f)));
+    const presentOptional = optional.filter((f) => existsSync(join(cwd, f)));
+    if (missing.length > 0) {
+        return {
+            name: 'Config',
+            status: 'fail',
+            message: `Missing: ${missing.join(', ')}`,
+            fix: 'profclaw setup',
+        };
+    }
+    const extras = presentOptional.length > 0 ? ` (+${presentOptional.join(', ')})` : '';
+    return { name: 'Config', status: 'pass', message: `settings.yml found${extras}` };
+}
+async function checkDiskSpace() {
+    try {
+        const { stdout } = await execFileAsync('df', ['-h', process.cwd()], { timeout: 5000 });
+        const lines = stdout.trim().split('\n');
+        if (lines.length >= 2) {
+            const parts = lines[1].split(/\s+/);
+            const available = parts[3] || 'unknown';
+            const usePct = parseInt(parts[4] || '0', 10);
+            if (usePct > 95) {
+                return { name: 'Disk', status: 'fail', message: `${available} free (${usePct}% used)`, fix: 'Free up disk space' };
+            }
+            if (usePct > 85) {
+                return { name: 'Disk', status: 'warn', message: `${available} free (${usePct}% used)` };
+            }
+            return { name: 'Disk', status: 'pass', message: `${available} free (${usePct}% used)` };
+        }
+        return { name: 'Disk', status: 'pass', message: 'Readable' };
+    }
+    catch {
+        return { name: 'Disk', status: 'warn', message: 'Could not check disk space' };
+    }
+}
+async function checkTailscale() {
+    const result = await api.get('/api/tunnels/status');
+    if (!result.ok) {
+        try {
+            await execFileAsync('which', ['tailscale'], { timeout: 3000 });
+            return { name: 'Tailscale', status: 'pass', message: 'Installed (server not running for full check)' };
+        }
+        catch {
+            return { name: 'Tailscale', status: 'warn', message: 'Not found (optional)', fix: 'https://tailscale.com/download' };
+        }
+    }
+    if (result.data?.tailscale?.available) {
+        return { name: 'Tailscale', status: 'pass', message: `Installed${result.data.tailscale.url ? ` (${result.data.tailscale.url})` : ''}` };
+    }
+    return { name: 'Tailscale', status: 'warn', message: 'Not installed (optional)', fix: 'https://tailscale.com/download' };
+}
+function formatCheck(result) {
+    const icon = result.status === 'pass' ? chalk.green('✓')
+        : result.status === 'warn' ? chalk.yellow('⚠')
+            : chalk.red('✗');
+    const nameCol = result.name.padEnd(14);
+    console.log(`  ${icon} ${chalk.bold(nameCol)} ${result.message}`);
+    if (result.fix && result.status !== 'pass') {
+        console.log(`    ${chalk.dim('Fix:')} ${chalk.cyan(result.fix)}`);
+    }
+}
+export function doctorCommand() {
+    const cmd = new Command('doctor')
+        .description('Run system diagnostics')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        console.log(chalk.bold('\nprofClaw Doctor\n'));
+        const checks = [
+            { name: 'Node.js', fn: checkNode },
+            { name: 'Config', fn: checkConfigFiles },
+            { name: 'Port', fn: checkPort },
+            { name: 'Redis', fn: checkRedis },
+            { name: 'Ollama', fn: checkOllama },
+            { name: 'Server', fn: checkServer },
+            { name: 'Database', fn: checkDatabase },
+            { name: 'AI Provider', fn: checkProvider },
+            { name: 'Memory', fn: checkMemory },
+            { name: 'Disk', fn: checkDiskSpace },
+            { name: 'Cloudflared', fn: checkCloudflared },
+            { name: 'Tailscale', fn: checkTailscale },
+        ];
+        const results = [];
+        for (const check of checks) {
+            const spin = spinner(`Checking ${check.name}...`).start();
+            try {
+                const result = await check.fn();
+                results.push(result);
+                spin.stop();
+                formatCheck(result);
+            }
+            catch (err) {
+                spin.stop();
+                const result = {
+                    name: check.name,
+                    status: 'fail',
+                    message: err instanceof Error ? err.message : 'Unknown error',
+                };
+                results.push(result);
+                formatCheck(result);
+            }
+        }
+        if (options.json) {
+            console.log(JSON.stringify(results, null, 2));
+            return;
+        }
+        const passed = results.filter((r) => r.status === 'pass').length;
+        const warnings = results.filter((r) => r.status === 'warn').length;
+        const failed = results.filter((r) => r.status === 'fail').length;
+        console.log('');
+        const total = results.length;
+        if (failed === 0 && warnings === 0) {
+            success(`All ${total} checks passed`);
+        }
+        else if (failed === 0) {
+            info(`${passed}/${total} passed, ${warnings} warnings`);
+        }
+        else {
+            error(`${passed}/${total} passed, ${warnings} warnings, ${failed} failed`);
+            process.exitCode = 1;
+        }
+        console.log('');
+    });
+    return cmd;
+}
+//# sourceMappingURL=doctor.js.map

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

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

package/dist/cli/commands/logs.js

@@ -0,0 +1,139 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getConfig } from '../utils/config.js';
+import { api } from '../utils/api.js';
+import { spinner, error, createTable, formatRelativeTime } from '../utils/output.js';
+function levelColor(level) {
+    switch (level) {
+        case 'debug': return chalk.dim(level.toUpperCase());
+        case 'info': return chalk.blue(level.toUpperCase());
+        case 'warn': return chalk.yellow(level.toUpperCase());
+        case 'error': return chalk.red(level.toUpperCase());
+        default: return String(level).toUpperCase();
+    }
+}
+function parseSince(since) {
+    const match = /^(\d+)([smhd])$/.exec(since);
+    if (!match)
+        return Date.now() - 60 * 60 * 1000; // default 1h
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    const multipliers = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
+    return Date.now() - value * (multipliers[unit] ?? 3600000);
+}
+export function logsCommand() {
+    const cmd = new Command('logs')
+        .description('View and filter server logs')
+        .option('--level <level>', 'Filter by log level (debug|info|warn|error)')
+        .option('--component <name>', 'Filter by component name')
+        .option('--since <duration>', 'Show logs since duration (e.g. 1h, 30m, 2d)', '1h')
+        .option('-l, --limit <n>', 'Max log entries to show', '50')
+        .option('-f, --follow', 'Follow log stream (SSE)')
+        .option('--json', 'Output as JSON');
+    cmd.action(async (options) => {
+        if (options.follow) {
+            await followLogs(options);
+            return;
+        }
+        const spin = spinner('Fetching logs...').start();
+        try {
+            const params = new URLSearchParams({ limit: options.limit });
+            if (options.level)
+                params.set('level', options.level);
+            if (options.component)
+                params.set('component', options.component);
+            if (options.since)
+                params.set('since', String(parseSince(options.since)));
+            const result = await api.get(`/api/logs?${params}`);
+            spin.stop();
+            if (!result.ok) {
+                error(result.error || 'Failed to fetch logs');
+                process.exit(1);
+            }
+            const { logs } = result.data;
+            if (options.json) {
+                console.log(JSON.stringify(logs, null, 2));
+                return;
+            }
+            if (logs.length === 0) {
+                console.log(chalk.dim('No logs found for the given filters.'));
+                return;
+            }
+            const table = createTable(['Time', 'Level', 'Component', 'Message']);
+            for (const entry of logs) {
+                table.push([
+                    formatRelativeTime(entry.timestamp),
+                    levelColor(entry.level),
+                    chalk.dim(entry.component || '-'),
+                    entry.message,
+                ]);
+            }
+            console.log(table.toString());
+            console.log(chalk.dim(`\nShowing ${logs.length} log entries`));
+        }
+        catch (err) {
+            spin.stop();
+            error(err instanceof Error ? err.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+async function followLogs(options) {
+    const config = getConfig();
+    const baseUrl = config.apiUrl || 'http://localhost:3000';
+    const params = new URLSearchParams({ stream: '1' });
+    if (options.level)
+        params.set('level', options.level);
+    if (options.component)
+        params.set('component', options.component);
+    const headers = { Accept: 'text/event-stream' };
+    if (config.apiToken)
+        headers['Authorization'] = `Bearer ${config.apiToken}`;
+    console.log(chalk.dim(`Following logs... (Ctrl+C to stop)\n`));
+    try {
+        const response = await fetch(`${baseUrl}/api/logs?${params}`, { headers });
+        if (!response.ok || !response.body) {
+            error(`Failed to connect to log stream: HTTP ${response.status}`);
+            process.exit(1);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    const raw = line.slice(6).trim();
+                    if (!raw || raw === '[DONE]')
+                        continue;
+                    try {
+                        const entry = JSON.parse(raw);
+                        if (options.json) {
+                            console.log(JSON.stringify(entry));
+                        }
+                        else {
+                            const time = new Date(entry.timestamp).toISOString().slice(11, 23);
+                            const level = levelColor(entry.level);
+                            const component = entry.component ? chalk.dim(`[${entry.component}] `) : '';
+                            console.log(`${chalk.dim(time)} ${level} ${component}${entry.message}`);
+                        }
+                    }
+                    catch {
+                        // ignore parse errors on stream
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        error(err instanceof Error ? err.message : 'Stream error');
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=logs.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * MCP CLI Commands
+ *
+ * Manage MCP server connections from the command line.
+ *
+ * Usage:
+ *   profclaw mcp status
+ *   profclaw mcp list-tools
+ *   profclaw mcp connect <name>
+ *   profclaw mcp disconnect <name>
+ *   profclaw mcp serve
+ */
+import { Command } from 'commander';
+export declare function mcpCommands(): Command;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/cli/commands/mcp.js

@@ -0,0 +1,157 @@
+/**
+ * MCP CLI Commands
+ *
+ * Manage MCP server connections from the command line.
+ *
+ * Usage:
+ *   profclaw mcp status
+ *   profclaw mcp list-tools
+ *   profclaw mcp connect <name>
+ *   profclaw mcp disconnect <name>
+ *   profclaw mcp serve
+ */
+import { spawn } from 'child_process';
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { api } from '../utils/api.js';
+import { createTable, success, error, info, spinner, truncate } from '../utils/output.js';
+export function mcpCommands() {
+    const cmd = new Command('mcp')
+        .description('Manage MCP server connections');
+    // profclaw mcp status
+    cmd
+        .command('status')
+        .description('Show MCP server connection status')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spin = spinner('Fetching MCP status...').start();
+        const result = await api.get('/api/mcp/status');
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to fetch MCP status');
+            process.exit(1);
+        }
+        const { servers } = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(result.data, null, 2));
+            return;
+        }
+        if (servers.length === 0) {
+            info('No MCP servers configured.');
+            info('Add MCP servers to your profClaw config to connect.');
+            return;
+        }
+        const table = createTable(['Name', 'Transport', 'Status', 'Tools']);
+        for (const s of servers) {
+            const statusDisplay = s.connected
+                ? chalk.green('● connected')
+                : chalk.red('● disconnected');
+            const toolsDisplay = s.connected
+                ? chalk.cyan(String(s.toolCount))
+                : chalk.dim('-');
+            table.push([chalk.bold(s.name), chalk.dim(s.transport), statusDisplay, toolsDisplay]);
+        }
+        console.log(table.toString());
+        const connected = servers.filter((s) => s.connected).length;
+        console.log(chalk.dim(`\n${connected}/${servers.length} server${servers.length !== 1 ? 's' : ''} connected`));
+    });
+    // profclaw mcp list-tools
+    cmd
+        .command('list-tools')
+        .alias('tools')
+        .description('List tools from all connected MCP servers')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spin = spinner('Fetching MCP tools...').start();
+        const result = await api.get('/api/mcp/tools');
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to fetch MCP tools');
+            process.exit(1);
+        }
+        const { tools } = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(result.data, null, 2));
+            return;
+        }
+        if (tools.length === 0) {
+            info('No tools available from connected MCP servers.');
+            info('Connect an MCP server first: profclaw mcp connect <name>');
+            return;
+        }
+        const table = createTable(['Tool', 'Server', 'Description']);
+        for (const t of tools) {
+            table.push([
+                chalk.cyan(t.name),
+                chalk.bold(t.server),
+                chalk.dim(truncate(t.description, 60)),
+            ]);
+        }
+        console.log(table.toString());
+        console.log(chalk.dim(`\n${tools.length} tool${tools.length !== 1 ? 's' : ''} available`));
+    });
+    // profclaw mcp connect <name>
+    cmd
+        .command('connect <name>')
+        .description('Connect to a configured MCP server by name')
+        .option('--json', 'Output as JSON')
+        .action(async (name, options) => {
+        const spin = spinner(`Connecting to ${chalk.cyan(name)}...`).start();
+        const result = await api.post(`/api/mcp/servers/${encodeURIComponent(name)}/connect`);
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || `Failed to connect to ${name}`);
+            process.exit(1);
+        }
+        if (options.json) {
+            console.log(JSON.stringify(result.data, null, 2));
+            return;
+        }
+        success(`Connected to MCP server ${chalk.cyan(name)}`);
+    });
+    // profclaw mcp disconnect <name>
+    cmd
+        .command('disconnect <name>')
+        .description('Disconnect from an MCP server')
+        .option('--json', 'Output as JSON')
+        .action(async (name, options) => {
+        const spin = spinner(`Disconnecting from ${chalk.cyan(name)}...`).start();
+        const result = await api.post(`/api/mcp/servers/${encodeURIComponent(name)}/disconnect`);
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || `Failed to disconnect from ${name}`);
+            process.exit(1);
+        }
+        if (options.json) {
+            console.log(JSON.stringify(result.data, null, 2));
+            return;
+        }
+        success(`Disconnected from MCP server ${chalk.cyan(name)}`);
+    });
+    // profclaw mcp serve
+    cmd
+        .command('serve')
+        .description('Start profClaw as a standalone MCP server (stdio mode)')
+        .action(() => {
+        info('Starting profClaw MCP server (stdio mode)...');
+        info('Connect from Claude Desktop or other MCP clients');
+        const child = spawn('node', ['dist/mcp/server.js'], {
+            stdio: 'inherit',
+            env: process.env,
+        });
+        child.on('error', (err) => {
+            error(`Failed to start MCP server: ${err.message}`);
+            error('Make sure to build first: pnpm build');
+            process.exit(1);
+        });
+        child.on('exit', (code) => {
+            if (code !== null && code !== 0) {
+                process.exit(code);
+            }
+        });
+        process.on('SIGINT', () => child.kill('SIGINT'));
+        process.on('SIGTERM', () => child.kill('SIGTERM'));
+    });
+    return cmd;
+}
+//# sourceMappingURL=mcp.js.map

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

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