gbos 1.3.23 → 1.4.1

package/package.json

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

package/src/cli.js

@@ -7,8 +7,9 @@ const authCommand = require('./commands/auth');
 const connectCommand = require('./commands/connect');
 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 { syncStartCommand, syncStopCommand, syncStatusCommand, syncNowCommand, repoCreateCommand, repoListCommand, repoCloneCommand, authCommand: gitlabAuthCommand, authStatusCommand: gitlabAuthStatusCommand, authLogoutCommand: gitlabAuthLogoutCommand } = 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')
@@ -202,6 +237,24 @@ gitlabRepo
   .option('-d, --dir <directory>', 'Target directory name')
   .action(repoCloneCommand);
 
+// GitLab Auth subcommands
+gitlabCmd
+  .command('auth')
+  .description('Authenticate with GitLab (store token securely)')
+  .option('-t, --token <token>', 'GitLab Personal Access Token')
+  .option('-h, --host <host>', 'GitLab host (default: https://git.gbos.io)')
+  .action(gitlabAuthCommand);
+
+gitlabCmd
+  .command('auth-status')
+  .description('Show GitLab authentication status')
+  .action(gitlabAuthStatusCommand);
+
+gitlabCmd
+  .command('auth-logout')
+  .description('Remove GitLab credentials')
+  .action(gitlabAuthLogoutCommand);
+
 // ==================== Registry Commands ====================
 
 const registryCmd = program
@@ -244,7 +297,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/gitlab.js

