@profoundlogic/coderflow-cli 0.2.1

package/lib/commands/test.js

@@ -0,0 +1,335 @@
+/**
+ * Command: coder test - Run ephemeral test containers with local state
+ */
+
+import { request } from '../http-client.js';
+import { getDefaultEnvironment, getServerUrl, getApiKey } from '../config.js';
+import { captureAllRepos, validateState } from '../state-capture.js';
+
+/**
+ * Load test definitions from server for the given environment
+ */
+async function loadTestDefinitions(environmentName) {
+  try {
+    const envConfig = await request(`/environments/${environmentName}`);
+    return envConfig.tests || {};
+  } catch (error) {
+    throw new Error(`Failed to load test definitions from server: ${error.message}`);
+  }
+}
+
+/**
+ * Parse command line arguments
+ */
+function parseTestArgs(args) {
+  let testName = null;
+  let environment = null;
+  let customCommand = null;
+  let noLocalState = false;
+  let listTests = false;
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--list') {
+      listTests = true;
+      continue;
+    }
+
+    if (arg === '--no-local-state') {
+      noLocalState = true;
+      continue;
+    }
+
+    if (arg === '--environment' || arg === '--env') {
+      const next = args[index + 1];
+      if (!next) {
+        console.error('Error: --environment requires a value');
+        process.exit(1);
+      }
+      environment = next;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--environment=')) {
+      environment = arg.substring('--environment='.length);
+      continue;
+    }
+
+    if (arg.startsWith('--env=')) {
+      environment = arg.substring('--env='.length);
+      continue;
+    }
+
+    if (arg === '--cmd') {
+      const next = args[index + 1];
+      if (!next) {
+        console.error('Error: --cmd requires a command string');
+        process.exit(1);
+      }
+      customCommand = next;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--cmd=')) {
+      customCommand = arg.substring('--cmd='.length);
+      continue;
+    }
+
+    if (arg.startsWith('--')) {
+      console.error(`Error: Unrecognized option: ${arg}`);
+      process.exit(1);
+    }
+
+    // First non-flag argument is the test name
+    if (!testName) {
+      testName = arg;
+      continue;
+    }
+
+    console.error(`Error: Unexpected argument: ${arg}`);
+    process.exit(1);
+  }
+
+  return { testName, environment, customCommand, noLocalState, listTests };
+}
+
+/**
+ * List available tests for environment
+ */
+async function listAvailableTests(environmentName) {
+  const tests = await loadTestDefinitions(environmentName);
+  const testNames = Object.keys(tests);
+
+  if (testNames.length === 0) {
+    console.log(`No tests defined for environment: ${environmentName}`);
+    console.log(`\nCreate tests.json in: environments/${environmentName}/tests.json`);
+    return;
+  }
+
+  console.log(`Available tests for ${environmentName}:\n`);
+  for (const name of testNames) {
+    const test = tests[name];
+    console.log(`  ${name}`);
+    if (test.description) {
+      console.log(`    ${test.description}`);
+    }
+    // Show command or commands
+    if (test.commands && Array.isArray(test.commands)) {
+      console.log(`    Commands: ${test.commands.length} steps`);
+    } else {
+      console.log(`    Command: ${test.command}`);
+    }
+    if (Array.isArray(test.repos)) {
+      if (test.repos.length === 0) {
+        console.log(`    Repos: none (skip local state)`);
+      } else {
+        console.log(`    Repos: ${test.repos.join(', ')}`);
+      }
+    } else {
+      console.log(`    Repos: all`);
+    }
+    console.log('');
+  }
+}
+
+/**
+ * Run a test in an ephemeral container
+ */
+export async function runTest(args = []) {
+  const { testName, environment, customCommand, noLocalState, listTests } = parseTestArgs(args);
+
+  // Resolve environment
+  let resolvedEnvironment = environment;
+  if (!resolvedEnvironment) {
+    resolvedEnvironment = await getDefaultEnvironment();
+  }
+
+  if (!resolvedEnvironment) {
+    console.error('Error: No environment specified and no default environment configured');
+    console.error('Use: coder test <test-name> --env=<environment>');
+    process.exit(1);
+  }
+
+  // Handle --list
+  if (listTests) {
+    await listAvailableTests(resolvedEnvironment);
+    return;
+  }
+
+  // Load test definitions
+  const tests = await loadTestDefinitions(resolvedEnvironment);
+
+  // Determine command to run
+  let command;
+  let description;
+  let reposFilter; // Optional array of repo names to include
+
+  if (customCommand) {
+    // Custom command
+    command = customCommand;
+    description = 'Custom test command';
+  } else if (testName) {
+    // Named test
+    const test = tests[testName];
+    if (!test) {
+      console.error(`Error: Test "${testName}" not found in environment "${resolvedEnvironment}"`);
+      console.error(`\nAvailable tests: ${Object.keys(tests).join(', ') || 'none'}`);
+      console.error(`\nOr use: coder test --cmd="your command"`);
+      process.exit(1);
+    }
+
+    // Support both 'command' (string) and 'commands' (array)
+    if (test.commands && Array.isArray(test.commands)) {
+      command = test.commands.join(' && ');
+    } else {
+      command = test.command;
+    }
+
+    description = test.description || testName;
+    reposFilter = test.repos; // undefined, array, or empty array
+  } else {
+    console.error('Error: No test name or --cmd specified');
+    console.error('Usage: coder test <test-name> [options]');
+    console.error('   or: coder test --cmd="command" [options]');
+    console.error('   or: coder test --list');
+    process.exit(1);
+  }
+
+  // Show what we're running
+  console.log(`Running test in environment: ${resolvedEnvironment}`);
+  if (testName) {
+    console.log(`Test: ${testName}`);
+  }
+  if (description) {
+    console.log(`Description: ${description}`);
+  }
+  console.log(`Command: ${command}`);
+
+  // Prepare request body
+  const requestBody = {
+    environment: resolvedEnvironment,
+    test_command: command
+  };
+
+  // Apply local state by default (unless --no-local-state)
+  // Also check if test specifies repos: [] (empty array = skip local state)
+  const shouldCaptureState = !noLocalState && !(Array.isArray(reposFilter) && reposFilter.length === 0);
+
+  if (shouldCaptureState) {
+    console.log('\n🔍 Capturing local repository state...');
+
+    try {
+      // Fetch environment config to get repo configurations
+      const envConfig = await request(`/environments/${resolvedEnvironment}`);
+      let repoConfigs = envConfig.repos || [];
+
+      // Filter repos if test specifies which ones to include
+      if (Array.isArray(reposFilter) && reposFilter.length > 0) {
+        const originalCount = repoConfigs.length;
+        repoConfigs = repoConfigs.filter(r => reposFilter.includes(r.name));
+        console.log(`  Filtering to ${repoConfigs.length}/${originalCount} repositories: ${reposFilter.join(', ')}`);
+      }
+
+      if (repoConfigs.length === 0) {
+        console.warn('Warning: No repositories configured for this environment');
+      } else {
+        // Capture state locally on the client side
+        const localState = await captureAllRepos(process.cwd(), repoConfigs);
+
+        // Validate the captured state
+        const validation = validateState(localState);
+        if (!validation.valid) {
+          console.error('Error: Invalid local state captured');
+          validation.errors.forEach(err => console.error(`  - ${err}`));
+          process.exit(1);
+        }
+
+        if (validation.warnings && validation.warnings.length > 0) {
+          validation.warnings.forEach(warn => console.warn(`  Warning: ${warn}`));
+        }
+
+        // Send the captured state JSON to the server
+        requestBody.local_state = localState;
+      }
+    } catch (error) {
+      console.error(`Error capturing local state: ${error.message}`);
+      process.exit(1);
+    }
+  } else if (Array.isArray(reposFilter) && reposFilter.length === 0) {
+    console.log('\n⏭️  Skipping local state (test configured with empty repos array)');
+  }
+
+  // Create test container
+  const data = await request('/test', {
+    method: 'POST',
+    body: JSON.stringify(requestBody)
+  });
+
+  console.log(`\n✓ Test container created`);
+  console.log(`  Container ID: ${data.containerId}`);
+
+  // Display local state info if captured
+  if (data.localState && data.localState.repos_found && data.localState.repos_found.length > 0) {
+    console.log('\n📦 Local State Applied:');
+    console.log(`  Repositories:   ${data.localState.repos_found.join(', ')}`);
+    if (data.localState.repos_missing && data.localState.repos_missing.length > 0) {
+      console.log(`  Missing:        ${data.localState.repos_missing.join(', ')} (using defaults)`);
+    }
+  }
+
+  console.log('\n\n' + '='.repeat(60));
+  console.log('Test Output:');
+  console.log('='.repeat(60) + '\n');
+
+  // Stream logs from container
+  const serverUrl = await getServerUrl();
+  const apiKey = await getApiKey();
+
+  // Use fetch to stream logs
+  const logsUrl = `${serverUrl}/test/${data.containerId}/logs`;
+  const headers = {
+    'Authorization': `Bearer ${apiKey}`
+  };
+
+  try {
+    const response = await fetch(logsUrl, { headers });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    // Stream response body
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const text = decoder.decode(value, { stream: true });
+      process.stdout.write(text);
+    }
+
+    console.log('='.repeat(60));
+
+    // Check final status and exit with proper code
+    const statusCheck = await request(`/test/${data.containerId}/status`).catch(() => null);
+
+    if (statusCheck) {
+      const exitCode = statusCheck.exitCode || 0;
+      console.log(`Exit code: ${exitCode}`);
+      process.exit(exitCode);
+    } else {
+      // Container already removed, assume success
+      console.log('Exit code: 0');
+      process.exit(0);
+    }
+
+  } catch (error) {
+    console.error(`\n✗ Error streaming test output: ${error.message}`);
+    process.exit(1);
+  }
+}

