commanderclaw 1.1.3

package/README.md

@@ -0,0 +1,57 @@
+# CommanderClaw
+
+Multi-device Agent Coordination Framework - CLI and OpenClaw/QClaw Plugin.
+
+## Installation
+
+```bash
+npm install -g commanderclaw
+```
+
+## Usage
+
+### CLI Commands
+
+```bash
+# Start gateway (server + web console)
+commanderclaw gateway start
+
+# Check gateway status
+commanderclaw gateway status
+
+# Stop gateway
+commanderclaw gateway stop
+
+# Install plugin to QClaw
+commanderclaw plugin install qclaw
+
+# Install plugin to OpenClaw
+commanderclaw plugin install openclaw
+
+# Check plugin status
+commanderclaw plugin status
+
+# Configure server URL and token
+commanderclaw config
+```
+
+### Gateway Ports
+
+| Service | Port |
+|---------|------|
+| Server | 19739 |
+| WebSocket | ws://127.0.0.1:19739/ws |
+| Web Console | 19730 |
+
+## Supported Platforms
+
+| Platform | Architecture |
+|----------|--------------|
+| macOS | x64 (Intel) |
+| macOS | arm64 (Apple Silicon) |
+| Linux | x64 |
+| Windows | x64 |
+
+## License
+
+MIT

package/bin/commanderclaw.cjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const { spawn } = require('child_process');
+const os = require('os');
+const fs = require('fs');
+
+const command = process.argv[2];
+
+// Helper to get platform identifier
+function getPlatformId() {
+  const platform = os.platform();
+  const arch = os.arch();
+  
+  // Normalize architecture
+  let normalizedArch = arch;
+  if (arch === 'x64' || arch === 'amd64') {
+    normalizedArch = 'x64';
+  } else if (arch === 'arm64' || arch === 'aarch64') {
+    normalizedArch = 'arm64';
+  }
+  
+  return `${platform}-${normalizedArch}`;
+}
+
+// Gateway start uses pre-compiled binary
+// Other gateway commands use TypeScript implementation
+if (command === 'gateway' && process.argv[3] === 'start') {
+  const platformId = getPlatformId();
+  const ext = os.platform() === 'win32' ? '.exe' : '';
+  const binaryPath = path.join(
+    __dirname,
+    '..',
+    'binaries',
+    platformId,
+    `coordination-server${ext}`
+  );
+  
+  if (!fs.existsSync(binaryPath)) {
+    console.error(`Error: Unsupported platform: ${platformId}`);
+    console.error('');
+    console.error('Supported platforms:');
+    console.error('  - darwin-x64 (macOS Intel)');
+    console.error('  - darwin-arm64 (macOS Apple Silicon)');
+    console.error('  - linux-x64 (Linux)');
+    console.error('  - win32-x64 (Windows)');
+    process.exit(1);
+  }
+  
+  const args = process.argv.slice(4);
+  const child = spawn(binaryPath, args, {
+    stdio: 'inherit',
+    env: { ...process.env },
+    shell: os.platform() === 'win32'
+  });
+  
+  child.on('error', (err) => {
+    console.error('Failed to start server:', err.message);
+    process.exit(1);
+  });
+  
+  child.on('exit', (code) => {
+    process.exit(code || 0);
+  });
+}
+
+// Other commands use TypeScript implementation
+else {
+  const cliPath = path.join(__dirname, '..', 'dist', 'cli', 'index.js');
+  
+  if (!fs.existsSync(cliPath)) {
+    console.error('Error: CLI not built. Run: npm run build');
+    process.exit(1);
+  }
+  
+  require(cliPath);
+}

package/dist/cli/config.js