@@ -38,14 +38,25 @@ function saveGitLabConfig(config) {
 
 // Get GitLab URL from session or config
 function getGitLabUrl() {
+  // Check config file first
+  try {
+    if (fs.existsSync(GITLAB_CONFIG_FILE)) {
+      const gitlabConfig = JSON.parse(fs.readFileSync(GITLAB_CONFIG_FILE, 'utf8'));
+      if (gitlabConfig.host) return gitlabConfig.host;
+    }
+  } catch (e) {
+    // Ignore
+  }
+
   const session = config.loadSession();
-  return session?.gitlab_url || process.env.GITLAB_URL || 'https://gitlab.com';
+  return session?.gitlab_url || process.env.GITLAB_URL || 'https://git.gbos.io';
 }
 
-// Get GitLab token
-function getGitLabToken() {
-  const session = config.loadSession();
-  return session?.gitlab_token || process.env.GITLAB_TOKEN || null;
+// Get GitLab token (checks all storage locations)
+async function getGitLabToken() {
+  const { createGitLabService } = require('../lib/gitlab');
+  const gitlabService = createGitLabService();
+  return await gitlabService.getToken();
 }
 
 // Execute git command
@@ -291,7 +302,7 @@ async function syncNowCommand(options) {
 
 // Create a new repository
 async function repoCreateCommand(name, options) {
-  const token = getGitLabToken();
+  const token = await getGitLabToken();
   const gitlabUrl = getGitLabUrl();
 
   if (!token) {
@@ -354,7 +365,7 @@ async function repoCreateCommand(name, options) {
 
 // List repositories
 async function repoListCommand(options) {
-  const token = getGitLabToken();
+  const token = await getGitLabToken();
   const gitlabUrl = getGitLabUrl();
 
   if (!token) {
@@ -410,7 +421,7 @@ async function repoListCommand(options) {
 
 // Clone a repository
 async function repoCloneCommand(name, options) {
-  const token = getGitLabToken();
+  const token = await getGitLabToken();
   const gitlabUrl = getGitLabUrl();
 
   if (!token) {
@@ -459,6 +470,137 @@ async function repoCloneCommand(name, options) {
   }
 }
 
+// ==================== AUTH COMMANDS ====================
+
+// Authenticate with GitLab
+async function authCommand(options) {
+  const { createGitLabService, GITLAB_HOST } = require('../lib/gitlab');
+  const readline = require('readline');
+
+  const termWidth = getTerminalWidth();
+  const tableWidth = Math.min(80, termWidth - 4);
+
+  console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+  console.log(`${BOLD}  GitLab Authentication${RESET}`);
+  console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+
+  let token = options.token;
+  const host = options.host || GITLAB_HOST;
+
+  // Interactive prompt if no token provided
+  if (!token) {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    console.log(`  ${DIM}GitLab Host: ${host}${RESET}`);
+    console.log(`  ${DIM}Create a Personal Access Token with scopes:${RESET}`);
+    console.log(`    ${DIM}- api${RESET}`);
+    console.log(`    ${DIM}- read_repository${RESET}`);
+    console.log(`    ${DIM}- write_repository${RESET}`);
+    console.log(`    ${DIM}- read_registry${RESET}`);
+    console.log(`    ${DIM}- write_registry${RESET}\n`);
+
+    token = await new Promise((resolve) => {
+      rl.question(`  ${CYAN}?${RESET} Enter GitLab Personal Access Token: `, (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+
+    if (!token) {
+      console.log(`\n  ${YELLOW}!${RESET} No token provided. Cancelled.\n`);
+      return;
+    }
+  }
+
+  console.log(`\n  ${DIM}Validating token...${RESET}`);
+
+  const gitlabService = createGitLabService({ host });
+
+  try {
+    const user = await gitlabService.storeToken(token);
+
+    console.log(`\n${GREEN}✓${RESET} ${BOLD}GitLab authentication successful${RESET}`);
+    console.log(`  ${DIM}User:${RESET} ${user.username} (${user.name || user.email})`);
+    console.log(`  ${DIM}Host:${RESET} ${host}`);
+    console.log(`  ${GREEN}✓${RESET} Token stored securely`);
+    console.log(`  ${GREEN}✓${RESET} Git credentials configured\n`);
+
+    console.log(`  ${DIM}You can now use:${RESET}`);
+    console.log(`    ${DIM}- gbos gitlab repo create <name>${RESET}`);
+    console.log(`    ${DIM}- gbos gitlab repo clone <name>${RESET}`);
+    console.log(`    ${DIM}- gbos start (orchestrator with GitLab integration)${RESET}\n`);
+
+  } catch (error) {
+    console.log(`\n${RED}✗${RESET} ${BOLD}Authentication failed${RESET}`);
+    console.log(`  ${DIM}${error.message}${RESET}\n`);
+    process.exit(1);
+  }
+}
+
+// Show GitLab auth status
+async function authStatusCommand() {
+  const { createGitLabService, GITLAB_HOST, GITLAB_CONFIG_FILE } = require('../lib/gitlab');
+
+  const termWidth = getTerminalWidth();
+  const tableWidth = Math.min(80, termWidth - 4);
+
+  console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+  console.log(`${BOLD}  GitLab Authentication Status${RESET}`);
+  console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+
+  const gitlabService = createGitLabService();
+
+  try {
+    const token = await gitlabService.getToken();
+
+    if (!token) {
+      console.log(`  ${YELLOW}!${RESET} Not authenticated with GitLab`);
+      console.log(`  ${DIM}Run: gbos gitlab auth --token <your-token>${RESET}\n`);
+      return;
+    }
+
+    // Validate token
+    gitlabService.token = token;
+    const user = await gitlabService.getCurrentUser();
+
+    console.log(`  ${GREEN}●${RESET} ${BOLD}Authenticated${RESET}`);
+    console.log(`  ${DIM}User:${RESET}  ${user.username}`);
+    console.log(`  ${DIM}Name:${RESET}  ${user.name || 'N/A'}`);
+    console.log(`  ${DIM}Email:${RESET} ${user.email || 'N/A'}`);
+    console.log(`  ${DIM}Host:${RESET}  ${GITLAB_HOST}\n`);
+
+    // Check if config file exists
+    if (fs.existsSync(GITLAB_CONFIG_FILE)) {
+      const gitlabConfig = JSON.parse(fs.readFileSync(GITLAB_CONFIG_FILE, 'utf8'));
+      if (gitlabConfig.storedAt) {
+        console.log(`  ${DIM}Stored: ${new Date(gitlabConfig.storedAt).toLocaleString()}${RESET}\n`);
+      }
+    }
+
+  } catch (error) {
+    console.log(`  ${RED}●${RESET} ${BOLD}Invalid or expired token${RESET}`);
+    console.log(`  ${DIM}Error: ${error.message}${RESET}`);
+    console.log(`  ${DIM}Run: gbos gitlab auth --token <new-token>${RESET}\n`);
+  }
+}
+
+// Logout from GitLab
+async function authLogoutCommand() {
+  const { createGitLabService } = require('../lib/gitlab');
+
+  const gitlabService = createGitLabService();
+
+  try {
+    await gitlabService.deleteToken();
+    console.log(`\n${GREEN}✓${RESET} GitLab credentials removed.\n`);
+  } catch (error) {
+    console.log(`\n${YELLOW}!${RESET} ${error.message}\n`);
+  }
+}
+
 module.exports = {
   syncStartCommand,
   syncStopCommand,
@@ -467,4 +609,7 @@ module.exports = {
   repoCreateCommand,
   repoListCommand,
   repoCloneCommand,
+  authCommand,
+  authStatusCommand,
+  authLogoutCommand,
 };

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

@@ -91,6 +91,10 @@ class GbosApiClient {
     return this.request('/cli/applications', { method: 'GET' });
   }
 
+  async getApplication(applicationId) {
+    return this.request(`/cli/applications/${applicationId}`, { method: 'GET' });
+  }
+
   // Node endpoints
   async listNodes(applicationId = null) {
     let endpoint = '/cli/nodes';