cli.js

#!/usr/bin/env node
import { execFile } from 'child_process';
import { createRequire } from 'module';
import { fileURLToPath } from 'url';
import path from 'path';
import { promisify } from 'util';

const __dirname = path.dirname(fileURLToPath(import.meta.url));
const execFileAsync = promisify(execFile);

const require = createRequire(import.meta.url);
const pkg = require('./package.json');

const [,, command, ...args] = process.argv;

function scriptPath(name) {
  return path.join(__dirname, name);
}

async function runShell(script) {
  try {
    await execFileAsync('bash', [scriptPath(script)], { stdio: 'inherit' });
  } catch (err) {
    process.exit(err.status ?? 1);
  }
}

function printHelp() {
  console.log(`remotelab v${pkg.version}

Usage:
  remotelab setup                    Run interactive setup
  remotelab start                    Start all services
  remotelab stop                     Stop all services
  remotelab restart [service]        Restart services (chat=owner+guests|tunnel|bridge|all)
  remotelab provision-host           Plan or execute whole-host provider provisioning
  remotelab bootstrap-host           Converge a Linux host into a RemoteLab host baseline
  remotelab install-profile          Resolve modules from install env and render runtime plan
  remotelab validate-profile         Validate host + profile health and report degradation
  remotelab guest-instance           Create isolated guest instances on this machine
  remotelab admin                    Manage fleet hosts and host -> instance admin views
  remotelab chat                     Run chat server in foreground
  remotelab api                      Call the local RemoteLab HTTP API with owner auth
  remotelab mail                     Manage agent mailbox and send outbound email
  remotelab gmail                    Manage the bound Gmail mailbox connector
  remotelab connector                Invoke instance-scoped connector capabilities
  remotelab assistant-message        Append an assistant message with optional local-file attachments
  remotelab local-bridge            Manage linked local helper bridges for a session
  remotelab agenda                  Manage the instance calendar feed
  remotelab trigger                  Manage durable session triggers
  remotelab schedule                 Manage recurring cron schedules
  remotelab usage-summary            Summarize local Codex token usage
  remotelab session-spawn            Spawn a focused parallel session from a source session
  remotelab generate-token           Generate a new access token
  remotelab set-password             Set username & password for login
  remotelab --help                   Show this help message
  remotelab --version                Show version`);
}