@@ -0,0 +1,116 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { rl, rlWithDefault, maskToken, DEFAULT_SERVER_URL, DEFAULT_DEVICE_NAME } from './utils.js';
+export function handleConfig() {
+    console.log('🦞 CommanderClaw Configuration');
+    console.log();
+    const homeDir = os.homedir();
+    let configPath;
+    if (fs.existsSync('/Applications/QClaw.app')) {
+        configPath = path.join(homeDir, '.qclaw', 'openclaw.json');
+        console.log('Detected QClaw installation.');
+    }
+    else {
+        configPath = path.join(homeDir, '.openclaw', 'openclaw.json');
+    }
+    const existingConfig = loadExistingConfig(configPath);
+    console.log('Current configuration:');
+    console.log(`  Server URL:  ${existingConfig.serverUrl}`);
+    if (existingConfig.token) {
+        console.log(`  Token:       ${maskToken(existingConfig.token)}`);
+    }
+    else {
+        console.log('  Token:       (not set)');
+    }
+    console.log(`  Device Name: ${existingConfig.deviceName}`);
+    console.log();
+    // Collect new config
+    collectConfigWithDefaults(existingConfig).then(config => {
+        updateConfigFile(configPath, config);
+        console.log();
+        console.log('✅ Configuration updated!');
+        console.log();
+        console.log('New configuration:');
+        console.log(`  Server URL:  ${config.serverUrl}`);
+        console.log(`  Device Name: ${config.deviceName}`);
+        if (config.token) {
+            console.log(`  Token:       ${maskToken(config.token)}`);
+        }
+        console.log();
+        console.log('Restart your OpenClaw/QClaw to apply changes.');
+    });
+}
+function loadExistingConfig(configPath) {
+    const config = {
+        serverUrl: DEFAULT_SERVER_URL,
+        token: '',
+        deviceName: DEFAULT_DEVICE_NAME,
+    };
+    if (!fs.existsSync(configPath)) {
+        return config;
+    }
+    try {
+        const data = fs.readFileSync(configPath, 'utf-8');
+        const cfg = JSON.parse(data);
+        const cc = cfg.channels?.commanderclaw || cfg.plugins?.entries?.commanderclaw?.config || {};
+        return {
+            serverUrl: cc.serverUrl || config.serverUrl,
+            token: cc.token || config.token,
+            deviceName: cc.deviceName || config.deviceName,
+        };
+    }
+    catch {
+        return config;
+    }
+}
+async function collectConfigWithDefaults(defaults) {
+    const serverUrl = await rlWithDefault('CommanderClaw server URL', defaults.serverUrl);
+    const token = await rl('Authentication token (press Enter to skip): ');
+    const deviceName = await rlWithDefault('Device name', defaults.deviceName);
+    return {
+        serverUrl,
+        token: token || defaults.token,
+        deviceName,
+    };
+}
+function updateConfigFile(configPath, config) {
+    let cfg = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            cfg = JSON.parse(fs.readFileSync(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: true,
+    };
+    // Update plugins
+    if (!cfg.plugins)
+        cfg.plugins = {};
+    if (!cfg.plugins.entries)
+        cfg.plugins.entries = {};
+    cfg.plugins.entries.commanderclaw = {
+        enabled: true,
+        config: {
+            serverUrl: config.serverUrl,
+            token: config.token,
+            deviceName: config.deviceName,
+            autoConnect: true,
+            reconnect: {
+                enabled: true,
+                maxAttempts: 10,
+                delayMs: 5000,
+            },
+        },
+    };
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2));
+}

package/dist/cli/gateway.js

