@profoundlogic/coderflow-cli 0.2.1

package/lib/commands/containers.js

@@ -0,0 +1,213 @@
+/**
+ * Command: coder containers - List and manage containers via server API
+ */
+
+import { createInterface } from 'readline';
+import { request } from '../http-client.js';
+
+function parseCleanArgs(args) {
+  const options = {
+    olderThan: null,
+    stoppedOnly: false,
+    dryRun: false,
+    skipConfirm: false
+  };
+
+  for (const arg of args) {
+    if (arg === '--dry-run') {
+      options.dryRun = true;
+    } else if (arg === '--yes' || arg === '-y') {
+      options.skipConfirm = true;
+    } else if (arg === '--stopped') {
+      options.stoppedOnly = true;
+    } else if (arg.startsWith('--older-than=')) {
+      const value = arg.substring('--older-than='.length);
+      const match = value.match(/^(\d+)d$/);
+      if (match) {
+        options.olderThan = parseInt(match[1], 10);
+      } else {
+        console.error('Error: --older-than must be in format: Xd (e.g., 7d, 30d)');
+        process.exit(1);
+      }
+    } else {
+      console.error(`Error: Unknown option: ${arg}`);
+      process.exit(1);
+    }
+  }
+
+  return options;
+}
+
+async function confirm(message) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(message, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+function formatAge(createdAt) {
+  if (!createdAt) {
+    return 'unknown';
+  }
+  const createdDate = new Date(createdAt);
+  const diffMs = Date.now() - createdDate.getTime();
+  const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+  if (diffHours < 24) {
+    return `${diffHours}h ago`;
+  }
+  const diffDays = Math.floor(diffHours / 24);
+  return `${diffDays}d ago`;
+}
+
+function filterContainers(containers, options) {
+  return containers.filter((container) => {
+    if (options.stoppedOnly && container.status === 'running') {
+      return false;
+    }
+
+    if (options.olderThan !== null && container.createdAt) {
+      const createdDate = new Date(container.createdAt);
+      const ageInDays = (Date.now() - createdDate.getTime()) / (1000 * 60 * 60 * 24);
+      if (ageInDays < options.olderThan) {
+        return false;
+      }
+    }
+
+    return true;
+  });
+}
+
+async function fetchContainers() {
+  const data = await request('/containers');
+  return data.containers || [];
+}
+
+async function listContainers() {
+  console.log('Fetching Coder containers...\n');
+
+  const containers = await fetchContainers();
+
+  if (containers.length === 0) {
+    console.log('No Coder containers found.');
+    return;
+  }
+
+  console.log(`Found ${containers.length} container(s):\n`);
+
+  for (const container of containers) {
+    const statusIcon = container.status === 'running' ? '▶' : '■';
+    console.log(`  ${statusIcon} ${container.name} (${container.containerId})`);
+    console.log(`    Status:  ${container.status}`);
+    if (container.environment) {
+      console.log(`    Env:     ${container.environment}`);
+    }
+    if (container.createdAt) {
+      console.log(`    Created: ${new Date(container.createdAt).toLocaleString()} (${formatAge(container.createdAt)})`);
+    }
+    console.log('');
+  }
+}
+
+async function deleteContainer(container) {
+  await request(`/containers/${container.name}`, {
+    method: 'DELETE'
+  });
+}
+
+async function cleanContainers(args) {
+  const options = parseCleanArgs(args);
+
+  console.log('Fetching Coder containers...\n');
+
+  const allContainers = await fetchContainers();
+
+  if (allContainers.length === 0) {
+    console.log('No Coder containers found. Nothing to clean.');
+    return;
+  }
+
+  const containersToDelete = filterContainers(allContainers, options);
+
+  if (containersToDelete.length === 0) {
+    console.log('No containers match the specified criteria. Nothing to clean.');
+    return;
+  }
+
+  console.log(`Found ${containersToDelete.length} container(s) to clean:\n`);
+
+  for (const container of containersToDelete) {
+    const statusIcon = container.status === 'running' ? '▶' : '■';
+    console.log(`  ${statusIcon} ${container.name} (${container.containerId})`);
+    if (container.createdAt) {
+      console.log(`    Created: ${new Date(container.createdAt).toLocaleString()} (${formatAge(container.createdAt)})`);
+    }
+    console.log('');
+  }
+
+  const filters = [];
+  if (options.stoppedOnly) {
+    filters.push('stopped only');
+  }
+  if (options.olderThan !== null) {
+    filters.push(`older than ${options.olderThan} days`);
+  }
+  if (filters.length > 0) {
+    console.log(`Filters: ${filters.join(', ')}\n`);
+  }
+
+  if (options.dryRun) {
+    console.log('✓ Dry run complete. No containers were deleted.');
+    console.log('Run without --dry-run to actually delete these containers.');
+    return;
+  }
+
+  if (!options.skipConfirm) {
+    const shouldDelete = await confirm(`Delete ${containersToDelete.length} container(s)? [y/N] `);
+    if (!shouldDelete) {
+      console.log('Cancelled. No containers were deleted.');
+      return;
+    }
+  }
+
+  let deletedCount = 0;
+  let errorCount = 0;
+
+  for (const container of containersToDelete) {
+    try {
+      await deleteContainer(container);
+      deletedCount += 1;
+    } catch (error) {
+      console.error(`✗ Failed to delete ${container.name}: ${error.message}`);
+      errorCount += 1;
+    }
+  }
+
+  console.log(`\n✓ Cleanup complete`);
+  console.log(`  Deleted: ${deletedCount} container(s)`);
+  if (errorCount > 0) {
+    console.log(`  Errors:  ${errorCount} container(s)`);
+  }
+}
+
+export async function handleContainers(args = []) {
+  const subcommand = args[0];
+
+  if (subcommand === 'clean') {
+    await cleanContainers(args.slice(1));
+  } else if (!subcommand) {
+    await listContainers();
+  } else {
+    console.error(`Error: Unknown subcommand: ${subcommand}`);
+    console.error('Usage: coder containers [clean]');
+    console.error('  coder containers              # List all containers');
+    console.error('  coder containers clean        # Clean containers');
+    process.exit(1);
+  }
+}

package/lib/commands/discard.js

@@ -0,0 +1,167 @@
+/**
+ * Command: coder discard - Discard all uncommitted changes from local repos
+ */
+
+import { request } from '../http-client.js';
+import readline from 'readline';
+
+export async function discardChanges(args) {
+  const flags = parseFlags(args);
+
+  // Get environment (from flag or default from server)
+  let environment = flags.env;
+  if (!environment) {
+    // Get default environment from server
+    try {
+      const envList = await request('/environments');
+      environment = envList.default_environment;
+    } catch (error) {
+      console.error('Error: Failed to get default environment from server');
+      console.error('Usage: coder discard [--env=<environment>] [--yes]');
+      process.exit(1);
+    }
+  }
+
+  if (!environment) {
+    console.error('Error: No environment specified and no default environment configured on server');
+    console.error('Usage: coder discard [--env=<environment>] [--yes]');
+    process.exit(1);
+  }
+
+  console.log(`Discarding changes in environment: ${environment}\n`);
+
+  // Get repos from environment configuration
+  const envData = await request(`/environments/${environment}`);
+
+  if (!envData.repos || envData.repos.length === 0) {
+    console.log('No repositories configured for this environment.');
+    return;
+  }
+
+  // Check which repos have changes (using paths from environment config)
+  const { existsSync } = await import('fs');
+  const { execSync } = await import('child_process');
+
+  const reposWithChanges = [];
+  for (const repo of envData.repos) {
+    // Use repo.path if specified, otherwise use repo.name (same logic as server patches endpoint)
+    const localPath = repo.path || repo.name;
+    const repoPath = `./${localPath}`;
+
+    // Check if repo exists
+    if (!existsSync(repoPath)) {
+      continue;
+    }
+
+    try {
+      // Check if repo has changes (staged, unstaged, or untracked)
+      const status = execSync(`git -C ${repoPath} status --porcelain`, { encoding: 'utf8', stdio: 'pipe' });
+      if (status.trim().length > 0) {
+        reposWithChanges.push({ ...repo, localPath, repoPath });
+      }
+    } catch (error) {
+      // Skip repos with git errors
+      continue;
+    }
+  }
+
+  if (reposWithChanges.length === 0) {
+    console.log('No repositories with uncommitted changes found.\n');
+    return;
+  }
+
+  console.log(`Found ${reposWithChanges.length} ${reposWithChanges.length === 1 ? 'repository' : 'repositories'} with changes:\n`);
+
+  // List repos with changes
+  for (const repo of reposWithChanges) {
+    console.log(`  - ${repo.name} (${repo.localPath})`);
+  }
+
+  // Confirm before discarding
+  if (!flags.yes) {
+    console.log('\nThis will:');
+    console.log('  1. Unstage all changes (git reset HEAD)');
+    console.log('  2. Discard all uncommitted changes (git restore .)');
+    console.log('  3. Remove untracked files (git clean -fd)');
+    console.log('\n⚠️  WARNING: This action cannot be undone!\n');
+
+    const answer = await prompt('Continue? [y/N] ');
+    if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+      console.log('Cancelled.');
+      return;
+    }
+  }
+
+  console.log('');
+
+  // Discard changes in each repo
+  for (const repo of reposWithChanges) {
+    console.log(`📦 ${repo.name}`);
+
+    try {
+      // 1. Unstage all changes
+      try {
+        execSync(`git -C ${repo.repoPath} reset HEAD`, { stdio: 'pipe' });
+      } catch (error) {
+        // Ignore errors - might not have staged changes
+      }
+
+      // 2. Discard all uncommitted changes
+      execSync(`git -C ${repo.repoPath} restore .`, { stdio: 'pipe' });
+
+      // 3. Remove untracked files and directories
+      execSync(`git -C ${repo.repoPath} clean -fd`, { stdio: 'pipe' });
+
+      console.log(`   ✓ Changes discarded successfully\n`);
+    } catch (error) {
+      // Try fallback method for older git versions
+      try {
+        execSync(`git -C ${repo.repoPath} checkout -- .`, { stdio: 'pipe' });
+        execSync(`git -C ${repo.repoPath} clean -fd`, { stdio: 'pipe' });
+        console.log(`   ✓ Changes discarded successfully\n`);
+      } catch (fallbackError) {
+        console.log(`   ✗ Failed to discard changes: ${error.message}`);
+        console.log(`     You may need to discard manually\n`);
+      }
+    }
+  }
+
+  console.log('✓ Discard complete\n');
+}
+
+/**
+ * Parse command line flags
+ */
+function parseFlags(args) {
+  const flags = {
+    yes: false,
+    env: null
+  };
+
+  for (const arg of args) {
+    if (arg === '--yes' || arg === '-y') {
+      flags.yes = true;
+    } else if (arg.startsWith('--env=')) {
+      flags.env = arg.substring('--env='.length);
+    }
+  }
+
+  return flags;
+}
+
+/**
+ * Simple prompt for user input
+ */
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}