switch (command) {
  case 'setup':
    await runShell('setup.sh');
    break;

  case 'start':
    await runShell('start.sh');
    break;

  case 'stop':
    await runShell('stop.sh');
    break;

  case 'restart': {
    const service = args[0] || 'all';
    try {
      await execFileAsync('bash', [scriptPath('restart.sh'), service], { stdio: 'inherit' });
    } catch (err) {
      process.exit(err.status ?? 1);
    }
    break;
  }

  case 'provision-host':
  case 'bootstrap-host':
  case 'install-profile':
  case 'validate-profile': {
    const { runInstanceFactoryCommand } = await import(scriptPath('lib/instance-factory-command.mjs'));
    try {
      process.exitCode = await runInstanceFactoryCommand(command, args);
    } catch (error) {
      console.error(error.message || String(error));
      process.exit(1);
    }
    break;
  }

  case 'chat':
    await import(scriptPath('chat-server.mjs'));
    break;

  case 'release': {
    console.error('`remotelab release` has been removed. RemoteLab now runs the current source tree after restart. Use `remotelab restart chat` for the owner surface.');
    process.exit(1);
    break;
  }

  case 'guest-instance':
  case 'guest-instances': {
    const { runGuestInstanceCommand } = await import(scriptPath('lib/guest-instance-command.mjs'));
    try {
      process.exitCode = await runGuestInstanceCommand(args);
    } catch (error) {
      console.error(error.message || String(error));
      process.exit(1);
    }
    break;
  }

  case 'admin': {
    const { runAdminCommand } = await import(scriptPath('lib/admin-command.mjs'));
    try {
      process.exitCode = await runAdminCommand(args);
    } catch (error) {
      console.error(error.message || String(error));
      process.exit(1);
    }
    break;
  }

  case 'api': {
    const { runRemoteLabApiCommand } = await import(scriptPath('lib/remotelab-api-command.mjs'));
    try {
      process.exitCode = await runRemoteLabApiCommand(args);
    } catch (error) {
      console.error(error.message || String(error));
      process.exit(1);
    }
    break;
  }

  case 'mail':
  case 'email': {
    const { runAgentMailCommand } = await import(scriptPath('lib/agent-mail-command.mjs'));
    try {
      process.exitCode = await runAgentMailCommand(args);
    } catch (error) {
      console.error(error.message || String(error));
      process.exit(1);
    }
    break;
  }

  case 'gmail': {
    const { runGmailCommand } = await import(scriptPath('lib/gmail-command.mjs'));
    try {
      process.exitCode = await runGmailCommand(args);
    } catch (error) {
      console.error(error.message || String(error));
      process.exit(1);
    }
    break;
  }

  case 'connector':
  case 'connectors': {
    const { runConnectorCommand } = await import(scriptPath('lib/connector-command.mjs'));
    try {
      process.exitCode = await runConnectorCommand(args);
    } catch (error) {
      console.error(error.message || String(error));
      process.exit(1);
    }
    break;
  }

  case 'assistant-message':
  case 'assistant-messages': {
    const { runAssistantMessageCommand } = await import(scriptPath('lib/assistant-message-command.mjs'));
    try {
      process.exitCode = await runAssistantMessageCommand(args);
    } catch (error) {
      console.error(error.message || String(error));
      process.exit(1);
    }
    break;
  }

  case 'local-bridge': {
    const { runLocalBridgeCommand } = await import(scriptPath('lib/local-bridge-command.mjs'));
    try {
      process.exitCode = await runLocalBridgeCommand(args);
    } catch (error) {
      console.error(error.message || String(error));
      process.exit(1);
    }
    break;
  }

  case 'agenda': {
    const { runAgendaCommand } = await import(scriptPath('lib/agenda-command.mjs'));
    try {
      process.exitCode = await runAgendaCommand(args);
    } catch (error) {
      console.error(error.message || String(error));
      process.exit(1);
    }
    break;
  }

  case 'trigger':
  case 'triggers': {
    const { runTriggerCommand } = await import(scriptPath('lib/trigger-command.mjs'));
    try {
      process.exitCode = await runTriggerCommand(args);
    } catch (error) {
      console.error(error.message || String(error));
      process.exit(1);
    }
    break;
  }

  case 'schedule':
  case 'schedules': {
    const { runScheduleCommand } = await import(scriptPath('lib/schedule-command.mjs'));
    try {
      process.exitCode = await runScheduleCommand(args);
    } catch (error) {
      console.error(error.message || String(error));
      process.exit(1);
    }
    break;
  }

  case 'usage-summary': {
    const { runUsageSummaryCommand } = await import(scriptPath('lib/usage-summary-command.mjs'));
    try {
      process.exitCode = await runUsageSummaryCommand(args);
    } catch (error) {
      console.error(error.message || String(error));
      process.exit(1);
    }
    break;
  }

  case 'session-spawn':
  case 'spawn-session': {
    const { runSessionSpawnCommand } = await import(scriptPath('lib/session-spawn-command.mjs'));
    try {
      process.exitCode = await runSessionSpawnCommand(args);
    } catch (error) {
      console.error(error.message || String(error));
      process.exit(1);
    }
    break;
  }

  case 'generate-token': {
    try {
      await execFileAsync('node', [scriptPath('generate-token.mjs')], { stdio: 'inherit' });
    } catch (err) {
      process.exit(err.status ?? 1);
    }
    break;
  }

  case 'set-password': {
    await import(scriptPath('set-password.mjs'));
    break;
  }

  case '--version':
  case '-v':
    console.log(pkg.version);
    break;

  case '--help':
  case '-h':
  case undefined:
    printHelp();
    break;

  default:
    console.error(`Unknown command: ${command}`);
    console.error('Run "remotelab --help" for usage.');
    process.exit(1);
}