openclaw-spawn 1.0.0

package/src/docker.js

@@ -0,0 +1,272 @@
+import { execSync, spawn, spawnSync } from 'child_process';
+import { getInstanceDir } from './metadata.js';
+
+// Check if Docker is running
+export function isDockerRunning() {
+  try {
+    execSync('docker ps', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Check if the docker binary is installed (not necessarily running)
+export function isDockerInstalled() {
+  try {
+    const cmd = process.platform === 'win32' ? 'where docker' : 'which docker';
+    execSync(cmd, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Check if our base image already exists (skip rebuild if so)
+export function imageExists() {
+  try {
+    const out = execSync('docker images -q openclaw-spawn-base:latest', { encoding: 'utf8' }).trim();
+    return out.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+// Check if container exists
+export function containerExists(containerName) {
+  try {
+    execSync(`docker ps -a --filter name=${containerName} --format '{{.Names}}'`, { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Get container status
+export function getContainerStatus(containerName) {
+  try {
+    const output = execSync(
+      `docker ps -a --filter name=${containerName} --format '{{.Status}}'`,
+      { encoding: 'utf8' }
+    );
+    if (output.includes('Up')) return 'running';
+    if (output.includes('Exited')) return 'stopped';
+    return 'unknown';
+  } catch {
+    return 'not-found';
+  }
+}
+
+// Create and start container
+export function createContainer(name, port) {
+  const instanceDir = getInstanceDir(name);
+  const containerName = `openclaw-${name}`;
+  
+  const cmd = [
+    'docker', 'run',
+    '-d',
+    '--name', containerName,
+    '-e', 'HOME=/home/node',
+    '-e', 'PLAYWRIGHT_BROWSERS_PATH=/home/node/.cache/ms-playwright',
+    '-p', `${port}:${port}`,                    // Gateway port
+    '-p', `${port + 2}:${port + 2}`,              // Browser control service (gateway.port + 2)
+    '-p', `${port + 11}:18800`,                 // Chrome CDP port
+    '-p', `${port + 20}:6080`,                  // noVNC browser view
+    '-v', `${instanceDir}/.openclaw:/home/node/.openclaw`,
+    '-v', `${instanceDir}/workspace:/workspace`,
+    '-v', `/var/run/docker.sock:/var/run/docker.sock`,
+    '--network', 'openclaw-network',
+    '--shm-size', '1g',              // Chrome needs more than the default 64MB for multiple tabs
+    'openclaw-spawn-base:latest'
+    // No CMD override — Dockerfile CMD runs: Xvfb :99 ... & tail -f /dev/null
+  ];
+  
+  try {
+    execSync(cmd.join(' '), { stdio: 'inherit' });
+    return true;
+  } catch (error) {
+    console.error('Failed to create container:', error.message);
+    return false;
+  }
+}
+
+// Execute command in container (interactive)
+export function execInContainer(containerName, command, detached = false) {
+  if (detached) {
+    // Run in background
+    const process = spawn('docker', ['exec', '-d', containerName, 'sh', '-c', command], {
+      stdio: 'inherit',
+      shell: false
+    });
+    
+    return new Promise((resolve, reject) => {
+      process.on('close', (code) => {
+        if (code === 0) {
+          resolve(true);
+        } else {
+          reject(new Error(`Command exited with code ${code}`));
+        }
+      });
+      
+      process.on('error', (error) => {
+        reject(error);
+      });
+    });
+  } else {
+    // Run interactively
+    const process = spawn('docker', ['exec', '-it', containerName, 'sh', '-c', command], {
+      stdio: 'inherit',
+      shell: false
+    });
+    
+    return new Promise((resolve, reject) => {
+      process.on('close', (code) => {
+        if (code === 0) {
+          resolve(true);
+        } else {
+          reject(new Error(`Command exited with code ${code}`));
+        }
+      });
+      
+      process.on('error', (error) => {
+        reject(error);
+      });
+    });
+  }
+}
+
+// Stop container
+export function stopContainer(containerName) {
+  try {
+    execSync(`docker stop ${containerName}`, { stdio: 'inherit' });
+    return true;
+  } catch (error) {
+    console.error('Failed to stop container:', error.message);
+    return false;
+  }
+}
+
+// Start container
+export function startContainer(containerName) {
+  try {
+    execSync(`docker start ${containerName}`, { stdio: 'inherit' });
+    return true;
+  } catch (error) {
+    console.error('Failed to start container:', error.message);
+    return false;
+  }
+}
+
+// Remove container
+export function removeContainer(containerName) {
+  try {
+    execSync(`docker rm -f ${containerName}`, { stdio: 'inherit' });
+    return true;
+  } catch (error) {
+    console.error('Failed to remove container:', error.message);
+    return false;
+  }
+}
+
+// Show container logs
+export function showLogs(containerName, follow = false) {
+  const cmd = follow ? 
+    `docker logs -f ${containerName}` : 
+    `docker logs ${containerName}`;
+  
+  try {
+    execSync(cmd, { stdio: 'inherit' });
+    return true;
+  } catch (error) {
+    console.error('Failed to show logs:', error.message);
+    return false;
+  }
+}
+
+// Build base image
+export function buildBaseImage() {
+  try {
+    execSync('docker build -t openclaw-spawn-base:latest .', { 
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+    return true;
+  } catch (error) {
+    console.error('Failed to build image:', error.message);
+    return false;
+  }
+}
+
+// Start VNC services inside container (x11vnc + websockify/noVNC)
+export function startVnc(containerName) {
+  try {
+    // Start x11vnc if not already running (serves Xvfb display :99 as VNC on port 5900)
+    execSync(
+      `docker exec -d ${containerName} sh -c "pgrep -x x11vnc > /dev/null || x11vnc -display :99 -forever -nopw -rfbport 5900 -quiet"`,
+      { stdio: 'ignore' }
+    );
+    execSync('sleep 1', { stdio: 'ignore' });
+    // Kill any existing websockify first so we only ever have one instance on port 6080.
+    // Use spawnSync with explicit argv — avoids shell interpretation and pkill self-kill issues.
+    spawnSync('docker', ['exec', containerName, 'pkill', '-f', 'websockify'], { stdio: 'pipe' });
+    execSync('sleep 0.5', { stdio: 'ignore' });
+    spawnSync('docker', ['exec', '-d', containerName, 'websockify', '--web', '/usr/share/novnc', '6080', 'localhost:5900'], { stdio: 'pipe' });
+    execSync('sleep 1', { stdio: 'ignore' });
+    return true;
+  } catch (error) {
+    console.error('Failed to start VNC:', error.message);
+    return false;
+  }
+}
+
+// Start a visible Chrome on the Xvfb display for browser takeover / VNC interaction.
+// Uses --disable-gpu for Docker compatibility and --remote-debugging-port so the gateway can attach via CDP.
+export function startVisibleChrome(containerName, cdpPort) {
+  try {
+    // Use a dedicated temp profile to avoid restoring old session tabs.
+    // Stale session tabs cause playwright connectOverCDP to hang indefinitely.
+    // Extra flags reduce background workers/network activity that can destabilize
+    // the CDP WebSocket connection when browsing heavy sites like YouTube.
+    execSync(
+      `docker exec -d ${containerName} sh -c "/home/node/openclaw-chromium` +
+      ` --no-sandbox` +
+      ` --disable-gpu` +
+      ` --disable-dev-shm-usage` +
+      ` --remote-debugging-port=${cdpPort}` +
+      ` --user-data-dir=/tmp/openclaw-vnc-profile` +
+      ` --no-first-run` +
+      ` --no-default-browser-check` +
+      ` --disable-background-networking` +
+      ` --disable-extensions` +
+      ` --metrics-recording-only` +
+      ` --safebrowsing-disable-auto-update` +
+      ` 2>/dev/null"`,
+      { stdio: 'ignore' }
+    );
+    // Give Chrome 3 seconds to start and expose its CDP port
+    execSync('sleep 3', { stdio: 'ignore' });
+    return true;
+  } catch (error) {
+    console.error('Failed to start Chrome:', error.message);
+    return false;
+  }
+}
+
+// Stop visible Chrome and any orphaned VNC services
+export function stopVisibleChrome(containerName) {
+  spawnSync('docker', ['exec', containerName, 'pkill', '-f', 'openclaw-chromium'], { stdio: 'pipe' });
+  return true;
+}
+
+// Create Docker network
+export function ensureNetwork() {
+  try {
+    execSync('docker network inspect openclaw-network', { stdio: 'ignore' });
+  } catch {
+    try {
+      execSync('docker network create openclaw-network', { stdio: 'inherit' });
+    } catch (error) {
+      console.error('Failed to create network:', error.message);
+    }
+  }
+}

package/src/metadata.js

@@ -0,0 +1,166 @@
+import os from 'os';
+import path from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+
+const SWARM_DIR = path.join(os.homedir(), '.openclaw-spawn');
+const METADATA_FILE = path.join(SWARM_DIR, 'instances.json');
+const INSTANCES_DIR = path.join(SWARM_DIR, 'instances');
+
+// Ensure directories exist
+export function ensureDirectories() {
+  if (!existsSync(SWARM_DIR)) {
+    mkdirSync(SWARM_DIR, { recursive: true });
+  }
+  if (!existsSync(INSTANCES_DIR)) {
+    mkdirSync(INSTANCES_DIR, { recursive: true });
+  }
+  if (!existsSync(METADATA_FILE)) {
+    writeFileSync(METADATA_FILE, JSON.stringify({ instances: {}, nextPort: 18789 }, null, 2));
+  }
+}
+
+// Read metadata
+export function readMetadata() {
+  ensureDirectories();
+  return JSON.parse(readFileSync(METADATA_FILE, 'utf8'));
+}
+
+// Write metadata
+export function writeMetadata(data) {
+  ensureDirectories();
+  writeFileSync(METADATA_FILE, JSON.stringify(data, null, 2));
+}
+
+// Get all instances
+export function getInstances() {
+  const data = readMetadata();
+  return data.instances;
+}
+
+// Get instance by name
+export function getInstance(name) {
+  const instances = getInstances();
+  return instances[name];
+}
+
+// Add instance
+export function addInstance(name, port) {
+  const data = readMetadata();
+  data.instances[name] = {
+    container: `openclaw-${name}`,
+    port,
+    created: new Date().toISOString(),
+    status: 'created'
+  };
+  data.nextPort = port + 220;
+  writeMetadata(data);
+  
+  // Create instance directories
+  const instanceDir = path.join(INSTANCES_DIR, name);
+  mkdirSync(path.join(instanceDir, '.openclaw'), { recursive: true });
+  mkdirSync(path.join(instanceDir, 'workspace'), { recursive: true });
+  
+  return data.instances[name];
+}
+
+// Remove instance
+export function removeInstance(name) {
+  const data = readMetadata();
+  if (name === '__all__') {
+    // Special case for cleanup: reset everything
+    data.instances = {};
+    data.nextPort = 18789;
+  } else {
+    delete data.instances[name];
+  }
+  writeMetadata(data);
+}
+
+// Get next available port
+export function getNextPort() {
+  const data = readMetadata();
+  return data.nextPort;
+}
+
+// Get instance directory
+export function getInstanceDir(name) {
+  return path.join(INSTANCES_DIR, name);
+}
+
+// Read gateway auth token from instance's openclaw.json (for dashboard URL)
+export function getInstanceGatewayToken(name) {
+  const configPath = path.join(INSTANCES_DIR, name, '.openclaw', 'openclaw.json');
+  if (!existsSync(configPath)) return null;
+  try {
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    return config?.gateway?.auth?.token ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// Set gateway.port in instance's openclaw.json so internal port matches host port
+export function setInstanceGatewayPort(name, port) {
+  const configPath = path.join(INSTANCES_DIR, name, '.openclaw', 'openclaw.json');
+  if (!existsSync(configPath)) return;
+  try {
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    if (!config.gateway) config.gateway = {};
+    config.gateway.port = port;
+    // Don't set bind - let CLI flag --bind lan override for gateway process only
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+  } catch {
+    // ignore
+  }
+}
+
+// Enable browser takeover mode: we launch Chrome ourselves on Xvfb, gateway attaches via CDP.
+// Sets attachOnly:true so the gateway never tries to launch Chrome itself (avoids Playwright launch issues in Docker).
+// headless stays false for bookkeeping but is irrelevant when attachOnly:true.
+export function enableBrowserTakeover(name) {
+  const configPath = path.join(INSTANCES_DIR, name, '.openclaw', 'openclaw.json');
+  if (!existsSync(configPath)) return;
+  try {
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    if (!config.browser) return;
+    config.browser.attachOnly = true;
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+  } catch {
+    // ignore
+  }
+}
+
+// Restore normal headless mode — undo browser takeover
+export function disableBrowserTakeover(name) {
+  const configPath = path.join(INSTANCES_DIR, name, '.openclaw', 'openclaw.json');
+  if (!existsSync(configPath)) return;
+  try {
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    if (!config.browser) return;
+    config.browser.attachOnly = false;
+    config.browser.headless = true;
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+  } catch {
+    // ignore
+  }
+}
+
+// Enable browser tool with managed Chromium (openclaw profile, CDP port 18800)
+export function enableBrowserTool(name) {
+  const configPath = path.join(INSTANCES_DIR, name, '.openclaw', 'openclaw.json');
+  if (!existsSync(configPath)) return;
+  try {
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    if (!config.browser) config.browser = {};
+    config.browser.enabled = true;
+    config.browser.defaultProfile = 'openclaw';
+    config.browser.headless = true;        // Required for Docker/headless environments
+    config.browser.noSandbox = true;       // Required for Docker (Chrome sandbox needs kernel features)
+    config.browser.executablePath = '/home/node/openclaw-chromium';
+    if (!config.browser.profiles) config.browser.profiles = {};
+    config.browser.profiles.openclaw = { cdpPort: 18800, color: '#FF4500' };
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+  } catch {
+    // ignore
+  }
+}

package/src/selector.js

@@ -0,0 +1,72 @@
+import inquirer from 'inquirer';
+import { getInstances } from './metadata.js';
+import { getContainerStatus } from './docker.js';
+
+// Show instance selector
+export async function selectInstance(allowAddNew = true) {
+  const instances = getInstances();
+  const choices = [];
+  
+  // Add existing instances
+  for (const [name, instance] of Object.entries(instances)) {
+    const status = getContainerStatus(instance.container);
+    const statusIcon = status === 'running' ? '🟢' : status === 'stopped' ? '🔴' : '⚪';
+    choices.push({
+      name: `${statusIcon} ${name} (port ${instance.port}, ${status})`,
+      value: name,
+      short: name
+    });
+  }
+  
+  // Add "new instance" option
+  if (allowAddNew) {
+    choices.push({
+      name: '➕ Add new instance',
+      value: '__new__',
+      short: 'New instance'
+    });
+  }
+  
+  if (choices.length === 0) {
+    return '__new__';
+  }
+  
+  const answer = await inquirer.prompt([{
+    type: 'list',
+    name: 'instance',
+    message: 'Select instance:',
+    choices
+  }]);
+  
+  return answer.instance;
+}
+
+// Prompt for new instance name
+export async function promptInstanceName() {
+  const answer = await inquirer.prompt([{
+    type: 'input',
+    name: 'name',
+    message: 'Enter instance name:',
+    validate: (input) => {
+      if (!input) return 'Name cannot be empty';
+      if (!/^[a-z0-9-]+$/.test(input)) return 'Use only lowercase letters, numbers, and hyphens';
+      const instances = getInstances();
+      if (instances[input]) return 'Instance already exists';
+      return true;
+    }
+  }]);
+  
+  return answer.name;
+}
+
+// Confirm action
+export async function confirm(message) {
+  const answer = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'confirmed',
+    message,
+    default: false
+  }]);
+  
+  return answer.confirmed;
+}

package/test/verify.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+// Quick test script to verify the CLI works
+import { execSync } from 'child_process';
+
+console.log('🧪 Testing OpenClaw Swarm CLI\n');
+
+// Test 1: List instances
+console.log('1️⃣  Testing list command...');
+try {
+  execSync('openclaw-spawn list', { stdio: 'inherit' });
+  console.log('✅ List command works\n');
+} catch (error) {
+  console.log('❌ List command failed\n');
+}
+
+// Test 2: Check instance status
+console.log('2️⃣  Testing instance status...');
+try {
+  execSync('docker ps | grep openclaw', { stdio: 'inherit' });
+  console.log('✅ Container is running\n');
+} catch (error) {
+  console.log('❌ No containers running\n');
+}
+
+// Test 3: Execute simple command in container
+console.log('3️⃣  Testing command execution...');
+try {
+  execSync('docker exec openclaw-oc-1 openclaw --version', { stdio: 'inherit' });
+  console.log('✅ Can execute commands in container\n');
+} catch (error) {
+  console.log('❌ Failed to execute command\n');
+}
+
+// Test 4: Check OpenClaw health
+console.log('4️⃣  Testing OpenClaw installation...');
+try {
+  execSync('docker exec openclaw-oc-1 which openclaw', { stdio: 'inherit' });
+  console.log('✅ OpenClaw is installed\n');
+} catch (error) {
+  console.log('❌ OpenClaw not found\n');
+}
+
+// Test 5: Check workspace
+console.log('5️⃣  Testing workspace access...');
+try {
+  execSync('docker exec openclaw-oc-1 ls -la /workspace', { stdio: 'inherit' });
+  console.log('✅ Workspace is accessible\n');
+} catch (error) {
+  console.log('❌ Workspace not accessible\n');
+}
+
+console.log('\n🎉 CLI tests complete!');
+console.log('\nTo test interactive commands manually:');
+console.log('  openclaw-spawn onboard    # Run onboarding wizard');
+console.log('  openclaw-spawn gateway    # Start gateway');
+console.log('  openclaw-spawn tui        # Open TUI');