package/lib/commands/interactive.js

@@ -0,0 +1,292 @@
+/**
+ * Command: coder start <environment> - Start interactive container
+ * Command: coder shell <environment> - Start interactive shell
+ */
+
+import { request } from '../http-client.js';
+import { getDefaultEnvironment, saveLastContainerId } from '../config.js';
+import { connectTerminal } from '../terminal-client.js';
+
+function parseEnvPair(input) {
+  const [rawKey, ...rest] = input.split('=');
+  if (!rawKey || rest.length === 0) {
+    return null;
+  }
+  const key = rawKey.trim();
+  const value = rest.join('=').trim();
+  if (!key || !value) {
+    return null;
+  }
+  return { key, value };
+}
+
+function parseKeyValue(pair) {
+  const [rawKey, ...rest] = pair.split('=');
+  if (!rawKey || rest.length === 0) {
+    return null;
+  }
+  const key = rawKey.trim();
+  const value = rest.join('=').trim();
+  if (!key || !value) {
+    return null;
+  }
+  return { key, value };
+}
+
+export async function startInteractive(args = []) {
+  let environment = null;
+  let noAttach = false;
+  let startShell = false;
+  let withLocalState = false;
+  const envVars = {}; // Environment variables to pass to container
+  const branches = {}; // Branch selections
+
+  // Parse arguments
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--no-attach') {
+      noAttach = true;
+    } else if (arg === '--shell') {
+      startShell = true;
+    } else if (arg === '--with-local-state') {
+      withLocalState = true;
+    } else if (arg === '--branch') {
+      const next = args[index + 1];
+      if (!next) {
+        console.error('Error: --branch requires REPO=BRANCH or BRANCH');
+        process.exit(1);
+      }
+      const parsed = parseKeyValue(next);
+      if (parsed) {
+        // Format: --branch profoundjs=feature-xyz
+        branches[parsed.key] = parsed.value;
+      } else {
+        // Format: --branch feature-xyz (will be applied to first selectable repo)
+        branches._default = next.trim();
+      }
+      index += 1; // Skip value token
+    } else if (arg.startsWith('--branch=')) {
+      const pair = arg.substring('--branch='.length);
+      const parsed = parseKeyValue(pair);
+      if (parsed) {
+        // Format: --branch=profoundjs=feature-xyz
+        branches[parsed.key] = parsed.value;
+      } else {
+        // Format: --branch=feature-xyz (will be applied to first selectable repo)
+        branches._default = pair.trim();
+      }
+    } else if (arg === '--agent') {
+      const next = args[index + 1];
+      if (!next) {
+        console.error('Error: --agent requires a value (claude or codex)');
+        process.exit(1);
+      }
+      envVars.CODER_AGENT = next;
+      index += 1;
+    } else if (arg.startsWith('--agent=')) {
+      envVars.CODER_AGENT = arg.substring('--agent='.length);
+    } else if (arg === '--env') {
+      const next = args[index + 1];
+      if (!next) {
+        console.error('Error: --env requires KEY=VALUE');
+        process.exit(1);
+      }
+      const parsed = parseEnvPair(next);
+      if (!parsed) {
+        console.error(`Error: Invalid --env value: ${next}`);
+        console.error('Expected: --env KEY=VALUE');
+        process.exit(1);
+      }
+      envVars[parsed.key] = parsed.value;
+      index += 1;
+    } else if (arg.startsWith('--env=')) {
+      const parsed = parseEnvPair(arg.substring('--env='.length));
+      if (!parsed) {
+        console.error(`Error: Invalid --env format: ${arg}`);
+        console.error('Expected: --env KEY=VALUE');
+        process.exit(1);
+      }
+      envVars[parsed.key] = parsed.value;
+    } else if (arg === '--environment') {
+      const next = args[index + 1];
+      if (!next) {
+        console.error('Error: --environment requires a value');
+        process.exit(1);
+      }
+      environment = next;
+      index += 1;
+    } else if (arg.startsWith('--environment=')) {
+      environment = arg.substring('--environment='.length);
+    } else if (!environment && !arg.startsWith('--')) {
+      environment = arg;
+    }
+  }
+
+  if (!environment) {
+    const configDefault = await getDefaultEnvironment();
+    environment = configDefault || null;
+  }
+
+  if (environment) {
+    console.log(`Starting interactive session with environment: ${environment}`);
+  } else {
+    console.log('Starting interactive session (no environment specified – relying on server default)');
+  }
+
+  // Display agent override if specified
+  if (envVars.CODER_AGENT) {
+    console.log(`Agent override: ${envVars.CODER_AGENT}`);
+  }
+
+  // Display other environment variables if any
+  const otherEnvVars = Object.entries(envVars).filter(([k]) => k !== 'CODER_AGENT');
+  if (otherEnvVars.length > 0) {
+    console.log(`Environment variables: ${otherEnvVars.map(([k, v]) => `${k}=${v}`).join(', ')}`);
+  }
+
+  // Display branch selections if any
+  if (Object.keys(branches).length > 0) {
+    console.log(`Branch selections: ${Object.entries(branches).map(([k, v]) => `${k}=${v}`).join(', ')}`);
+  }
+
+  const requestBody = {};
+  if (environment) {
+    requestBody.environment = environment;
+  }
+  if (Object.keys(envVars).length > 0) {
+    requestBody.env_vars = envVars;
+  }
+  if (Object.keys(branches).length > 0) {
+    requestBody.branches = branches;
+  }
+
+  // Capture local repository state if requested
+  if (withLocalState) {
+    console.log('\n🔍 Capturing local repository state...');
+    requestBody.capture_local_state = true;
+    requestBody.source_path = process.cwd();
+  }
+
+  const data = await request('/containers/interactive', {
+    method: 'POST',
+    body: JSON.stringify(requestBody)
+  });
+
+  console.log(`\n✓ Container started successfully`);
+  console.log(`  Container ID:   ${data.containerId}`);
+  console.log(`  Environment:    ${data.environment}`);
+  console.log(`  Image:          ${data.image}`);
+  console.log(`  Default Agent:  ${data.defaultAgent}`);
+
+  // Show local state summary if it was captured
+  if (data.localState) {
+    console.log('');
+    console.log('📦 Local State Applied:');
+    console.log(`  Repositories:   ${data.localState.repos_found.join(', ')}`);
+
+    // Show details for each repo
+    for (const repo of data.localState.repos_found) {
+      const repoState = data.localState.repositories[repo];
+      if (repoState) {
+        const details = [];
+        if (repoState.current_branch) {
+          details.push(`branch: ${repoState.current_branch}`);
+        }
+        if (repoState.unstaged) {
+          const fileCount = (repoState.unstaged.match(/^diff --git/gm) || []).length;
+          details.push(`${fileCount} unstaged`);
+        }
+        if (repoState.staged) {
+          const fileCount = (repoState.staged.match(/^diff --git/gm) || []).length;
+          details.push(`${fileCount} staged`);
+        }
+        if (repoState.untracked_files && Object.keys(repoState.untracked_files).length > 0) {
+          details.push(`${Object.keys(repoState.untracked_files).length} untracked`);
+        }
+        if (details.length > 0) {
+          console.log(`    ${repo}: ${details.join(', ')}`);
+        }
+      }
+    }
+
+    if (data.localState.repos_missing && data.localState.repos_missing.length > 0) {
+      console.log(`  Missing:        ${data.localState.repos_missing.join(', ')} (using defaults)`);
+    }
+
+    console.log('  ✅ State capture complete');
+
+    // Give container time to apply state (it runs during startup)
+    console.log('  ⏳ Waiting for state application...');
+
+    // Poll for summary with retries (up to 30 seconds for large workspaces)
+    let summaryCheck = null;
+    const maxRetries = 30; // 30 seconds total
+    for (let i = 0; i < maxRetries; i++) {
+      try {
+        summaryCheck = await request(`/containers/${data.containerId}/local-state-summary`);
+        break; // Got the summary, exit loop
+      } catch (err) {
+        // Summary not ready yet, wait and retry
+        if (i < maxRetries - 1) {
+          await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1 second between retries
+        }
+      }
+    }
+
+    // Display summary results
+    if (summaryCheck && summaryCheck.has_warnings) {
+      console.log('');
+      console.log('  ⚠️  State applied with warnings:');
+      for (const warning of summaryCheck.warnings || []) {
+        console.log(`     ${warning}`);
+      }
+      console.log('');
+      console.log('  💡 Check git status in container to verify state');
+    } else if (summaryCheck) {
+      console.log('  ✅ State applied successfully');
+    } else {
+      // Timed out waiting for summary
+      console.log('  ⚠️  Timed out waiting for state application');
+      console.log('  💡 Check /task-output/log.txt in container for details');
+    }
+  }
+
+  // Save this as the last container
+  await saveLastContainerId(data.containerId);
+
+  if (noAttach) {
+    console.log('\nTo connect manually, run:');
+    console.log(`  coder attach`);
+    return;
+  }
+
+  const cmd = startShell ? null : data.shellCommand;
+  const descriptiveAction = startShell ? 'Connecting to shell' : `Starting ${data.defaultAgent}`;
+
+  console.log(`\n${descriptiveAction}...\n`);
+
+  try {
+    const exitCode = await connectTerminal(data.containerId, cmd);
+
+    if (exitCode === 0) {
+      console.log(`\n✓ Disconnected from container ${data.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 remains running.');
+    console.log('\nTo connect manually, run:');
+    console.log(`  coder attach`);
+    return;
+  }
+
+  console.log('\nContainer is still running and will auto-cleanup after 2 hours of inactivity.');
+  console.log(`Container ID: ${data.containerId}`);
+  console.log('\nTo reconnect to this container:');
+  console.log(`  coder attach`);
+  console.log('\nTo start a fresh session:');
+  console.log(`  coder start${environment ? ' ' + environment : ' <environment>'}`);
+}