profclaw 0.0.1-beta.1

package/dist/cli/commands/tunnel.js

@@ -0,0 +1,135 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { api } from '../utils/api.js';
+import { success, error, spinner } from '../utils/output.js';
+export function tunnelCommands() {
+    const cmd = new Command('tunnel')
+        .description('Manage tunnels (Cloudflare, Tailscale)');
+    // status (default)
+    cmd
+        .command('status', { isDefault: true })
+        .description('Show tunnel status')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spin = spinner('Fetching tunnel status...').start();
+        const result = await api.get('/api/tunnels/status');
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to fetch tunnel status');
+            process.exit(1);
+        }
+        const data = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        const cf = data.cloudflare;
+        const ts = data.tailscale;
+        console.log();
+        console.log(chalk.bold('Cloudflare Tunnel'));
+        if (!cf.available) {
+            console.log(`  Status:    ${chalk.dim('not available')}`);
+        }
+        else {
+            const cfStatus = cf.running ? chalk.green('running') : chalk.red('stopped');
+            console.log(`  Status:    ${cfStatus}`);
+            if (cf.activeUrl) {
+                console.log(`  URL:       ${cf.activeUrl}`);
+            }
+            if (cf.version) {
+                console.log(`  Version:   ${cf.version}`);
+            }
+        }
+        console.log();
+        console.log(chalk.bold('Tailscale'));
+        if (!ts.available) {
+            console.log(`  Status:    ${chalk.dim('not available')}`);
+        }
+        else {
+            const tsStatus = ts.serving ? chalk.green('connected') : chalk.red('not running');
+            console.log(`  Status:    ${tsStatus}`);
+            if (ts.url) {
+                console.log(`  URL:       ${ts.url}`);
+            }
+            if (ts.tailnet) {
+                console.log(`  Tailnet:   ${ts.tailnet}`);
+            }
+        }
+        console.log();
+    });
+    // start
+    cmd
+        .command('start')
+        .description('Start a Cloudflare quick tunnel')
+        .option('--port <n>', 'Local port to expose', '3000')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const port = parseInt(options.port ?? '3000', 10);
+        const spin = spinner('Starting Cloudflare tunnel...').start();
+        const result = await api.post('/api/tunnels/cloudflare/quick', { port });
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to start tunnel');
+            process.exit(1);
+        }
+        const data = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        success(`Tunnel started`);
+        console.log(`\n  ${chalk.bold('URL:')} ${chalk.cyan(data.url)}\n`);
+    });
+    // stop
+    cmd
+        .command('stop')
+        .description('Stop the active Cloudflare tunnel')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spin = spinner('Stopping tunnel...').start();
+        const result = await api.post('/api/tunnels/cloudflare/stop');
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to stop tunnel');
+            process.exit(1);
+        }
+        if (options.json) {
+            console.log(JSON.stringify(result.data, null, 2));
+            return;
+        }
+        success('Tunnel stopped');
+    });
+    // tailscale
+    cmd
+        .command('tailscale')
+        .description('Show detailed Tailscale status')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spin = spinner('Fetching Tailscale status...').start();
+        const result = await api.get('/api/tunnels/tailscale/status');
+        spin.stop();
+        if (!result.ok) {
+            error(result.error || 'Failed to fetch Tailscale status');
+            process.exit(1);
+        }
+        const data = result.data;
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        console.log();
+        console.log(chalk.bold('Tailscale Status'));
+        console.log(`  Available:  ${data.available ? chalk.green('yes') : chalk.red('no')}`);
+        console.log(`  Serving:    ${data.serving ? chalk.green('yes') : chalk.dim('no')}`);
+        console.log(`  Funneling:  ${data.funneling ? chalk.green('yes') : chalk.dim('no')}`);
+        if (data.url) {
+            console.log(`  URL:        ${data.url}`);
+        }
+        if (data.tailnet) {
+            console.log(`  Tailnet:    ${data.tailnet}`);
+        }
+        console.log();
+    });
+    return cmd;
+}
+//# sourceMappingURL=tunnel.js.map

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

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