@@ -0,0 +1,250 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import { spawn, execSync } from 'child_process';
+import { getProjectRoot } from './utils.js';
+const SERVER_PORT = 19739;
+const WEB_PORT = 19730;
+const SERVER_PID_FILE = '/tmp/commanderclaw-server.pid';
+const WEB_PID_FILE = '/tmp/commanderclaw-web.pid';
+const SERVER_LOG_FILE = '/tmp/commanderclaw-server.log';
+const WEB_LOG_FILE = '/tmp/commanderclaw-web.log';
+export function handleGateway(args) {
+    if (args.length === 0) {
+        printGatewayUsage();
+        process.exit(1);
+    }
+    const action = args[0];
+    switch (action) {
+        case 'start':
+            gatewayStart();
+            break;
+        case 'stop':
+            gatewayStop();
+            break;
+        case 'restart':
+            gatewayRestart();
+            break;
+        case 'status':
+            gatewayStatus();
+            break;
+        default:
+            console.log(`Unknown gateway action: ${action}`);
+            printGatewayUsage();
+            process.exit(1);
+    }
+}
+function printGatewayUsage() {
+    console.log('Gateway management commands:');
+    console.log();
+    console.log('Usage:');
+    console.log('  commanderclaw gateway <action>');
+    console.log();
+    console.log('Actions:');
+    console.log('  start     Start server (port 19739) and web console (port 19730)');
+    console.log('  stop      Stop server and web console');
+    console.log('  restart   Restart server and web console');
+    console.log('  status    Show status of server and web console');
+}
+function getBinaryPath() {
+    const platform = os.platform();
+    const arch = os.arch();
+    let platformId = `${platform}-${arch === 'x64' ? 'x64' : arch}`;
+    // Find binary in package binaries directory
+    const packageDir = path.dirname(path.dirname(__dirname));
+    const binaryDir = path.join(packageDir, 'binaries', platformId);
+    const ext = platform === 'win32' ? '.exe' : '';
+    const binaryPath = path.join(binaryDir, `coordination-server${ext}`);
+    if (fs.existsSync(binaryPath)) {
+        return binaryPath;
+    }
+    // Fallback to project root bin directory (development mode)
+    const projectRoot = getProjectRoot();
+    const devBinaryPath = path.join(projectRoot, 'bin', 'coordination-server');
+    if (fs.existsSync(devBinaryPath)) {
+        return devBinaryPath;
+    }
+    // Need to build
+    console.log('(building server first)...');
+    execSync('go build -o bin/coordination-server ./cmd/coordination-server', {
+        cwd: projectRoot,
+        stdio: 'inherit',
+    });
+    return devBinaryPath;
+}
+function isProcessRunning(pidFile) {
+    if (!fs.existsSync(pidFile)) {
+        return false;
+    }
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+    if (isNaN(pid)) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function stopProcess(pidFile) {
+    if (!fs.existsSync(pidFile)) {
+        return;
+    }
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+    if (isNaN(pid)) {
+        return;
+    }
+    try {
+        process.kill(pid, 'SIGTERM');
+        setTimeout(() => {
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch { }
+        }, 500);
+    }
+    catch { }
+    fs.unlinkSync(pidFile);
+}
+function gatewayStart() {
+    const serverRunning = isProcessRunning(SERVER_PID_FILE);
+    const webRunning = isProcessRunning(WEB_PID_FILE);
+    if (serverRunning && webRunning) {
+        console.log('Gateway is already running');
+        console.log(`  Server:     http://127.0.0.1:${SERVER_PORT}`);
+        console.log(`  Web Console: http://127.0.0.1:${WEB_PORT}`);
+        return;
+    }
+    if (!serverRunning) {
+        process.stdout.write(`Starting server on port ${SERVER_PORT}... `);
+        if (startServer()) {
+            console.log('OK');
+        }
+        else {
+            console.log('Failed');
+            process.exit(1);
+        }
+    }
+    if (!webRunning) {
+        process.stdout.write(`Starting web console on port ${WEB_PORT}... `);
+        if (startWeb()) {
+            console.log('OK');
+        }
+        else {
+            console.log('Failed');
+            process.exit(1);
+        }
+    }
+    console.log();
+    console.log('Gateway started successfully!');
+    console.log(`  Server:     http://127.0.0.1:${SERVER_PORT}`);
+    console.log(`  WebSocket:  ws://127.0.0.1:${SERVER_PORT}/ws`);
+    console.log(`  Web Console: http://127.0.0.1:${WEB_PORT}`);
+    console.log();
+    console.log('Logs:');
+    console.log(`  Server: ${SERVER_LOG_FILE}`);
+    console.log(`  Web:    ${WEB_LOG_FILE}`);
+}
+function startServer() {
+    try {
+        const binaryPath = getBinaryPath();
+        const logFile = fs.openSync(SERVER_LOG_FILE, 'a');
+        const child = spawn(binaryPath, ['-port', String(SERVER_PORT)], {
+            detached: true,
+            stdio: ['ignore', logFile, logFile],
+        });
+        child.unref();
+        fs.writeFileSync(SERVER_PID_FILE, String(child.pid));
+        // Wait a bit to verify it started
+        setTimeout(() => {
+            if (!isProcessRunning(SERVER_PID_FILE)) {
+                console.log('\nServer process exited immediately. Check logs at ' + SERVER_LOG_FILE);
+                process.exit(1);
+            }
+        }, 500);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+function startWeb() {
+    try {
+        const projectRoot = getProjectRoot();
+        const webDir = path.join(projectRoot, 'web');
+        if (!fs.existsSync(webDir)) {
+            console.log('(web directory not found, skipping)');
+            return true;
+        }
+        const logFile = fs.openSync(WEB_LOG_FILE, 'a');
+        const child = spawn('npm', ['run', 'dev', '--', '--port', String(WEB_PORT)], {
+            cwd: webDir,
+            detached: true,
+            stdio: ['ignore', logFile, logFile],
+            env: { ...process.env, PORT: String(WEB_PORT) },
+        });
+        child.unref();
+        fs.writeFileSync(WEB_PID_FILE, String(child.pid));
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+function gatewayStop() {
+    process.stdout.write('Stopping web console... ');
+    if (isProcessRunning(WEB_PID_FILE)) {
+        stopProcess(WEB_PID_FILE);
+        console.log('OK');
+    }
+    else {
+        console.log('(not running)');
+    }
+    process.stdout.write('Stopping server... ');
+    if (isProcessRunning(SERVER_PID_FILE)) {
+        stopProcess(SERVER_PID_FILE);
+        console.log('OK');
+    }
+    else {
+        console.log('(not running)');
+    }
+    console.log('Gateway stopped');
+}
+function gatewayRestart() {
+    console.log('Restarting gateway...');
+    gatewayStop();
+    setTimeout(() => {
+        console.log();
+        gatewayStart();
+    }, 500);
+}
+function gatewayStatus() {
+    console.log('CommanderClaw Gateway Status');
+    console.log('-'.repeat(40));
+    const serverRunning = isProcessRunning(SERVER_PID_FILE);
+    const webRunning = isProcessRunning(WEB_PID_FILE);
+    let serverStatus = 'stopped';
+    let serverPid = '';
+    if (serverRunning) {
+        serverStatus = 'running';
+        serverPid = fs.readFileSync(SERVER_PID_FILE, 'utf-8').trim();
+    }
+    let webStatus = 'stopped';
+    let webPid = '';
+    if (webRunning) {
+        webStatus = 'running';
+        webPid = fs.readFileSync(WEB_PID_FILE, 'utf-8').trim();
+    }
+    console.log(`Server (port ${SERVER_PORT}):  ${serverStatus}${serverPid ? ` (PID: ${serverPid})` : ''}`);
+    console.log(`Web (port ${WEB_PORT}):    ${webStatus}${webPid ? ` (PID: ${webPid})` : ''}`);
+    if (serverRunning) {
+        console.log();
+        console.log(`Server URL:   http://127.0.0.1:${SERVER_PORT}`);
+        console.log(`WebSocket:    ws://127.0.0.1:${SERVER_PORT}/ws`);
+    }
+    if (webRunning) {
+        console.log(`Web Console:  http://127.0.0.1:${WEB_PORT}`);
+    }
+}

package/dist/cli/index.js

@@ -0,0 +1,53 @@
+import { handleGateway } from './gateway.js';
+import { handlePlugin } from './plugin.js';
+import { handleConfig } from './config.js';
+const VERSION = '1.1.3';
+function printUsage() {
+    console.log('CommanderClaw - Multi-device Agent Coordination Framework');
+    console.log();
+    console.log('Usage:');
+    console.log('  commanderclaw <command> [arguments]');
+    console.log();
+    console.log('Commands:');
+    console.log('  gateway    Manage gateway services (server + web)');
+    console.log('  plugin     Install/update plugin to OpenClaw/QClaw');
+    console.log('  config     Configure server URL and token');
+    console.log('  help       Show this help message');
+    console.log();
+    console.log('Run \'commanderclaw gateway\' for gateway commands.');
+    console.log('Run \'commanderclaw plugin\' for plugin commands.');
+}
+function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        printUsage();
+        process.exit(1);
+    }
+    const command = args[0];
+    const subArgs = args.slice(1);
+    switch (command) {
+        case 'gateway':
+            handleGateway(subArgs);
+            break;
+        case 'plugin':
+            handlePlugin(subArgs);
+            break;
+        case 'config':
+            handleConfig();
+            break;
+        case 'help':
+        case '-h':
+        case '--help':
+            printUsage();
+            break;
+        case '-v':
+        case '--version':
+            console.log(`commanderclaw v${VERSION}`);
+            break;
+        default:
+            console.log(`Unknown command: ${command}`);
+            printUsage();
+            process.exit(1);
+    }
+}
+main();