@profoundlogic/coderflow-cli 0.2.1

package/lib/commands/apply.js

@@ -0,0 +1,238 @@
+/**
+ * Command: coder apply - Apply patches from completed task to local repos
+ */
+
+import { request } from '../http-client.js';
+import { select } from '@inquirer/prompts';
+import { groupRelatedTasks, formatGroupForDisplay, formatTaskForDisplay } from '../task-grouping.js';
+
+/**
+ * Fetch recent completed tasks from the server
+ */
+async function fetchRecentTasks() {
+  try {
+    // Fetch most recent completed tasks (only completed tasks can be applied)
+    // Include summary to show more details about each task
+    const data = await request('/tasks?status=completed&limit=50&include=summary');
+
+    // Filter out test command tasks (they're for testing, not for applying)
+    const tasks = (data.tasks || []).filter(task => task.taskType !== 'test');
+
+    return tasks;
+  } catch (error) {
+    console.error('Failed to fetch tasks:', error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Prompt user to select a task from a list of grouped tasks
+ */
+async function selectTaskInteractively() {
+  console.log('Fetching your most recent completed tasks...\n');
+
+  const tasks = await fetchRecentTasks();
+
+  if (!tasks || tasks.length === 0) {
+    console.log('No completed tasks found.');
+    console.log('\nPossible reasons:');
+    console.log('  - No tasks have been run yet');
+    console.log('  - All tasks are still running or have failed');
+    console.log('  - Server was restarted (task history is not persistent)');
+    console.log('\nRun "coder list" to see all tasks.');
+    process.exit(0);
+  }
+
+  // Group tasks by variants (same as web UI)
+  const groups = groupRelatedTasks(tasks);
+
+  // Create choices for the prompt
+  const choices = groups.map(group => ({
+    name: formatGroupForDisplay(group),
+    value: group
+  }));
+
+  // Prompt user to select a task group
+  let selectedGroup;
+  try {
+    selectedGroup = await select({
+      message: 'Select a task to apply (Ctrl+C to cancel):',
+      choices,
+      pageSize: 15,
+      loop: false  // Disable wrapping to make start/end of list clear
+    });
+  } catch (error) {
+    // User cancelled (Ctrl+C) or other error
+    if (error.name === 'ExitPromptError' || error.message.includes('User force closed')) {
+      console.log('\nCancelled.');
+      process.exit(0);
+    }
+    throw error;
+  }
+
+  // If the group has multiple variants, prompt for variant selection
+  if (selectedGroup.isGroup && selectedGroup.variants.length > 1) {
+    console.log(''); // Empty line for spacing
+
+    const variantChoices = selectedGroup.variants.map(variant => ({
+      name: formatTaskForDisplay(variant, true),
+      value: variant
+    }));
+
+    let selectedVariant;
+    try {
+      selectedVariant = await select({
+        message: 'Select a variant (Ctrl+C to cancel):',
+        choices: variantChoices,
+        pageSize: 10,
+        loop: false  // Disable wrapping to make start/end of list clear
+      });
+    } catch (error) {
+      // User cancelled (Ctrl+C) or other error
+      if (error.name === 'ExitPromptError' || error.message.includes('User force closed')) {
+        console.log('\nCancelled.');
+        process.exit(0);
+      }
+      throw error;
+    }
+
+    return selectedVariant.taskId;
+  }
+
+  return selectedGroup.primary.taskId;
+}
+
+export async function applyTask(taskIdArg, filePathArg) {
+  let taskId = taskIdArg;
+
+  // If no task ID provided, show interactive selection
+  if (!taskId) {
+    taskId = await selectTaskInteractively();
+    console.log(''); // Empty line for spacing
+  }
+
+  // Fetch task details to show context
+  let taskDetails;
+  try {
+    taskDetails = await request(`/tasks/${taskId}?include=summary,instructions`);
+  } catch (error) {
+    console.error(`Failed to fetch task details: ${error.message}`);
+    // Continue anyway - we can still try to apply patches
+  }
+
+  // Show task information
+  if (taskDetails) {
+    console.log('Task Details:');
+    console.log('─'.repeat(60));
+
+    // Show template if used
+    if (taskDetails.taskType && taskDetails.taskType !== 'manual') {
+      console.log(`Template: ${taskDetails.taskType}`);
+    }
+
+    // Show template parameters if any (excluding instructions which we show separately)
+    if (taskDetails.parameters && Object.keys(taskDetails.parameters).length > 0) {
+      const params = { ...taskDetails.parameters };
+      delete params.instructions; // We'll show this separately
+
+      if (Object.keys(params).length > 0) {
+        console.log('\nParameters:');
+        for (const [key, value] of Object.entries(params)) {
+          // Format the value nicely
+          let displayValue = value;
+          if (typeof value === 'string' && value.length > 60) {
+            displayValue = value.substring(0, 57) + '...';
+          } else if (typeof value === 'object') {
+            displayValue = JSON.stringify(value);
+          }
+          console.log(`  ${key}: ${displayValue}`);
+        }
+      }
+    }
+
+    // Show instructions
+    const instructions = taskDetails.instructions || taskDetails.parameters?.instructions;
+    if (instructions) {
+      console.log('\nInstructions:');
+      // Show first 5 lines or all if less than 5
+      const lines = instructions.split('\n').slice(0, 5);
+      lines.forEach(line => console.log(`  ${line}`));
+      const totalLines = instructions.split('\n').length;
+      if (totalLines > 5) {
+        console.log(`  ... (${totalLines - 5} more lines)`);
+      }
+    }
+
+    console.log('─'.repeat(60));
+    console.log('');
+  }
+
+  console.log(`Applying patches...\n`);
+
+  // Get patches from server
+  const data = await request(`/tasks/${taskId}/patches`);
+
+  if (!data.patches || data.patches.length === 0) {
+    console.log('No patches found for this task.');
+    console.log('Task may not have made any changes.');
+    return;
+  }
+
+  console.log(`Found ${data.patches.length} repository${data.patches.length > 1 ? 'ies' : ''} with changes:\n`);
+
+  // Apply each patch
+  for (const patch of data.patches) {
+    console.log(`📦 ${patch.repo_name}`);
+    console.log(`   Files changed: ${patch.files_changed}`);
+
+    // Use local_path from server (includes environment config mapping)
+    // Falls back to repo_name if local_path not provided (backwards compatibility)
+    const localPath = patch.local_path || patch.repo_name;
+
+    // Check if repo exists in current directory
+    const { existsSync } = await import('fs');
+    const repoPath = `./${localPath}`;
+
+    if (!existsSync(repoPath)) {
+      console.log(`   ✗ Repository not found: ${repoPath}`);
+      console.log(`     Expected path: ${repoPath}`);
+      console.log(`     Skipping ${patch.repo_name}\n`);
+      continue;
+    }
+
+    // Write patch to temporary file
+    const { writeFileSync, unlinkSync } = await import('fs');
+    const tmpPatch = `/tmp/${taskId}-${patch.patch_file}`;
+    writeFileSync(tmpPatch, patch.patch_content, { encoding: 'utf-8' });
+
+    // Apply patch
+    const { execSync } = await import('child_process');
+    try {
+      let applyCommand = `git -C ${repoPath} apply --ignore-whitespace --whitespace=nowarn`;
+      
+      if (filePathArg) {
+        // Use --include to only apply changes for specific file
+        // Note: git apply expects the path as it appears in the patch (relative to repo root)
+        applyCommand += ` --include=${filePathArg}`;
+        console.log(`   (Applying only changes for: ${filePathArg})`);
+      }
+
+      applyCommand += ` ${tmpPatch}`;
+
+      execSync(applyCommand, { stdio: 'pipe' });
+      console.log(`   ✓ Patch applied successfully\n`);
+
+      // Clean up temp file
+      unlinkSync(tmpPatch);
+    } catch (error) {
+      console.log(`   ✗ Failed to apply patch: ${error.message}`);
+      console.log(`     You may need to apply manually\n`);
+      unlinkSync(tmpPatch);
+    }
+  }
+
+  console.log('Next steps:');
+  console.log('  1. Review changes: git status');
+  console.log('  2. Stage changes: git add .');
+  console.log('  3. Commit changes: git commit -m "Your commit message"');
+}

package/lib/commands/attach.js

@@ -0,0 +1,143 @@
+/**
+ * Command: coder attach [container-id] - Attach to a running container
+ */
+
+import { request } from '../http-client.js';
+import { getLastContainerId, saveLastContainerId } from '../config.js';
+import { connectTerminal } from '../terminal-client.js';
+
+export async function attachToContainer(args = []) {
+  let containerId = null;
+  let startShell = false;
+  let agentOverride = null;
+
+  // Parse arguments - process flags first, then find container ID
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--shell') {
+      startShell = true;
+    } else if (arg === '--agent') {
+      const next = args[index + 1];
+      if (!next) {
+        console.error('Error: --agent requires a value (claude or codex)');
+        process.exit(1);
+      }
+      agentOverride = next;
+      index += 1;
+    } else if (arg.startsWith('--agent=')) {
+      agentOverride = arg.substring('--agent='.length);
+    } else if (!containerId && !arg.startsWith('--')) {
+      // This is the container ID
+      containerId = arg;
+    }
+  }
+
+  // If no container ID provided, try to use the last one
+  if (!containerId) {
+    containerId = await getLastContainerId();
+    if (!containerId) {
+      console.error('Error: No container ID specified and no previous container found.');
+      console.error('\nUsage:');
+      console.error('  coder attach <container-id>    # Attach to specific container');
+      console.error('  coder attach                   # Attach to last container');
+      console.error('\nTo see available containers, run:');
+      console.error('  coder containers');
+      process.exit(1);
+    }
+    console.log(`Attaching to last container: ${containerId}`);
+  } else {
+    console.log(`Attaching to container: ${containerId}`);
+  }
+
+  // Fetch container info from server to verify it exists and get details
+  let containerInfo;
+  try {
+    containerInfo = await request(`/containers/${containerId}`);
+  } catch (error) {
+    console.error(`\n✗ Failed to find container: ${error.message}`);
+    console.error('\nTo see available containers, run:');
+    console.error('  coder containers');
+    process.exit(1);
+  }
+
+  // Display container info
+  console.log(`\n✓ Container found`);
+  console.log(`  Container ID:   ${containerInfo.containerId}`);
+  console.log(`  Environment:    ${containerInfo.environment}`);
+  console.log(`  Image:          ${containerInfo.image || 'N/A'}`);
+  console.log(`  Default Agent:  ${containerInfo.defaultAgent}`);
+  console.log(`  Status:         ${containerInfo.status}`);
+  if (containerInfo.isTaskContainer) {
+    console.log(`  Type:           Task container (${containerInfo.taskId})`);
+  }
+
+  if (containerInfo.status !== 'running') {
+    console.error(`\n✗ Container is not running (status: ${containerInfo.status})`);
+    console.error('You can only attach to running containers.');
+    process.exit(1);
+  }
+
+  // Determine command to run
+  let cmd;
+  let descriptiveAction;
+
+  if (startShell) {
+    cmd = null; // Just start a shell
+    descriptiveAction = 'Connecting to shell';
+  } else if (agentOverride) {
+    // Override the default agent with resume
+    if (agentOverride === 'claude') {
+      cmd = 'cd /workspace && claude --resume';
+      descriptiveAction = 'Resuming with Claude';
+    } else if (agentOverride === 'codex') {
+      cmd = 'cd /workspace && codex resume';
+      descriptiveAction = 'Resuming with Codex';
+    } else {
+      console.error(`Error: Unknown agent: ${agentOverride}`);
+      console.error('Valid agents: claude, codex');
+      process.exit(1);
+    }
+  } else {
+    // Use the default agent from container with resume
+    const agent = containerInfo.defaultAgent || 'claude';
+    if (agent === 'claude') {
+      cmd = 'cd /workspace && claude --resume';
+      descriptiveAction = 'Resuming with Claude';
+    } else if (agent === 'codex') {
+      cmd = 'cd /workspace && codex resume';
+      descriptiveAction = 'Resuming with Codex';
+    } else {
+      // Fallback for unknown agents
+      cmd = `cd /workspace && ${agent}`;
+      descriptiveAction = `Starting ${agent}`;
+    }
+  }
+
+  console.log(`\n${descriptiveAction}...\n`);
+
+  // Save this as the last container
+  await saveLastContainerId(containerInfo.containerId);
+
+  try {
+    const exitCode = await connectTerminal(containerInfo.containerId, cmd);
+
+    if (exitCode === 0) {
+      console.log(`\n✓ Disconnected from container ${containerInfo.containerId}`);
+    } else if (exitCode === 130) {
+      console.log(`\n✓ Terminal session interrupted`);
+    } else {
+      console.error(`\n✗ Terminal session exited with code ${exitCode}`);
+    }
+  } catch (error) {
+    console.error(`\n✗ Failed to connect to terminal: ${error.message}`);
+    console.log('\nContainer may still be running.');
+    console.log('\nTo see container status, run:');
+    console.log(`  coder containers`);
+    return;
+  }
+
+  console.log('\nContainer is still running and will auto-cleanup after 2 hours of inactivity.');
+  console.log(`Container ID: ${containerInfo.containerId}`);
+  console.log('\nTo reconnect:');
+  console.log(`  coder attach`);
+}

package/lib/commands/config.js

@@ -0,0 +1,226 @@
+/**
+ * Config command - manage coder-setup configuration
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import { getConfigPathForDisplay, loadClientConfig, invalidateConfigCache, loadRawClientConfig } from '../config.js';
+import { getActiveProfileName, loadProfile, getProfilePath } from '../profile.js';
+
+// Client-side config keys (stored in ~/.coder/config.json)
+// Note: Server-side keys (coder_setup_path, server_port, etc.) are managed by coder-server config
+const CLIENT_CONFIG_KEYS = new Set([
+  'server',
+  'apiKey',
+  'last_container_id',
+  'default_environment'
+]);
+
+/**
+ * Handle config command
+ * Usage:
+ *   coder config set ssh_host sandbox.example.com
+ *   coder config get ssh_host
+ *   coder config show
+ */
+export async function handleConfig(args) {
+  const subcommand = args[0];
+
+  if (!subcommand) {
+    console.error('Usage: coder config <set|get|remove|show> [key] [value]');
+    console.error('');
+    console.error('Commands:');
+    console.error('  set <key> <value>  Set a configuration value');
+    console.error('  get <key>          Get a configuration value');
+    console.error('  remove <key>       Remove a configuration value');
+    console.error('  show               Show all configuration');
+    console.error('');
+    console.error('Configuration keys:');
+    console.error('  server              Server URL (e.g., http://localhost:3000)');
+    console.error('  default_environment Default environment name');
+    console.error('  apiKey              API authentication key');
+    console.error('');
+    console.error('Note: Server-side configuration is managed by coder-server config');
+    process.exit(1);
+  }
+
+  try {
+    switch (subcommand) {
+      case 'set':
+        await setConfig(args[1], args[2]);
+        break;
+
+      case 'get':
+        await getConfig(args[1]);
+        break;
+
+      case 'remove':
+      case 'unset':
+        await removeConfig(args[1]);
+        break;
+
+      case 'show':
+        await showConfig();
+        break;
+
+      default:
+        console.error(`Unknown subcommand: ${subcommand}`);
+        console.error('Run "coder config" for usage information');
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+async function setConfig(key, value) {
+  if (!key || value === undefined) {
+    console.error('Usage: coder config set <key> <value>');
+    process.exit(1);
+  }
+
+  if (!CLIENT_CONFIG_KEYS.has(key)) {
+    console.error(`Unknown configuration key: ${key}`);
+    console.error('Run "coder config" for a list of available keys');
+    console.error('');
+    console.error('Note: Server-side keys are managed by coder-server config');
+    process.exit(1);
+  }
+
+  await setClientConfig(key, value);
+}
+
+async function setClientConfig(key, value) {
+  const configPath = getConfigPathForDisplay();
+  const configDir = path.dirname(configPath);
+
+  // Ensure .coder directory exists
+  await fs.mkdir(configDir, { recursive: true });
+
+  // Load existing config or create new one
+  let config = await loadClientConfig() || {};
+
+  // Update the value
+  config[key] = value;
+
+  // Write back to file
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+
+  // Invalidate cache so next read gets fresh data
+  invalidateConfigCache();
+
+  console.log(`✓ Set ${key} = ${value}`);
+  console.log(`  Location: ${configPath}`);
+}
+
+async function getConfig(key) {
+  if (!key) {
+    console.error('Usage: coder config get <key>');
+    process.exit(1);
+  }
+
+  if (!CLIENT_CONFIG_KEYS.has(key)) {
+    console.error(`Unknown configuration key: ${key}`);
+    console.error('Run "coder config" for a list of available keys');
+    console.error('');
+    console.error('Note: Server-side keys are managed by coder-server config');
+    process.exit(1);
+  }
+
+  const config = await loadClientConfig();
+  const value = config?.[key];
+
+  if (value !== undefined) {
+    console.log(value);
+  } else {
+    console.error(`Key "${key}" not found in configuration`);
+    process.exit(1);
+  }
+}
+
+async function removeConfig(key) {
+  if (!key) {
+    console.error('Usage: coder config remove <key>');
+    process.exit(1);
+  }
+
+  if (!CLIENT_CONFIG_KEYS.has(key)) {
+    console.error(`Unknown configuration key: ${key}`);
+    console.error('Run "coder config" for a list of available keys');
+    console.error('');
+    console.error('Note: Server-side keys are managed by coder-server config');
+    process.exit(1);
+  }
+
+  await removeClientConfig(key);
+}
+
+async function removeClientConfig(key) {
+  const configPath = getConfigPathForDisplay();
+
+  // Load existing config
+  let config = await loadClientConfig();
+  if (!config || config[key] === undefined) {
+    console.error(`Key "${key}" not found in client configuration`);
+    process.exit(1);
+  }
+
+  // Remove the key
+  delete config[key];
+
+  // Write back to file
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+
+  // Invalidate cache so next read gets fresh data
+  invalidateConfigCache();
+
+  console.log(`✓ Removed ${key}`);
+  console.log(`  Location: ${configPath}`);
+}
+
+async function showConfig() {
+  // Show active profile if set
+  const activeProfileName = await getActiveProfileName();
+  if (activeProfileName) {
+    console.log(`=== Active Profile: ${activeProfileName} ===`);
+    console.log('');
+    const profile = await loadProfile(activeProfileName);
+    if (profile) {
+      // Mask API key for display
+      const displayProfile = { ...profile };
+      if (displayProfile.apiKey) {
+        displayProfile.apiKey = displayProfile.apiKey.slice(0, 4) + '****' + displayProfile.apiKey.slice(-4);
+      }
+      console.log(JSON.stringify(displayProfile, null, 2));
+    }
+    console.log('');
+    console.log(`Location: ${getProfilePath(activeProfileName)}`);
+    console.log('');
+    console.log('Tip: Use "coder profile" commands to manage profiles');
+    console.log('');
+  }
+
+  console.log('=== Client Configuration (Legacy) ===');
+  console.log('');
+
+  // Read raw client config (not merged with profile)
+  const clientConfigPath = getConfigPathForDisplay();
+  const clientConfig = await loadRawClientConfig();
+
+  if (clientConfig && Object.keys(clientConfig).length > 0) {
+    // Mask API key for display
+    const displayConfig = { ...clientConfig };
+    if (displayConfig.apiKey) {
+      displayConfig.apiKey = displayConfig.apiKey.slice(0, 4) + '****' + displayConfig.apiKey.slice(-4);
+    }
+    console.log(JSON.stringify(displayConfig, null, 2));
+  } else {
+    console.log('(empty)');
+  }
+  console.log('');
+  console.log(`Location: ${clientConfigPath}`);
+  console.log('');
+  console.log('Note: Server-side configuration is managed by coder-server config');
+}