package/dist/cli/commands/webhooks.js

@@ -0,0 +1,191 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { api } from '../utils/api.js';
+import { spinner, success, error, info, warn, createTable, formatRelativeTime, truncate } from '../utils/output.js';
+export function webhooksCommands() {
+    const cmd = new Command('webhooks')
+        .description('Manage webhook endpoints');
+    cmd
+        .command('list')
+        .alias('ls')
+        .description('List configured webhooks')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const spin = spinner('Fetching webhooks...').start();
+        try {
+            const result = await api.get('/api/webhooks');
+            spin.stop();
+            if (!result.ok) {
+                error(result.error || 'Failed to fetch webhooks');
+                process.exit(1);
+            }
+            const { webhooks } = result.data;
+            if (options.json) {
+                console.log(JSON.stringify(webhooks, null, 2));
+                return;
+            }
+            if (webhooks.length === 0) {
+                info('No webhooks configured.');
+                return;
+            }
+            const table = createTable(['ID', 'URL', 'Enabled', 'Deliveries', 'Last Delivery']);
+            for (const w of webhooks) {
+                table.push([
+                    chalk.dim(truncate(w.id, 12)),
+                    truncate(w.url, 40),
+                    w.enabled ? chalk.green('yes') : chalk.dim('no'),
+                    String(w.deliveryCount ?? 0),
+                    formatRelativeTime(w.lastDeliveryAt),
+                ]);
+            }
+            console.log(table.toString());
+            console.log(chalk.dim(`\n${webhooks.length} webhook${webhooks.length !== 1 ? 's' : ''}`));
+        }
+        catch (err) {
+            spin.stop();
+            error(err instanceof Error ? err.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+    cmd
+        .command('create <url>')
+        .description('Create a new webhook')
+        .option('--secret <secret>', 'Signing secret for payload verification')
+        .option('--json', 'Output as JSON')
+        .action(async (url, options) => {
+        const spin = spinner('Creating webhook...').start();
+        try {
+            const result = await api.post('/api/webhooks', { url, secret: options.secret });
+            spin.stop();
+            if (!result.ok) {
+                error(result.error || 'Failed to create webhook');
+                process.exit(1);
+            }
+            if (options.json) {
+                console.log(JSON.stringify(result.data, null, 2));
+                return;
+            }
+            const w = result.data;
+            success(`Webhook created`);
+            console.log(chalk.dim(`  ID:  ${w.id}`));
+            console.log(chalk.dim(`  URL: ${w.url}`));
+        }
+        catch (err) {
+            spin.stop();
+            error(err instanceof Error ? err.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+    cmd
+        .command('delete <id>')
+        .description('Delete a webhook')
+        .option('--yes', 'Skip confirmation')
+        .option('--json', 'Output as JSON')
+        .action(async (id, options) => {
+        if (!options.yes) {
+            const { createInterface } = await import('readline');
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            const confirmed = await new Promise((resolve) => {
+                rl.question(`Delete webhook ${id}? (y/N) `, (ans) => { rl.close(); resolve(ans.toLowerCase() === 'y'); });
+            });
+            if (!confirmed) {
+                info('Aborted.');
+                return;
+            }
+        }
+        const spin = spinner('Deleting webhook...').start();
+        try {
+            const result = await api.delete(`/api/webhooks/${id}`);
+            spin.stop();
+            if (!result.ok) {
+                error(result.error || 'Failed to delete webhook');
+                process.exit(1);
+            }
+            if (options.json) {
+                console.log(JSON.stringify({ ok: true, id }, null, 2));
+                return;
+            }
+            success(`Webhook ${id} deleted`);
+        }
+        catch (err) {
+            spin.stop();
+            error(err instanceof Error ? err.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+    cmd
+        .command('test <id>')
+        .description('Send a test delivery to a webhook')
+        .option('--json', 'Output as JSON')
+        .action(async (id, options) => {
+        const spin = spinner(`Sending test to webhook ${id}...`).start();
+        try {
+            const result = await api.post(`/api/webhooks/${id}/test`);
+            spin.stop();
+            if (!result.ok) {
+                error(result.error || 'Test delivery failed');
+                process.exit(1);
+            }
+            if (options.json) {
+                console.log(JSON.stringify(result.data, null, 2));
+                return;
+            }
+            const data = result.data;
+            if (data.ok) {
+                success(`Test delivery succeeded (HTTP ${data.status})`);
+            }
+            else {
+                warn(`Test delivery returned HTTP ${data.status}`);
+            }
+        }
+        catch (err) {
+            spin.stop();
+            error(err instanceof Error ? err.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+    cmd
+        .command('history <id>')
+        .description('Show delivery history for a webhook')
+        .option('-l, --limit <n>', 'Max deliveries to show', '20')
+        .option('--json', 'Output as JSON')
+        .action(async (id, options) => {
+        const spin = spinner('Fetching delivery history...').start();
+        try {
+            const result = await api.get(`/api/webhooks/${id}/history?limit=${options.limit}`);
+            spin.stop();
+            if (!result.ok) {
+                error(result.error || 'Failed to fetch history');
+                process.exit(1);
+            }
+            const { deliveries } = result.data;
+            if (options.json) {
+                console.log(JSON.stringify(deliveries, null, 2));
+                return;
+            }
+            if (deliveries.length === 0) {
+                info('No deliveries recorded.');
+                return;
+            }
+            const table = createTable(['ID', 'Event', 'Status', 'Duration', 'Time']);
+            for (const d of deliveries) {
+                const statusColor = d.status >= 200 && d.status < 300 ? chalk.green : chalk.red;
+                table.push([
+                    chalk.dim(truncate(d.id, 12)),
+                    d.event,
+                    statusColor(String(d.status)),
+                    d.duration != null ? `${d.duration}ms` : chalk.dim('-'),
+                    formatRelativeTime(d.createdAt),
+                ]);
+            }
+            console.log(table.toString());
+        }
+        catch (err) {
+            spin.stop();
+            error(err instanceof Error ? err.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=webhooks.js.map

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import figlet from 'figlet';
+import { taskCommands } from './commands/task.js';
+import { ticketCommands } from './commands/ticket.js';
+import { summaryCommands } from './commands/summary.js';
+import { agentCommands } from './commands/agent.js';
+import { configCommands } from './commands/config.js';
+import { costCommands } from './commands/cost.js';
+import { serveCommand } from './commands/serve.js';
+import { toolsCommands } from './commands/tools.js';
+import { authCommands } from './commands/auth.js';
+import { setupCommand } from './commands/setup.js';
+import { onboardCommand } from './commands/onboard.js';
+import { pluginCommands } from './commands/plugin.js';
+import { chatCommands } from './commands/chat.js';
+import { tunnelCommands } from './commands/tunnel.js';
+import { skillCommands } from './commands/skill.js';
+import { memoryCommands } from './commands/memory.js';
+import { statusCommand } from './commands/status.js';
+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
+function showBanner() {
+    const banner = figlet.textSync('profClaw', {
+        font: 'Standard',
+        horizontalLayout: 'default',
+    });
+    console.log(chalk.cyan(banner));
+    console.log(chalk.dim('  AI Agent Task Orchestrator'));
+    console.log(chalk.dim(`  Version ${VERSION}\n`));
+}
+// Create main program
+const program = new Command();
+program
+    .name('profclaw')
+    .description('profClaw - AI Agent Task Orchestration')
+    .version(VERSION, '-v, --version', 'Output the current version')
+    .option('--json', 'Output results as JSON')
+    .option('-q, --quiet', 'Suppress non-essential output');
+// Register command groups
+program.addCommand(taskCommands());
+program.addCommand(ticketCommands());
+program.addCommand(summaryCommands());
+program.addCommand(agentCommands());
+program.addCommand(configCommands());
+program.addCommand(costCommands());
+program.addCommand(serveCommand());
+program.addCommand(toolsCommands());
+program.addCommand(authCommands());
+program.addCommand(setupCommand());
+program.addCommand(onboardCommand());
+program.addCommand(pluginCommands());
+program.addCommand(chatCommands());
+program.addCommand(tunnelCommands());
+program.addCommand(skillCommands());
+program.addCommand(memoryCommands());
+program.addCommand(statusCommand());
+program.addCommand(sessionCommands());
+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(() => {
+    showBanner();
+    console.log(chalk.yellow('Quick Start:'));
+    console.log('  profclaw onboard          Zero-to-running wizard (new users)');
+    console.log('  profclaw setup            Configure AI provider, admin, etc.');
+    console.log('  profclaw serve            Start the server');
+    console.log('  profclaw task list        List all tasks');
+    console.log('  profclaw ticket list      List AI-native tickets');
+    console.log('  profclaw ticket create    Create a new ticket');
+    console.log('  profclaw config get       View current settings');
+    console.log('');
+    console.log(chalk.yellow('Auth & Users:'));
+    console.log('  profclaw auth invite      Generate invite codes');
+    console.log('  profclaw auth list-users  List all users');
+    console.log('  profclaw auth set-mode    Set registration mode');
+    console.log('');
+    console.log(chalk.yellow('Tool Testing:'));
+    console.log('  profclaw tools list       List all execution tools');
+    console.log('  profclaw tools run <cmd>  Execute a shell command');
+    console.log('  profclaw tools sysinfo    Show system information');
+    console.log('  profclaw tools git-status Show git status');
+    console.log('');
+    console.log(chalk.yellow('Infrastructure:'));
+    console.log('  profclaw tui              Terminal dashboard');
+    console.log('  profclaw logs -f          Follow server logs');
+    console.log('  profclaw models list      List AI models');
+    console.log('  profclaw channels list    List messaging channels');
+    console.log('  profclaw daemon install   Install as system service');
+    console.log('  profclaw completion zsh   Generate shell completions');
+    console.log('');
+    console.log(chalk.dim('Run `profclaw --help` for all commands'));
+});
+// Parse and execute (parseAsync required for async command actions)
+await program.parseAsync();
+//# sourceMappingURL=index.js.map

package/dist/cli/utils/api.d.ts

@@ -0,0 +1,17 @@
+export interface ApiResponse<T = unknown> {
+    ok: boolean;
+    status: number;
+    data?: T;
+    error?: string;
+}
+/**
+ * Make an API request to the profClaw server
+ */
+export declare function apiRequest<T = unknown>(method: 'GET' | 'POST' | 'PATCH' | 'DELETE', path: string, body?: unknown): Promise<ApiResponse<T>>;
+export declare const api: {
+    get: <T = unknown>(path: string) => Promise<ApiResponse<T>>;
+    post: <T = unknown>(path: string, body?: unknown) => Promise<ApiResponse<T>>;
+    patch: <T = unknown>(path: string, body?: unknown) => Promise<ApiResponse<T>>;
+    delete: <T = unknown>(path: string) => Promise<ApiResponse<T>>;
+};
+//# sourceMappingURL=api.d.ts.map

package/dist/cli/utils/api.js

@@ -0,0 +1,63 @@
+import { getConfig } from './config.js';
+/**
+ * Make an API request to the profClaw server
+ */
+export async function apiRequest(method, path, body) {
+    const config = getConfig();
+    const baseUrl = config.apiUrl || 'http://localhost:3000';
+    const url = `${baseUrl}${path}`;
+    try {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        // Add auth token if configured
+        if (config.apiToken) {
+            headers['Authorization'] = `Bearer ${config.apiToken}`;
+        }
+        const response = await fetch(url, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        const data = await response.json().catch(() => ({}));
+        if (!response.ok) {
+            const errorMessage = typeof data?.error === 'string' ? data.error
+                : typeof data?.message === 'string' ? data.message
+                    : `HTTP ${response.status}`;
+            return {
+                ok: false,
+                status: response.status,
+                error: errorMessage,
+            };
+        }
+        return {
+            ok: true,
+            status: response.status,
+            data: data,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        // Check for connection refused
+        if (message.includes('ECONNREFUSED') || message.includes('fetch failed')) {
+            return {
+                ok: false,
+                status: 0,
+                error: `Cannot connect to profClaw server at ${baseUrl}. Is it running? Try: profclaw serve`,
+            };
+        }
+        return {
+            ok: false,
+            status: 0,
+            error: message,
+        };
+    }
+}
+// Convenience methods
+export const api = {
+    get: (path) => apiRequest('GET', path),
+    post: (path, body) => apiRequest('POST', path, body),
+    patch: (path, body) => apiRequest('PATCH', path, body),
+    delete: (path) => apiRequest('DELETE', path),
+};
+//# sourceMappingURL=api.js.map

package/dist/cli/utils/config.d.ts

@@ -0,0 +1,31 @@
+export interface CLIConfig {
+    apiUrl: string;
+    apiToken?: string;
+    defaultAgent?: string;
+    outputFormat: 'table' | 'json';
+}
+/**
+ * Get the config file path
+ */
+export declare function getConfigPath(): string;
+/**
+ * Load configuration from file
+ */
+export declare function getConfig(): CLIConfig;
+/**
+ * Save configuration to file
+ */
+export declare function saveConfig(updates: Partial<CLIConfig>): void;
+/**
+ * Get a specific config value
+ */
+export declare function getConfigValue<K extends keyof CLIConfig>(key: K): CLIConfig[K];
+/**
+ * Set a specific config value
+ */
+export declare function setConfigValue<K extends keyof CLIConfig>(key: K, value: CLIConfig[K]): void;
+/**
+ * Clear cached config (for testing)
+ */
+export declare function clearConfigCache(): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/cli/utils/config.js

@@ -0,0 +1,81 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+const DEFAULT_CONFIG = {
+    apiUrl: 'http://localhost:3000',
+    outputFormat: 'table',
+};
+let cachedConfig = null;
+/**
+ * Get the config file path
+ */
+export function getConfigPath() {
+    // Check for project-level config first
+    const projectConfig = join(process.cwd(), '.profclaw.json');
+    if (existsSync(projectConfig)) {
+        return projectConfig;
+    }
+    // Fall back to user-level config
+    return join(homedir(), '.profclaw', 'config.json');
+}
+/**
+ * Load configuration from file
+ */
+export function getConfig() {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    const configPath = getConfigPath();
+    let config = { ...DEFAULT_CONFIG };
+    if (existsSync(configPath)) {
+        try {
+            const content = readFileSync(configPath, 'utf-8');
+            config = { ...DEFAULT_CONFIG, ...JSON.parse(content) };
+        }
+        catch {
+            // Use default config on parse error
+        }
+    }
+    // Environment variable overrides
+    if (process.env.PROFCLAW_API_URL) {
+        config.apiUrl = process.env.PROFCLAW_API_URL;
+    }
+    if (process.env.PROFCLAW_API_TOKEN) {
+        config.apiToken = process.env.PROFCLAW_API_TOKEN;
+    }
+    cachedConfig = config;
+    return config;
+}
+/**
+ * Save configuration to file
+ */
+export function saveConfig(updates) {
+    const configPath = join(homedir(), '.profclaw', 'config.json');
+    const dir = dirname(configPath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    const current = getConfig();
+    const newConfig = { ...current, ...updates };
+    writeFileSync(configPath, JSON.stringify(newConfig, null, 2));
+    cachedConfig = newConfig;
+}
+/**
+ * Get a specific config value
+ */
+export function getConfigValue(key) {
+    return getConfig()[key];
+}
+/**
+ * Set a specific config value
+ */
+export function setConfigValue(key, value) {
+    saveConfig({ [key]: value });
+}
+/**
+ * Clear cached config (for testing)
+ */
+export function clearConfigCache() {
+    cachedConfig = null;
+}
+//# sourceMappingURL=config.js.map