commanderclaw 1.1.3

package/dist/cli/plugin.js

@@ -0,0 +1,400 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { execSync } from 'child_process';
+import { getPlatforms, findPlatform, rlWithDefault, maskToken, getTokenFromServer, backupFile, restoreBackup, DEFAULT_SERVER_URL, DEFAULT_DEVICE_NAME, } from './utils.js';
+export function handlePlugin(args) {
+    if (args.length === 0) {
+        printPluginUsage();
+        process.exit(1);
+    }
+    const cmd = args[0];
+    const platform = args[1];
+    switch (cmd) {
+        case 'install':
+            if (!platform) {
+                console.log('Error: platform name required');
+                console.log('Usage: commanderclaw plugin install <platform>');
+                printAvailablePlatforms();
+                process.exit(1);
+            }
+            handlePluginInstall(platform);
+            break;
+        case 'update':
+            if (!platform) {
+                console.log('Error: platform name required');
+                console.log('Usage: commanderclaw plugin update <platform>');
+                process.exit(1);
+            }
+            handlePluginUpdate(platform);
+            break;
+        case 'uninstall':
+            if (!platform) {
+                console.log('Error: platform name required');
+                console.log('Usage: commanderclaw plugin uninstall <platform>');
+                process.exit(1);
+            }
+            handlePluginUninstall(platform);
+            break;
+        case 'status':
+            handlePluginStatus();
+            break;
+        case 'list-platforms':
+            handleListPlatforms();
+            break;
+        default:
+            console.log(`Unknown plugin command: ${cmd}`);
+            printPluginUsage();
+            process.exit(1);
+    }
+}
+function printPluginUsage() {
+    console.log('Plugin management commands:');
+    console.log();
+    console.log('Usage:');
+    console.log('  commanderclaw plugin <command> [arguments]');
+    console.log();
+    console.log('Commands:');
+    console.log('  install <platform>   Install plugin to specified platform');
+    console.log('  update <platform>    Update installed plugin');
+    console.log('  uninstall <platform> Uninstall plugin from platform');
+    console.log('  status               Show installation status');
+    console.log('  list-platforms       List supported platforms');
+    console.log();
+    console.log('Supported platforms: qclaw, openclaw');
+}
+function printAvailablePlatforms() {
+    console.log('Available platforms:');
+    for (const p of getPlatforms()) {
+        const status = p.detectFunc() ? ' (installed)' : '';
+        console.log(`  ${p.name}  ${p.displayName}${status}`);
+    }
+}
+function handleListPlatforms() {
+    console.log('Supported platforms:');
+    console.log();
+    for (const p of getPlatforms()) {
+        const installed = p.detectFunc() ? 'installed' : 'not installed';
+        console.log(`  ${p.name.padEnd(12)} ${p.displayName} (${installed})`);
+    }
+}
+function handlePluginStatus() {
+    console.log('CommanderClaw Plugin Status');
+    console.log();
+    for (const p of getPlatforms()) {
+        console.log(`${p.displayName} (${p.name}):`);
+        if (!p.detectFunc()) {
+            console.log('  Status: not installed');
+            console.log();
+            continue;
+        }
+        const targetPath = path.join(p.extDir, 'commanderclaw');
+        if (fs.existsSync(targetPath)) {
+            const pkgPath = path.join(targetPath, 'package.json');
+            let version = 'unknown';
+            if (fs.existsSync(pkgPath)) {
+                try {
+                    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                    version = pkg.version || 'unknown';
+                }
+                catch { }
+            }
+            console.log(`  Status:  installed (v${version})`);
+            console.log(`  Path:    ${targetPath}`);
+        }
+        else {
+            console.log('  Status: not installed');
+        }
+        console.log();
+    }
+}
+async function handlePluginInstall(platformName) {
+    const platform = findPlatform(platformName);
+    if (!platform) {
+        console.log(`Error: Unknown platform: ${platformName}`);
+        printAvailablePlatforms();
+        process.exit(1);
+    }
+    if (!platform.detectFunc()) {
+        console.log(`Error: ${platform.displayName} is not installed`);
+        process.exit(1);
+    }
+    console.log(`🦞 Installing CommanderClaw plugin to ${platform.displayName}`);
+    console.log();
+    // Collect configuration
+    const config = await collectInstallConfig(platform);
+    // Get token from server
+    try {
+        console.log('Fetching token from server...');
+        const token = await getTokenFromServer(config.serverUrl);
+        config.token = token;
+        console.log(`✓ Token obtained: ${maskToken(token)}`);
+        console.log();
+    }
+    catch (e) {
+        console.log(`Error: Could not get token from server: ${e.message}`);
+        console.log('Make sure the CommanderClaw server is running:');
+        console.log('  commanderclaw gateway start');
+        process.exit(1);
+    }
+    // Backup config
+    const backupPath = platform.configPath + '.backup';
+    backupFile(platform.configPath, backupPath);
+    // Install
+    console.log(`Installing commanderclaw-openclaw-plugin@${config.version}...`);
+    const targetPath = path.join(platform.extDir, 'commanderclaw');
+    try {
+        installFromNpm(config.version, targetPath, platform);
+        console.log('✓ Plugin files installed');
+        updatePlatformConfig(platform, config);
+        console.log('✓ Configuration updated');
+        addToPath(platform);
+        // Remove backup on success
+        if (fs.existsSync(backupPath)) {
+            fs.unlinkSync(backupPath);
+        }
+        console.log();
+        console.log('✅ Installation complete!');
+        console.log();
+        console.log('Configuration:');
+        console.log(`  Server URL:  ${config.serverUrl}`);
+        console.log(`  Device Name: ${config.deviceName}`);
+        console.log(`  Version:     ${config.version}`);
+        console.log();
+        console.log('Next steps:');
+        console.log(`  Restart ${platform.displayName} to activate the plugin`);
+    }
+    catch (e) {
+        console.log(`❌ Installation failed: ${e.message}`);
+        restoreBackup(backupPath, platform.configPath);
+        process.exit(1);
+    }
+}
+async function handlePluginUpdate(platformName) {
+    const platform = findPlatform(platformName);
+    if (!platform) {
+        console.log(`Error: Unknown platform: ${platformName}`);
+        process.exit(1);
+    }
+    const targetPath = path.join(platform.extDir, 'commanderclaw');
+    if (!fs.existsSync(targetPath)) {
+        console.log(`Error: Plugin not installed in ${platform.displayName}`);
+        console.log('Run: commanderclaw plugin install <platform>');
+        process.exit(1);
+    }
+    console.log(`🦞 Updating CommanderClaw plugin in ${platform.displayName}`);
+    console.log();
+    const version = await rlWithDefault('Version to update to', 'latest');
+    console.log(`Updating to version ${version}...`);
+    try {
+        installFromNpm(version, targetPath, platform);
+        console.log('✅ Plugin updated successfully!');
+    }
+    catch (e) {
+        console.log(`❌ Update failed: ${e.message}`);
+        process.exit(1);
+    }
+}
+function handlePluginUninstall(platformName) {
+    const platform = findPlatform(platformName);
+    if (!platform) {
+        console.log(`Error: Unknown platform: ${platformName}`);
+        process.exit(1);
+    }
+    const targetPath = path.join(platform.extDir, 'commanderclaw');
+    console.log(`🦞 Uninstalling CommanderClaw plugin from ${platform.displayName}`);
+    console.log();
+    try {
+        if (platform.requiresSudo) {
+            execSync(`sudo rm -rf ${targetPath}`, { stdio: 'inherit' });
+        }
+        else {
+            if (fs.existsSync(targetPath)) {
+                fs.rmSync(targetPath, { recursive: true });
+            }
+        }
+        console.log('✅ Plugin uninstalled successfully!');
+        console.log();
+        console.log(`Note: Configuration in ${platform.configPath} was not modified`);
+    }
+    catch (e) {
+        console.log(`❌ Uninstall failed: ${e.message}`);
+        process.exit(1);
+    }
+}
+async function collectInstallConfig(platform) {
+    const version = await rlWithDefault('Plugin version', 'latest');
+    const serverUrl = await rlWithDefault('Server URL', DEFAULT_SERVER_URL);
+    const deviceName = await rlWithDefault('Device name', DEFAULT_DEVICE_NAME);
+    return {
+        version,
+        serverUrl,
+        token: '',
+        deviceName,
+        autoConnect: true,
+        reconnect: {
+            enabled: true,
+            maxAttempts: 10,
+            delayMs: 5000,
+        },
+    };
+}
+function installFromNpm(version, targetPath, platform) {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'commanderclaw-plugin-'));
+    try {
+        const spec = version === 'latest'
+            ? 'commanderclaw'
+            : `commanderclaw@${version}`;
+        // Download from npm
+        execSync(`npm pack ${spec}`, { cwd: tmpDir, stdio: 'pipe' });
+        // Find tarball
+        const files = fs.readdirSync(tmpDir).filter(f => f.endsWith('.tgz'));
+        if (files.length === 0) {
+            throw new Error('Could not find downloaded tarball');
+        }
+        const tarball = path.join(tmpDir, files[0]);
+        // Extract
+        const extractDir = path.join(tmpDir, 'extracted');
+        fs.mkdirSync(extractDir);
+        execSync(`tar -xzf ${tarball} -C ${extractDir}`, { stdio: 'pipe' });
+        const packageDir = path.join(extractDir, 'package');
+        // Remove existing
+        if (platform.requiresSudo) {
+            execSync(`sudo rm -rf ${targetPath}`, { stdio: 'pipe' });
+            execSync(`sudo mkdir -p ${path.dirname(targetPath)}`, { stdio: 'pipe' });
+            execSync(`sudo cp -r ${packageDir} ${targetPath}`, { stdio: 'pipe' });
+        }
+        else {
+            if (fs.existsSync(targetPath)) {
+                fs.rmSync(targetPath, { recursive: true });
+            }
+            fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+            copyDir(packageDir, targetPath);
+        }
+    }
+    finally {
+        // Cleanup
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
+function copyDir(src, dst) {
+    fs.mkdirSync(dst, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const dstPath = path.join(dst, entry.name);
+        if (entry.isDirectory()) {
+            copyDir(srcPath, dstPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, dstPath);
+        }
+    }
+}
+function updatePlatformConfig(platform, config) {
+    let cfg = {};
+    if (fs.existsSync(platform.configPath)) {
+        try {
+            cfg = JSON.parse(fs.readFileSync(platform.configPath, 'utf-8'));
+        }
+        catch { }
+    }
+    // Update channels
+    if (!cfg.channels)
+        cfg.channels = {};
+    cfg.channels.commanderclaw = {
+        enabled: true,
+        serverUrl: config.serverUrl,
+        token: config.token,
+        deviceName: config.deviceName,
+        autoConnect: config.autoConnect,
+    };
+    // Update plugins
+    if (!cfg.plugins)
+        cfg.plugins = {};
+    if (!cfg.plugins.allow)
+        cfg.plugins.allow = [];
+    if (!cfg.plugins.allow.includes('commanderclaw')) {
+        cfg.plugins.allow.push('commanderclaw');
+    }
+    if (!cfg.plugins.entries)
+        cfg.plugins.entries = {};
+    cfg.plugins.entries.commanderclaw = {
+        enabled: true,
+        config: {
+            serverUrl: config.serverUrl,
+            token: config.token,
+            deviceName: config.deviceName,
+            autoConnect: config.autoConnect,
+            reconnect: config.reconnect,
+        },
+    };
+    if (!cfg.plugins.installs)
+        cfg.plugins.installs = {};
+    cfg.plugins.installs.commanderclaw = {
+        source: 'npm',
+        spec: `commanderclaw@${config.version}`,
+        version: config.version,
+        installedAt: new Date().toISOString(),
+    };
+    // Write config
+    const output = JSON.stringify(cfg, null, 2);
+    if (platform.requiresSudo) {
+        const tmpFile = path.join(os.tmpdir(), 'openclaw.json');
+        fs.writeFileSync(tmpFile, output);
+        execSync(`sudo cp ${tmpFile} ${platform.configPath}`, { stdio: 'pipe' });
+        fs.unlinkSync(tmpFile);
+    }
+    else {
+        fs.mkdirSync(path.dirname(platform.configPath), { recursive: true });
+        fs.writeFileSync(platform.configPath, output);
+    }
+}
+function addToPath(platform) {
+    // Check if commanderclaw is already in PATH
+    try {
+        execSync('which commanderclaw', { stdio: 'pipe' });
+        return; // Already in PATH
+    }
+    catch { }
+    const homeDir = os.homedir();
+    const shellConfig = detectShellConfig(homeDir);
+    if (!shellConfig)
+        return;
+    // Get bin directory
+    const packageDir = path.dirname(path.dirname(__dirname));
+    const binDir = path.join(packageDir, 'bin');
+    // Check if already added
+    if (fs.existsSync(shellConfig)) {
+        const content = fs.readFileSync(shellConfig, 'utf-8');
+        if (content.includes('commanderclaw')) {
+            return;
+        }
+    }
+    // Add to shell config
+    const line = `\n# Added by CommanderClaw\nexport PATH="$PATH:${binDir}"\n`;
+    try {
+        fs.appendFileSync(shellConfig, line);
+        console.log(`✓ Added commanderclaw to PATH in ${path.basename(shellConfig)}`);
+        console.log("  Run 'source ~/.zshrc' or restart your terminal to apply");
+    }
+    catch { }
+}
+function detectShellConfig(homeDir) {
+    const shell = process.env.SHELL || '';
+    // Check for zsh
+    if (shell.includes('zsh')) {
+        const zshrc = path.join(homeDir, '.zshrc');
+        if (fs.existsSync(zshrc))
+            return zshrc;
+    }
+    // Check for bash
+    const bashrc = path.join(homeDir, '.bashrc');
+    if (fs.existsSync(bashrc))
+        return bashrc;
+    const bashProfile = path.join(homeDir, '.bash_profile');
+    if (fs.existsSync(bashProfile))
+        return bashProfile;
+    // Default to .zshrc
+    return path.join(homeDir, '.zshrc');
+}

package/dist/cli/utils.js

@@ -0,0 +1,121 @@
+import * as readline from 'readline';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+export const DEFAULT_SERVER_URL = 'ws://127.0.0.1:19739/ws';
+export const DEFAULT_DEVICE_NAME = 'OpenClaw Agent';
+export function getPlatforms() {
+    const homeDir = os.homedir();
+    return [
+        {
+            name: 'qclaw',
+            displayName: 'QClaw',
+            configPath: '/Applications/QClaw.app/Contents/Resources/openclaw/config/openclaw.json',
+            extDir: '/Applications/QClaw.app/Contents/Resources/openclaw/config/extensions',
+            detectFunc: () => fs.existsSync('/Applications/QClaw.app'),
+            requiresSudo: true,
+        },
+        {
+            name: 'openclaw',
+            displayName: 'OpenClaw',
+            configPath: path.join(homeDir, '.openclaw', 'openclaw.json'),
+            extDir: path.join(homeDir, '.openclaw', 'extensions'),
+            detectFunc: () => {
+                try {
+                    require('child_process').execSync('which openclaw', { stdio: 'ignore' });
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            },
+            requiresSudo: false,
+        },
+    ];
+}
+export function findPlatform(name) {
+    return getPlatforms().find(p => p.name === name);
+}
+export function maskToken(token) {
+    if (token.length <= 8) {
+        return '****';
+    }
+    return token.substring(0, 4) + '****' + token.substring(token.length - 4);
+}
+export function rl(question) {
+    const readlineInterface = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        readlineInterface.question(question, (answer) => {
+            readlineInterface.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export function rlWithDefault(question, defaultValue) {
+    return rl(`${question} [${defaultValue}]: `).then(answer => answer || defaultValue);
+}
+export function getProjectRoot() {
+    // Check environment variable
+    const envRoot = process.env.COMMANDERCLAW_ROOT;
+    if (envRoot && fs.existsSync(path.join(envRoot, 'package.json'))) {
+        return envRoot;
+    }
+    // Check current directory
+    let dir = process.cwd();
+    while (dir !== path.dirname(dir)) {
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
+            const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
+            if (pkg.name === 'commanderclaw') {
+                return dir;
+            }
+        }
+        dir = path.dirname(dir);
+    }
+    return process.cwd();
+}
+export async function getTokenFromServer(serverUrl) {
+    const http = require('http');
+    // Convert ws:// to http://
+    let apiUrl = serverUrl
+        .replace('ws://', 'http://')
+        .replace('wss://', 'https://')
+        .replace(/\/ws$/, '');
+    apiUrl += '/api/auth/token';
+    return new Promise((resolve, reject) => {
+        const req = http.get(apiUrl, { timeout: 5000 }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+                if (res.statusCode !== 200) {
+                    reject(new Error(`Server returned ${res.statusCode}`));
+                    return;
+                }
+                try {
+                    const json = JSON.parse(data);
+                    resolve(json.token);
+                }
+                catch (e) {
+                    reject(new Error('Invalid response'));
+                }
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('Timeout'));
+        });
+    });
+}
+export function backupFile(src, dst) {
+    if (fs.existsSync(src)) {
+        fs.copyFileSync(src, dst);
+    }
+}
+export function restoreBackup(backup, target) {
+    if (fs.existsSync(backup)) {
+        fs.copyFileSync(backup, target);
+    }
+}

package/dist/plugin/client.d.ts

@@ -0,0 +1,76 @@
+/**
+ * WebSocket client for CommanderClaw server
+ * Cross-platform: works in both Node.js and browser/Electron environments
+ */
+import type { Message, PeerInfo, CreateTaskInput, Task, TaskUpdatePayload, ClientEventType, ClientEvent } from "./types";
+export interface ClientOptions {
+    url: string;
+    token?: string;
+    name: string;
+    capabilities: string[];
+    reconnect?: {
+        enabled: boolean;
+        maxAttempts: number;
+        delayMs: number;
+    };
+}
+export declare class CommanderClawClient {
+    private ws;
+    private options;
+    private nodeId;
+    private peers;
+    private commanderId;
+    private connected;
+    private reconnectAttempts;
+    private messageHandlers;
+    private eventHandlers;
+    private heartbeatInterval;
+    private connectionPromise;
+    constructor(options: ClientOptions);
+    connect(): Promise<void>;
+    private handleMessage;
+    private updatePeers;
+    private handleDisconnect;
+    private startHeartbeat;
+    private attemptReconnect;
+    disconnect(): Promise<void>;
+    send(type: string, payload?: unknown): void;
+    on(event: ClientEventType, handler: (event: ClientEvent) => void): void;
+    off(event: ClientEventType, handler: (event: ClientEvent) => void): void;
+    private emit;
+    onMessage(type: string, handler: (msg: Message) => void): void;
+    isConnected(): boolean;
+    getNodeId(): string | null;
+    getPeers(): PeerInfo[];
+    getCommanderId(): string | null;
+    private getHttpUrl;
+    private fetchApi;
+    listNodes(): Promise<PeerInfo[]>;
+    getStatus(): Promise<{
+        status: string;
+        nodes: number;
+    }>;
+    createTask(input: CreateTaskInput): Promise<Task>;
+    listTasks(): Promise<Task[]>;
+    getTask(taskId: string): Promise<Task>;
+    abortTask(taskId: string, reason?: string): Promise<{
+        status: string;
+    }>;
+    pauseTask(taskId: string): Promise<{
+        status: string;
+    }>;
+    resumeTask(taskId: string): Promise<{
+        status: string;
+    }>;
+    appointCommander(nodeId: string): Promise<{
+        status: string;
+        commanderId: string;
+    }>;
+    sendTaskUpdate(payload: TaskUpdatePayload): void;
+    sendTaskResult(payload: TaskUpdatePayload & {
+        output?: unknown;
+        error?: string;
+        duration: number;
+    }): void;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/plugin/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/plugin/client.ts"],"names":[],"mappings":"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"}

package/dist/plugin/config.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Configuration management for CommanderClaw plugin
+ *
+ * Config file location: ~/.openclaw/.commanderclaw.json
+ */
+export interface CommanderClawConfigFile {
+    nodeId?: string;
+    nodeName: string;
+    serverUrl: string;
+    token?: string;
+    autoConnect: boolean;
+    reconnect: {
+        enabled: boolean;
+        maxAttempts: number;
+        delayMs: number;
+    };
+    lastConnected?: string;
+}
+export declare function loadConfig(): CommanderClawConfigFile | null;
+export declare function saveConfig(config: CommanderClawConfigFile): void;
+export declare function updateConfig(updates: Partial<CommanderClawConfigFile>): CommanderClawConfigFile | null;
+export declare function createDefaultConfig(serverUrl: string, nodeName: string, token?: string): CommanderClawConfigFile;
+export declare function getNodeId(): string | undefined;
+export declare function saveNodeId(nodeId: string): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/plugin/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/plugin/config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,MAAM,WAAW,uBAAuB;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAiBD,wBAAgB,UAAU,IAAI,uBAAuB,GAAG,IAAI,CAc3D;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,uBAAuB,GAAG,IAAI,CAWhE;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,uBAAuB,CAAC,GAAG,uBAAuB,GAAG,IAAI,CAUtG;AAED,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,CAAC,EAAE,MAAM,GACb,uBAAuB,CAYzB;AAED,wBAAgB,SAAS,IAAI,MAAM,GAAG,SAAS,CAG9C;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAM/C"}