gbos 1.3.22 → 1.4.0

package/README.md

@@ -155,6 +155,7 @@ Stored at `~/.gbos/session.json`:
 | Variable | Description |
 |----------|-------------|
 | `DEBUG=1` | Enable debug output |
+| `GBOS_API_URL` | Override API endpoint (default: `https://api.gbos.io/api/v1`) |
 
 ## API Endpoints
 
@@ -260,7 +261,7 @@ gbos auth --force
 ## Links
 
 - **GBOS Platform**: [https://gbos.io](https://gbos.io)
-- **API Documentation**: [https://gbos-api-579767694933.us-south1.run.app/docs](https://gbos-api-579767694933.us-south1.run.app/docs)
+- **API Documentation**: [https://api.gbos.io/docs](https://api.gbos.io/docs)
 - **Issues**: [https://github.com/mystroanalytics/gbos-node-local/issues](https://github.com/mystroanalytics/gbos-node-local/issues)
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gbos",
-  "version": "1.3.22",
+  "version": "1.4.0",
   "description": "GBOS - Command line interface for GBOS services",
   "main": "src/index.js",
   "bin": {

package/src/cli.js

@@ -9,6 +9,7 @@ const logoutCommand = require('./commands/logout');
 const { tasksCommand, nextTaskCommand, continueCommand, fallbackCommand, addTaskCommand, completedCommand } = require('./commands/tasks');
 const { syncStartCommand, syncStopCommand, syncStatusCommand, syncNowCommand, repoCreateCommand, repoListCommand, repoCloneCommand } = require('./commands/gitlab');
 const { registryLoginCommand, registryImagesCommand, registryPushCommand, registryPullCommand } = require('./commands/registry');
+const { startCommand, resumeCommand, stopCommand, runsCommand } = require('./commands/orchestrator');
 const config = require('./lib/config');
 const { displayStatus, printBanner } = require('./lib/display');
 
@@ -133,6 +134,40 @@ program
   .description('Create a new task interactively')
   .action(addTaskCommand);
 
+// ==================== Orchestrator Commands ====================
+
+program
+  .command('start')
+  .description('Start the GBOS orchestrator to automatically process tasks')
+  .option('-a, --agent <agent>', 'Agent to use (claude-code, codex, gemini)', 'claude-code')
+  .option('-d, --dir <directory>', 'Working directory')
+  .option('--auto-approve', 'Auto-approve agent actions')
+  .option('--no-mr', 'Skip merge request creation')
+  .option('-c, --continuous', 'Continuously process tasks')
+  .option('-n, --max-tasks <number>', 'Maximum tasks to process', '1')
+  .option('--show-prompt', 'Show the generated prompt')
+  .action(startCommand);
+
+program
+  .command('resume')
+  .description('Resume a paused orchestrator run')
+  .option('-r, --run-id <runId>', 'Specific run ID to resume')
+  .option('--no-mr', 'Skip merge request creation')
+  .action(resumeCommand);
+
+program
+  .command('stop')
+  .description('Stop an active orchestrator run')
+  .option('-r, --run-id <runId>', 'Specific run ID to stop')
+  .option('-f, --force', 'Force stop and mark as failed')
+  .action(stopCommand);
+
+program
+  .command('runs')
+  .description('List recent orchestrator runs')
+  .option('-l, --limit <number>', 'Number of runs to show', '10')
+  .action(runsCommand);
+
 program
   .command('logout')
   .description('Log out from GBOS services and clear credentials')
@@ -244,7 +279,7 @@ program
         cmd.outputHelp();
       } else {
         console.log(`Unknown command: ${command}`);
-        console.log('Available commands: auth, connect, disconnect, status, tasks, next, continue, completed, fallback, add_task, logout, gitlab, registry, help');
+        console.log('Available commands: auth, connect, disconnect, status, tasks, next, continue, completed, fallback, add_task, start, resume, stop, runs, logout, gitlab, registry, help');
       }
     } else {
       program.outputHelp();

package/src/commands/orchestrator.js

@@ -0,0 +1,329 @@
+/**
+ * Orchestrator Commands
+ * CLI commands for start, resume, and stop
+ */
+
+const config = require('../lib/config');
+const { displayMessageBox, fg, LOGO_PURPLE, RESET, BOLD, DIM, getTerminalWidth } = require('../lib/display');
+const Orchestrator = require('../orchestrator/orchestrator');
+const { StateMachine, STATES, RUNS_DIR } = require('../orchestrator/state-machine');
+const { checkInstalledAdapters } = require('../orchestrator/adapters');
+const fs = require('fs');
+const path = require('path');
+
+// Colors
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const CYAN = '\x1b[36m';
+
+/**
+ * gbos start - Start the orchestrator
+ */
+async function startCommand(options) {
+  // Check authentication
+  if (!config.isAuthenticated()) {
+    displayMessageBox('Not Authenticated', 'Please run "gbos auth" first.', 'warning');
+    process.exit(1);
+  }
+
+  // Check connection
+  const connection = config.getConnection();
+  if (!connection) {
+    displayMessageBox('Not Connected', 'Please run "gbos connect" first.', 'warning');
+    process.exit(1);
+  }
+
+  const termWidth = getTerminalWidth();
+  const tableWidth = Math.min(80, termWidth - 4);
+
+  console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+  console.log(`${BOLD}  GBOS Orchestrator${RESET}`);
+  console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+
+  // Check for existing active run
+  const activeRun = StateMachine.getActiveRun();
+  if (activeRun) {
+    console.log(`  ${YELLOW}!${RESET} An active run exists: ${activeRun.runId}`);
+    console.log(`  ${DIM}State: ${activeRun.state}${RESET}`);
+    console.log(`  ${DIM}Use "gbos resume" to continue or "gbos stop" to cancel.${RESET}\n`);
+    return;
+  }
+
+  // Check agent availability
+  console.log(`  ${DIM}Checking agent availability...${RESET}`);
+  const adapters = await checkInstalledAdapters();
+  const agentName = options.agent || 'claude-code';
+  const agentInfo = adapters[agentName] || adapters['claude-code'];
+
+  if (!agentInfo?.available) {
+    displayMessageBox('Agent Not Found', `Agent "${agentName}" is not installed.\n\nAvailable agents: ${Object.entries(adapters).filter(([_, v]) => v.available).map(([k]) => k).join(', ') || 'none'}`, 'error');
+    process.exit(1);
+  }
+
+  console.log(`  ${GREEN}✓${RESET} Agent: ${agentName} (${agentInfo.version || 'installed'})`);
+  console.log(`  ${DIM}Application: ${connection.application?.name || 'N/A'}${RESET}`);
+  console.log(`  ${DIM}Node: ${connection.node?.name || 'N/A'}${RESET}`);
+  console.log('');
+
+  // Create orchestrator
+  const orchestrator = new Orchestrator({
+    agent: agentName,
+    autoApprove: options.autoApprove || false,
+    createMR: options.mr !== false,
+    continuous: options.continuous || false,
+    maxTasks: options.maxTasks ? parseInt(options.maxTasks) : 1,
+    workingDir: options.dir ? path.resolve(options.dir) : null,
+  });
+
+  // Set up event handlers
+  orchestrator.on('started', ({ runId }) => {
+    console.log(`  ${GREEN}✓${RESET} Run started: ${runId}\n`);
+  });
+
+  orchestrator.on('stage', ({ stage }) => {
+    console.log(`  ${CYAN}▸${RESET} ${stage.replace(/_/g, ' ')}`);
+  });
+
+  orchestrator.on('log', ({ message }) => {
+    console.log(`    ${DIM}${message}${RESET}`);
+  });
+
+  orchestrator.on('prompt', ({ prompt }) => {
+    if (options.showPrompt) {
+      console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+      console.log(`${BOLD}  Task Prompt${RESET}`);
+      console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+      console.log(prompt);
+      console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+    }
+  });
+
+  orchestrator.on('committed', (result) => {
+    if (result.commit) {
+      console.log(`    ${GREEN}✓${RESET} Committed: ${result.commit.shortHash}`);
+    }
+    if (result.mergeRequest) {
+      console.log(`    ${GREEN}✓${RESET} MR: ${result.mergeRequest.url}`);
+    }
+  });
+
+  orchestrator.on('completed', ({ tasksCompleted }) => {
+    console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+    console.log(`${GREEN}✓${RESET} ${BOLD}Orchestrator completed${RESET}`);
+    console.log(`  ${DIM}Tasks completed: ${tasksCompleted}${RESET}`);
+    console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+  });
+
+  orchestrator.on('failed', ({ error }) => {
+    console.log(`\n${RED}✗${RESET} ${BOLD}Orchestrator failed${RESET}`);
+    console.log(`  ${DIM}Error: ${error.message}${RESET}\n`);
+  });
+
+  // Handle interrupts
+  process.on('SIGINT', async () => {
+    console.log(`\n\n  ${YELLOW}!${RESET} Stopping orchestrator...`);
+    await orchestrator.stop();
+    console.log(`  ${DIM}Run paused. Use "gbos resume" to continue.${RESET}\n`);
+    process.exit(0);
+  });
+
+  // Start the orchestrator
+  try {
+    await orchestrator.start();
+  } catch (error) {
+    console.log(`\n${RED}✗${RESET} ${error.message}\n`);
+    process.exit(1);
+  }
+}
+
+/**
+ * gbos resume - Resume a paused run
+ */
+async function resumeCommand(options) {
+  const termWidth = getTerminalWidth();
+  const tableWidth = Math.min(80, termWidth - 4);
+
+  console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+  console.log(`${BOLD}  Resume Orchestrator${RESET}`);
+  console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+
+  // Find run to resume
+  let runId = options.runId;
+  let run;
+
+  if (runId) {
+    try {
+      run = StateMachine.loadRun(runId);
+    } catch (e) {
+      displayMessageBox('Run Not Found', `Run "${runId}" not found.`, 'error');
+      process.exit(1);
+    }
+  } else {
+    run = StateMachine.getActiveRun();
+    if (!run) {
+      console.log(`  ${DIM}No active runs to resume.${RESET}`);
+      console.log(`  ${DIM}Use "gbos start" to begin a new run.${RESET}\n`);
+      return;
+    }
+    runId = run.runId;
+  }
+
+  if (!run.isResumable()) {
+    console.log(`  ${YELLOW}!${RESET} Run ${runId} is not resumable (state: ${run.state})`);
+    return;
+  }
+
+  console.log(`  ${DIM}Resuming run: ${runId}${RESET}`);
+  console.log(`  ${DIM}State: ${run.state}${RESET}`);
+  console.log(`  ${DIM}Task: ${run.context.taskKey || run.context.taskId || 'N/A'}${RESET}\n`);
+
+  // Create orchestrator and resume
+  const orchestrator = new Orchestrator({
+    agent: run.context.agentVendor || 'claude-code',
+    createMR: options.mr !== false,
+  });
+
+  // Set up event handlers (same as start)
+  orchestrator.on('stage', ({ stage }) => {
+    console.log(`  ${CYAN}▸${RESET} ${stage.replace(/_/g, ' ')}`);
+  });
+
+  orchestrator.on('log', ({ message }) => {
+    console.log(`    ${DIM}${message}${RESET}`);
+  });
+
+  orchestrator.on('completed', ({ tasksCompleted }) => {
+    console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+    console.log(`${GREEN}✓${RESET} ${BOLD}Orchestrator completed${RESET}`);
+    console.log(`  ${DIM}Tasks completed: ${tasksCompleted}${RESET}`);
+    console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+  });
+
+  orchestrator.on('failed', ({ error }) => {
+    console.log(`\n${RED}✗${RESET} ${BOLD}Orchestrator failed${RESET}`);
+    console.log(`  ${DIM}Error: ${error.message}${RESET}\n`);
+  });
+
+  process.on('SIGINT', async () => {
+    console.log(`\n\n  ${YELLOW}!${RESET} Stopping orchestrator...`);
+    await orchestrator.stop();
+    process.exit(0);
+  });
+
+  try {
+    await orchestrator.resume(runId);
+  } catch (error) {
+    console.log(`\n${RED}✗${RESET} ${error.message}\n`);
+    process.exit(1);
+  }
+}
+
+/**
+ * gbos stop - Stop an active run
+ */
+async function stopCommand(options) {
+  const termWidth = getTerminalWidth();
+  const tableWidth = Math.min(80, termWidth - 4);
+
+  console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+  console.log(`${BOLD}  Stop Orchestrator${RESET}`);
+  console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+
+  // Find active run
+  let runId = options.runId;
+  let run;
+
+  if (runId) {
+    try {
+      run = StateMachine.loadRun(runId);
+    } catch (e) {
+      displayMessageBox('Run Not Found', `Run "${runId}" not found.`, 'error');
+      process.exit(1);
+    }
+  } else {
+    run = StateMachine.getActiveRun();
+    if (!run) {
+      console.log(`  ${DIM}No active runs to stop.${RESET}\n`);
+      return;
+    }
+    runId = run.runId;
+  }
+
+  if (run.state === STATES.COMPLETED || run.state === STATES.FAILED) {
+    console.log(`  ${DIM}Run ${runId} is already ${run.state}.${RESET}\n`);
+    return;
+  }
+
+  // Transition to paused or failed
+  if (options.force) {
+    run.transition(STATES.FAILED, { reason: 'Forcefully stopped by user' });
+    console.log(`  ${RED}✗${RESET} Run ${runId} forcefully stopped.\n`);
+  } else {
+    run.transition(STATES.PAUSED, { reason: 'Stopped by user' });
+    console.log(`  ${YELLOW}!${RESET} Run ${runId} paused.`);
+    console.log(`  ${DIM}Use "gbos resume" to continue.${RESET}\n`);
+  }
+}
+
+/**
+ * gbos runs - List recent runs
+ */
+async function runsCommand(options) {
+  const termWidth = getTerminalWidth();
+  const tableWidth = Math.min(100, termWidth - 4);
+
+  console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+  console.log(`${BOLD}  Orchestrator Runs${RESET}`);
+  console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+
+  StateMachine.ensureRunsDir();
+
+  const files = fs.readdirSync(RUNS_DIR)
+    .filter(f => f.endsWith('.json'))
+    .sort()
+    .reverse()
+    .slice(0, options.limit ? parseInt(options.limit) : 10);
+
+  if (files.length === 0) {
+    console.log(`  ${DIM}No runs found.${RESET}`);
+    console.log(`  ${DIM}Use "gbos start" to begin a new run.${RESET}\n`);
+    return;
+  }
+
+  for (const file of files) {
+    try {
+      const runId = file.replace('.json', '');
+      const run = StateMachine.loadRun(runId);
+      const summary = run.getSummary();
+
+      const stateColors = {
+        [STATES.COMPLETED]: GREEN,
+        [STATES.FAILED]: RED,
+        [STATES.PAUSED]: YELLOW,
+      };
+      const stateColor = stateColors[summary.state] || CYAN;
+
+      console.log(`  ${stateColor}●${RESET} ${BOLD}${summary.runId}${RESET}`);
+      console.log(`    ${DIM}State: ${summary.state} | Agent: ${summary.agent}${RESET}`);
+      if (summary.taskKey) {
+        console.log(`    ${DIM}Task: ${summary.taskKey}${RESET}`);
+      }
+      if (summary.startTime) {
+        console.log(`    ${DIM}Started: ${new Date(summary.startTime).toLocaleString()}${RESET}`);
+      }
+      console.log('');
+    } catch (e) {
+      // Skip invalid files
+    }
+  }
+
+  console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+}
+
+module.exports = {
+  startCommand,
+  resumeCommand,
+  stopCommand,
+  runsCommand,
+};

package/src/lib/api.js

@@ -1,6 +1,11 @@
 const config = require('./config');
 
-const API_BASE_URL = 'https://gbos-api-579767694933.us-south1.run.app/api/v1';
+// Default API endpoint (new domain)
+const DEFAULT_API_URL = 'https://api.gbos.io/api/v1';
+
+// Support GBOS_API_URL env var for backwards compatibility or custom endpoints
+// e.g., GBOS_API_URL=https://gbos-api-579767694933.us-south1.run.app/api/v1
+const API_BASE_URL = process.env.GBOS_API_URL || DEFAULT_API_URL;
 
 class GbosApiClient {
   constructor() {

package/src/orchestrator/adapters/base-adapter.js

@@ -0,0 +1,204 @@
+/**
+ * Base Agent Adapter
+ * Defines the interface for all agent adapters
+ */
+
+const { EventEmitter } = require('events');
+
+class BaseAdapter extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    this.name = 'base';
+    this.config = config;
+    this.process = null;
+    this.isRunning = false;
+    this.supportsNonInteractive = false;
+    this.supportsInteractive = true;
+  }
+
+  /**
+   * Check if the agent CLI is available
+   * @returns {Promise<boolean>}
+   */
+  async isAvailable() {
+    throw new Error('isAvailable() must be implemented');
+  }
+
+  /**
+   * Get the agent version
+   * @returns {Promise<string>}
+   */
+  async getVersion() {
+    throw new Error('getVersion() must be implemented');
+  }
+
+  /**
+   * Generate the command to run the agent
+   * @param {Object} options - Run options
+   * @returns {Object} { command, args, env }
+   */
+  getCommand(options = {}) {
+    throw new Error('getCommand() must be implemented');
+  }
+
+  /**
+   * Format a prompt for this specific agent
+   * @param {Object} task - Task object from GBOS API
+   * @param {Object} context - Additional context (repo, cloudRunUrl, etc.)
+   * @returns {string} Formatted prompt
+   */
+  formatPrompt(task, context = {}) {
+    throw new Error('formatPrompt() must be implemented');
+  }
+
+  /**
+   * Detect if the agent has completed its work
+   * Used for interactive mode
+   * @param {string} output - Recent output from the agent
+   * @returns {boolean}
+   */
+  detectCompletion(output) {
+    // Default: look for common completion patterns
+    const completionPatterns = [
+      /task.*completed?/i,
+      /done.*with.*changes/i,
+      /all.*changes.*committed/i,
+      /finished.*working/i,
+      /ready.*for.*review/i,
+    ];
+    return completionPatterns.some(p => p.test(output));
+  }
+
+  /**
+   * Detect if the agent is waiting for input
+   * @param {string} output - Recent output
+   * @returns {boolean}
+   */
+  detectWaitingForInput(output) {
+    const waitPatterns = [
+      /\?.*$/m,
+      /\(y\/n\)/i,
+      /press.*enter/i,
+      /continue\?/i,
+    ];
+    return waitPatterns.some(p => p.test(output));
+  }
+
+  /**
+   * Detect if the agent encountered an error
+   * @param {string} output - Recent output
+   * @returns {boolean}
+   */
+  detectError(output) {
+    const errorPatterns = [
+      /error:/i,
+      /failed:/i,
+      /exception:/i,
+      /fatal:/i,
+    ];
+    return errorPatterns.some(p => p.test(output));
+  }
+
+  /**
+   * Parse the output to extract useful information
+   * @param {string} output - Full output from the agent
+   * @returns {Object} Parsed information
+   */
+  parseOutput(output) {
+    return {
+      raw: output,
+      filesModified: this.extractFilesModified(output),
+      testsRun: this.extractTestResults(output),
+      errors: this.extractErrors(output),
+    };
+  }
+
+  /**
+   * Extract files modified from output
+   * @param {string} output
+   * @returns {string[]}
+   */
+  extractFilesModified(output) {
+    const files = new Set();
+    // Common patterns for file modifications
+    const patterns = [
+      /(?:created?|modified?|updated?|wrote?|edited?)\s+[`']?([^\s`']+\.[a-z]+)/gi,
+      /(?:file|path):\s*[`']?([^\s`']+\.[a-z]+)/gi,
+    ];
+    patterns.forEach(pattern => {
+      let match;
+      while ((match = pattern.exec(output)) !== null) {
+        files.add(match[1]);
+      }
+    });
+    return Array.from(files);
+  }
+
+  /**
+   * Extract test results from output
+   * @param {string} output
+   * @returns {Object|null}
+   */
+  extractTestResults(output) {
+    // Look for common test output patterns
+    const jestMatch = output.match(/Tests:\s*(\d+)\s*passed,?\s*(\d+)?\s*failed?/i);
+    if (jestMatch) {
+      return {
+        framework: 'jest',
+        passed: parseInt(jestMatch[1]) || 0,
+        failed: parseInt(jestMatch[2]) || 0,
+      };
+    }
+
+    const pytestMatch = output.match(/(\d+)\s*passed.*?(\d+)?\s*failed?/i);
+    if (pytestMatch) {
+      return {
+        framework: 'pytest',
+        passed: parseInt(pytestMatch[1]) || 0,
+        failed: parseInt(pytestMatch[2]) || 0,
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * Extract errors from output
+   * @param {string} output
+   * @returns {string[]}
+   */
+  extractErrors(output) {
+    const errors = [];
+    const lines = output.split('\n');
+    for (const line of lines) {
+      if (/error:|failed:|exception:|fatal:/i.test(line)) {
+        errors.push(line.trim());
+      }
+    }
+    return errors;
+  }
+
+  /**
+   * Stop the running agent
+   */
+  async stop() {
+    if (this.process) {
+      this.process.kill('SIGTERM');
+      this.isRunning = false;
+      this.emit('stopped');
+    }
+  }
+
+  /**
+   * Force kill the agent
+   */
+  async kill() {
+    if (this.process) {
+      this.process.kill('SIGKILL');
+      this.isRunning = false;
+      this.emit('killed');
+    }
+  }
+}
+
+module.exports = BaseAdapter;