package/lib/config.js

@@ -0,0 +1,378 @@
+import { promises as fs } from 'fs';
+import os from 'os';
+import path from 'path';
+import {
+  getEffectiveConfig,
+  getActiveProfileName,
+  loadProfile,
+  getMainConfigPath,
+  loadMainConfig,
+  saveMainConfig
+} from './profile.js';
+
+let cachedConfig = null;
+let configLoaded = false;
+
+// CLI profile override (set via --profile flag)
+let cliProfileOverride = null;
+
+function getDefaultConfigPath() {
+  return path.join(os.homedir(), '.coder', 'config.json');
+}
+
+function getConfigPath() {
+  return process.env.CODER_CONFIG_PATH || getDefaultConfigPath();
+}
+
+/**
+ * Set the CLI profile override (from --profile flag)
+ * This takes precedence over the activeProfile in config.json
+ */
+export function setCliProfileOverride(profileName) {
+  cliProfileOverride = profileName;
+  invalidateConfigCache();
+}
+
+/**
+ * Get the current CLI profile override
+ */
+export function getCliProfileOverride() {
+  return cliProfileOverride;
+}
+
+/**
+ * Invalidate the config cache (used after external writes)
+ */
+export function invalidateConfigCache() {
+  cachedConfig = null;
+  configLoaded = false;
+}
+
+function sanitizeServerUrl(url) {
+  if (!url) {
+    return url;
+  }
+  return url.endsWith('/') ? url.slice(0, -1) : url;
+}
+
+/**
+ * Load client config with profile support
+ * Returns the merged configuration from profile + legacy config
+ */
+export async function loadClientConfig() {
+  if (configLoaded) {
+    return cachedConfig;
+  }
+
+  try {
+    // Use the new profile-aware config loading
+    cachedConfig = await getEffectiveConfig(cliProfileOverride);
+  } catch (error) {
+    // Fall back to legacy behavior if profile system fails
+    const configPath = getConfigPath();
+    try {
+      const content = await fs.readFile(configPath, 'utf-8');
+      cachedConfig = JSON.parse(content);
+    } catch (readError) {
+      if (readError.code === 'ENOENT') {
+        cachedConfig = null;
+      } else {
+        throw new Error(`Failed to read client config at ${configPath}: ${readError.message}`);
+      }
+    }
+  }
+
+  configLoaded = true;
+  return cachedConfig;
+}
+
+/**
+ * Load raw client config (legacy config.json only, no profile merging)
+ * Used for config management commands
+ */
+export async function loadRawClientConfig() {
+  const configPath = getConfigPath();
+  try {
+    const content = await fs.readFile(configPath, 'utf-8');
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return null;
+    }
+    throw new Error(`Failed to read client config at ${configPath}: ${error.message}`);
+  }
+}
+
+export async function getServerUrl() {
+  if (process.env.CODER_SERVER_URL) {
+    return sanitizeServerUrl(process.env.CODER_SERVER_URL);
+  }
+
+  const config = await loadClientConfig();
+  if (config?.server) {
+    return sanitizeServerUrl(config.server);
+  }
+
+  return 'http://localhost:3000';
+}
+
+export async function getDefaultEnvironment() {
+  // Check client config first
+  const config = await loadClientConfig();
+  if (config?.default_environment) {
+    return config.default_environment;
+  }
+
+  // Fall back to fetching from server
+  try {
+    const { request } = await import('./http-client.js');
+    const environmentsData = await request('/environments');
+    return environmentsData?.default_environment || null;
+  } catch (error) {
+    // If server call fails, fall back to local setup.json if available
+    const setupPath = await getCoderSetupPath();
+    if (setupPath) {
+      try {
+        const setupJsonPath = path.join(setupPath, 'setup.json');
+        const setupContent = await fs.readFile(setupJsonPath, 'utf-8');
+        const setupJson = JSON.parse(setupContent);
+        return setupJson?.default_environment || null;
+      } catch (error) {
+        return null;
+      }
+    }
+    return null;
+  }
+}
+
+export function getConfigPathForDisplay() {
+  return getConfigPath();
+}
+
+/**
+ * Get the path where credentials will be saved (profile or legacy config)
+ */
+export async function getCredentialsPathForDisplay() {
+  const activeProfileName = cliProfileOverride || await getActiveProfileName();
+  if (activeProfileName) {
+    const { getProfilePath } = await import('./profile.js');
+    return getProfilePath(activeProfileName);
+  }
+  return getConfigPath();
+}
+
+/**
+ * Save API key to config file or active profile
+ */
+export async function saveApiKey(apiKey) {
+  // Check if there's an active profile (including CLI override)
+  const activeProfileName = cliProfileOverride || await getActiveProfileName();
+
+  if (activeProfileName) {
+    // Save to active profile
+    const { loadProfile, saveProfile } = await import('./profile.js');
+    const profile = await loadProfile(activeProfileName) || { name: activeProfileName };
+    profile.apiKey = apiKey;
+    await saveProfile(activeProfileName, profile);
+
+    // Invalidate cache so next read gets fresh data
+    invalidateConfigCache();
+    return;
+  }
+
+  // Fall back to legacy config
+  const configPath = getConfigPath();
+  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 loadRawClientConfig() || {};
+
+  // Update API key
+  config.apiKey = apiKey;
+
+  // Write config file
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+  // Update cache
+  invalidateConfigCache();
+}
+
+/**
+ * Get API key from config or environment variable
+ */
+export async function getApiKey() {
+  // Check environment variable first
+  if (process.env.CODER_API_KEY) {
+    return process.env.CODER_API_KEY;
+  }
+
+  // Check config file
+  const config = await loadClientConfig();
+  return config?.apiKey || null;
+}
+
+/**
+ * Clear API key from config file (logout)
+ */
+export async function clearApiKey() {
+  const configPath = getConfigPath();
+
+  let config = await loadRawClientConfig();
+  if (!config) {
+    return; // No config file, nothing to clear
+  }
+
+  // Remove API key
+  delete config.apiKey;
+
+  // Write updated config
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+  // Invalidate cache
+  invalidateConfigCache();
+}
+
+/**
+ * Save coder setup path to config file
+ */
+export async function saveCoderSetupPath(setupPath) {
+  const configPath = getConfigPath();
+  const configDir = path.dirname(configPath);
+
+  // Ensure .coder directory exists
+  await fs.mkdir(configDir, { recursive: true });
+
+  // Load existing config or create new one (use raw to preserve activeProfile)
+  let config = await loadRawClientConfig() || {};
+
+  // Update coder setup path
+  config.coder_setup_path = setupPath;
+
+  // Write config file
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+  // Invalidate cache
+  invalidateConfigCache();
+}
+
+/**
+ * Get coder setup path from config or environment variable
+ */
+export async function getCoderSetupPath() {
+  // Check environment variable first
+  if (process.env.CODER_SETUP_PATH) {
+    return process.env.CODER_SETUP_PATH;
+  }
+
+  // Check config file
+  const config = await loadClientConfig();
+  return config?.coder_setup_path || null;
+}
+
+/**
+ * Save server port to config file
+ */
+export async function saveServerPort(port) {
+  const configPath = getConfigPath();
+  const configDir = path.dirname(configPath);
+
+  // Ensure .coder directory exists
+  await fs.mkdir(configDir, { recursive: true });
+
+  // Load existing config or create new one (use raw to preserve activeProfile)
+  let config = await loadRawClientConfig() || {};
+
+  // Update server port
+  config.server_port = port;
+
+  // Write config file
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+  // Invalidate cache
+  invalidateConfigCache();
+}
+
+/**
+ * Get server port from config or environment variable
+ */
+export async function getServerPort() {
+  // Check environment variable first
+  if (process.env.PORT) {
+    return parseInt(process.env.PORT, 10);
+  }
+
+  // Check config file
+  const config = await loadClientConfig();
+  return config?.server_port || 3000;
+}
+
+/**
+ * Save profound coder path to config file
+ */
+export async function saveProfoundCoderPath(profoundCoderPath) {
+  const configPath = getConfigPath();
+  const configDir = path.dirname(configPath);
+
+  // Ensure .coder directory exists
+  await fs.mkdir(configDir, { recursive: true });
+
+  // Load existing config or create new one (use raw to preserve activeProfile)
+  let config = await loadRawClientConfig() || {};
+
+  // Update profound coder path
+  config.profound_coder_path = profoundCoderPath;
+
+  // Write config file
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+  // Invalidate cache
+  invalidateConfigCache();
+}
+
+/**
+ * Get profound coder path from config or environment variable
+ */
+export async function getProfoundCoderPath() {
+  // Check environment variable first
+  if (process.env.PROFOUND_CODER_PATH) {
+    return process.env.PROFOUND_CODER_PATH;
+  }
+
+  // Check config file
+  const config = await loadClientConfig();
+  return config?.profound_coder_path || null;
+}
+
+/**
+ * Save last container ID to config file
+ */
+export async function saveLastContainerId(containerId) {
+  const configPath = getConfigPath();
+  const configDir = path.dirname(configPath);
+
+  // Ensure .coder directory exists
+  await fs.mkdir(configDir, { recursive: true });
+
+  // Load existing config or create new one (use raw to preserve activeProfile)
+  let config = await loadRawClientConfig() || {};
+
+  // Update last container ID
+  config.last_container_id = containerId;
+
+  // Write config file
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+  // Invalidate cache
+  invalidateConfigCache();
+}
+
+/**
+ * Get last container ID from config
+ */
+export async function getLastContainerId() {
+  const config = await loadClientConfig();
+  return config?.last_container_id || null;
+}