@profoundlogic/coderflow-cli 0.2.1

package/lib/commands/profile.js

@@ -0,0 +1,539 @@
+/**
+ * Profile command - manage CLI configuration profiles
+ *
+ * Profiles allow switching between different CoderFlow server configurations
+ * (e.g., my-server, team-name, project-x) without changing environment variables.
+ */
+
+import { promises as fs } from 'fs';
+import readline from 'readline';
+import {
+  listProfiles,
+  loadProfile,
+  saveProfile,
+  deleteProfile,
+  getActiveProfileName,
+  setActiveProfile,
+  profileExists,
+  isValidProfileName,
+  getProfileConfigKeys,
+  createProfileFromLegacyConfig,
+  getProfilePath,
+  loadMainConfig
+} from '../profile.js';
+import { invalidateConfigCache } from '../config.js';
+
+/**
+ * Handle profile command
+ * Usage:
+ *   coder profile list              List all profiles
+ *   coder profile show [name]       Show profile details
+ *   coder profile create <name>     Create new profile
+ *   coder profile switch <name>     Switch active profile
+ *   coder profile delete <name>     Delete a profile
+ *   coder profile copy <src> <dest> Copy a profile
+ *   coder profile set <key> <value> Set a value in active profile
+ *   coder profile get <key>         Get a value from active profile
+ */
+export async function handleProfile(args) {
+  const subcommand = args[0];
+
+  if (!subcommand) {
+    showProfileHelp();
+    process.exit(1);
+  }
+
+  try {
+    switch (subcommand) {
+      case 'list':
+      case 'ls':
+        await listProfilesCommand();
+        break;
+
+      case 'show':
+        await showProfileCommand(args[1]);
+        break;
+
+      case 'create':
+      case 'add':
+        await createProfileCommand(args[1], args.slice(2));
+        break;
+
+      case 'switch':
+      case 'use':
+        await switchProfileCommand(args[1]);
+        break;
+
+      case 'delete':
+      case 'remove':
+      case 'rm':
+        await deleteProfileCommand(args[1]);
+        break;
+
+      case 'copy':
+      case 'cp':
+        await copyProfileCommand(args[1], args[2]);
+        break;
+
+      case 'set':
+        await setProfileValueCommand(args[1], args[2]);
+        break;
+
+      case 'get':
+        await getProfileValueCommand(args[1]);
+        break;
+
+      case 'current':
+        await showCurrentProfile();
+        break;
+
+      case 'migrate':
+        await migrateToProfile(args[1]);
+        break;
+
+      default:
+        console.error(`Unknown subcommand: ${subcommand}`);
+        showProfileHelp();
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+function showProfileHelp() {
+  console.log(`
+Usage: coder profile <command> [options]
+
+Commands:
+  list                    List all profiles (shows active profile)
+  show [name]             Show profile details (active if no name given)
+  create <name>           Create a new profile
+  switch <name>           Switch to a different profile
+  delete <name>           Delete a profile
+  copy <source> <dest>    Copy an existing profile
+  set <key> <value>       Set a value in the active profile
+  get <key>               Get a value from the active profile
+  current                 Show the current active profile name
+  migrate <name>          Create profile from current legacy config
+
+Profile Keys:
+  server                  Server URL (e.g., http://localhost:3000)
+  apiKey                  API authentication key
+  default_environment     Default environment name
+  coder_setup_path        Path to coder-setup directory
+  server_port             Server port number
+  profound_coder_path     Path to profound-coder directory
+
+Examples:
+  coder profile list
+  coder profile create my-server
+  coder profile switch my-server
+  coder profile set server https://coderflow.example.com
+  coder profile show my-server
+  coder profile copy my-server project-x
+  coder profile delete project-x
+
+Using Profiles:
+  - Use 'coder profile switch <name>' to change the active profile
+  - Use 'coder --profile=<name> <command>' to use a profile for one command
+  - Set CODER_PROFILE=<name> environment variable to override
+`);
+}
+
+async function listProfilesCommand() {
+  const profiles = await listProfiles();
+  const activeProfile = await getActiveProfileName();
+
+  if (profiles.length === 0) {
+    console.log('No profiles found.');
+    console.log('');
+    console.log('Create one with:');
+    console.log('  coder profile create <name>');
+    console.log('');
+    console.log('Or migrate your current config:');
+    console.log('  coder profile migrate default');
+    return;
+  }
+
+  console.log('Profiles:');
+  console.log('');
+
+  for (const name of profiles) {
+    const isActive = name === activeProfile;
+    const marker = isActive ? '*' : ' ';
+    const profile = await loadProfile(name);
+    const server = profile?.server || '(not set)';
+
+    console.log(`  ${marker} ${name}`);
+    console.log(`      Server: ${server}`);
+  }
+
+  console.log('');
+  if (activeProfile) {
+    console.log(`Active profile: ${activeProfile}`);
+  } else {
+    console.log('No active profile (using legacy config)');
+  }
+}
+
+async function showProfileCommand(profileName) {
+  // If no name provided, show active profile
+  if (!profileName) {
+    profileName = await getActiveProfileName();
+    if (!profileName) {
+      console.log('No active profile set.');
+      console.log('');
+      console.log('Use "coder profile list" to see available profiles.');
+      console.log('Use "coder profile switch <name>" to set an active profile.');
+      return;
+    }
+  }
+
+  const profile = await loadProfile(profileName);
+  if (!profile) {
+    console.error(`Profile '${profileName}' not found.`);
+    console.error('');
+    console.error('Use "coder profile list" to see available profiles.');
+    process.exit(1);
+  }
+
+  const activeProfile = await getActiveProfileName();
+  const isActive = profileName === activeProfile;
+
+  console.log(`Profile: ${profileName}${isActive ? ' (active)' : ''}`);
+  console.log(`Location: ${getProfilePath(profileName)}`);
+  console.log('');
+  console.log('Settings:');
+
+  for (const key of getProfileConfigKeys()) {
+    const value = profile[key];
+    if (value !== undefined) {
+      // Mask API key for security
+      const displayValue = key === 'apiKey' ? maskApiKey(value) : value;
+      console.log(`  ${key}: ${displayValue}`);
+    }
+  }
+}
+
+function maskApiKey(apiKey) {
+  if (!apiKey || apiKey.length < 8) {
+    return '****';
+  }
+  return apiKey.slice(0, 4) + '****' + apiKey.slice(-4);
+}
+
+async function createProfileCommand(profileName, extraArgs) {
+  if (!profileName) {
+    console.error('Usage: coder profile create <name>');
+    process.exit(1);
+  }
+
+  if (!isValidProfileName(profileName)) {
+    console.error(`Invalid profile name: ${profileName}`);
+    console.error('Profile names can only contain letters, numbers, hyphens, and underscores.');
+    process.exit(1);
+  }
+
+  if (await profileExists(profileName)) {
+    console.error(`Profile '${profileName}' already exists.`);
+    console.error('Use "coder profile delete" first, or choose a different name.');
+    process.exit(1);
+  }
+
+  // Parse extra arguments for initial values (--server=..., --apiKey=..., etc.)
+  const initialValues = parseProfileArgs(extraArgs);
+
+  // Create profile with initial values
+  const profileData = {
+    name: profileName,
+    ...initialValues
+  };
+
+  await saveProfile(profileName, profileData);
+
+  console.log(`Created profile: ${profileName}`);
+  console.log(`Location: ${getProfilePath(profileName)}`);
+  console.log('');
+
+  if (Object.keys(initialValues).length > 0) {
+    console.log('Initial settings:');
+    for (const [key, value] of Object.entries(initialValues)) {
+      const displayValue = key === 'apiKey' ? maskApiKey(value) : value;
+      console.log(`  ${key}: ${displayValue}`);
+    }
+    console.log('');
+  }
+
+  console.log('To configure this profile:');
+  console.log(`  coder profile switch ${profileName}`);
+  console.log(`  coder profile set server <url>`);
+  console.log(`  coder profile set apiKey <key>`);
+}
+
+function parseProfileArgs(args) {
+  const values = {};
+  const validKeys = new Set(getProfileConfigKeys());
+
+  for (const arg of args) {
+    if (arg.startsWith('--')) {
+      const equalIndex = arg.indexOf('=');
+      if (equalIndex > 2) {
+        const key = arg.slice(2, equalIndex);
+        const value = arg.slice(equalIndex + 1);
+        if (validKeys.has(key)) {
+          values[key] = value;
+        }
+      }
+    }
+  }
+
+  return values;
+}
+
+async function switchProfileCommand(profileName) {
+  if (!profileName) {
+    // No name provided - show current profile
+    const current = await getActiveProfileName();
+    if (current) {
+      console.log(`Current profile: ${current}`);
+    } else {
+      console.log('No active profile set (using legacy config)');
+    }
+    console.log('');
+    console.log('Usage: coder profile switch <name>');
+    return;
+  }
+
+  if (!await profileExists(profileName)) {
+    console.error(`Profile '${profileName}' not found.`);
+    console.error('');
+    console.error('Available profiles:');
+    const profiles = await listProfiles();
+    if (profiles.length === 0) {
+      console.error('  (none)');
+    } else {
+      for (const name of profiles) {
+        console.error(`  - ${name}`);
+      }
+    }
+    process.exit(1);
+  }
+
+  await setActiveProfile(profileName);
+  invalidateConfigCache();
+
+  const profile = await loadProfile(profileName);
+  console.log(`Switched to profile: ${profileName}`);
+  if (profile?.server) {
+    console.log(`Server: ${profile.server}`);
+  }
+}
+
+async function deleteProfileCommand(profileName) {
+  if (!profileName) {
+    console.error('Usage: coder profile delete <name>');
+    process.exit(1);
+  }
+
+  if (!await profileExists(profileName)) {
+    console.error(`Profile '${profileName}' not found.`);
+    process.exit(1);
+  }
+
+  // Check if this is the active profile
+  const activeProfile = await getActiveProfileName();
+  if (profileName === activeProfile) {
+    console.log(`Warning: '${profileName}' is the current active profile.`);
+
+    // Prompt for confirmation
+    const confirmed = await promptConfirmation('Delete this profile?');
+    if (!confirmed) {
+      console.log('Cancelled.');
+      return;
+    }
+
+    // Clear active profile
+    await setActiveProfile(null);
+    invalidateConfigCache();
+  }
+
+  await deleteProfile(profileName);
+  console.log(`Deleted profile: ${profileName}`);
+}
+
+async function copyProfileCommand(sourceName, destName) {
+  if (!sourceName || !destName) {
+    console.error('Usage: coder profile copy <source> <destination>');
+    process.exit(1);
+  }
+
+  if (!isValidProfileName(destName)) {
+    console.error(`Invalid profile name: ${destName}`);
+    console.error('Profile names can only contain letters, numbers, hyphens, and underscores.');
+    process.exit(1);
+  }
+
+  const sourceProfile = await loadProfile(sourceName);
+  if (!sourceProfile) {
+    console.error(`Source profile '${sourceName}' not found.`);
+    process.exit(1);
+  }
+
+  if (await profileExists(destName)) {
+    console.error(`Destination profile '${destName}' already exists.`);
+    console.error('Delete it first or choose a different name.');
+    process.exit(1);
+  }
+
+  // Copy profile data
+  const newProfile = { ...sourceProfile, name: destName };
+  await saveProfile(destName, newProfile);
+
+  console.log(`Copied profile '${sourceName}' to '${destName}'`);
+}
+
+async function setProfileValueCommand(key, value) {
+  if (!key || value === undefined) {
+    console.error('Usage: coder profile set <key> <value>');
+    console.error('');
+    console.error('Available keys:');
+    for (const k of getProfileConfigKeys()) {
+      console.error(`  - ${k}`);
+    }
+    process.exit(1);
+  }
+
+  const validKeys = new Set(getProfileConfigKeys());
+  if (!validKeys.has(key)) {
+    console.error(`Unknown key: ${key}`);
+    console.error('');
+    console.error('Available keys:');
+    for (const k of getProfileConfigKeys()) {
+      console.error(`  - ${k}`);
+    }
+    process.exit(1);
+  }
+
+  const activeProfileName = await getActiveProfileName();
+  if (!activeProfileName) {
+    console.error('No active profile set.');
+    console.error('');
+    console.error('Either:');
+    console.error('  1. Switch to a profile: coder profile switch <name>');
+    console.error('  2. Create a new profile: coder profile create <name>');
+    console.error('  3. Use legacy config: coder config set <key> <value>');
+    process.exit(1);
+  }
+
+  const profile = await loadProfile(activeProfileName) || { name: activeProfileName };
+  profile[key] = value;
+  await saveProfile(activeProfileName, profile);
+  invalidateConfigCache();
+
+  const displayValue = key === 'apiKey' ? maskApiKey(value) : value;
+  console.log(`Set ${key} = ${displayValue} in profile '${activeProfileName}'`);
+}
+
+async function getProfileValueCommand(key) {
+  if (!key) {
+    console.error('Usage: coder profile get <key>');
+    process.exit(1);
+  }
+
+  const validKeys = new Set(getProfileConfigKeys());
+  if (!validKeys.has(key)) {
+    console.error(`Unknown key: ${key}`);
+    process.exit(1);
+  }
+
+  const activeProfileName = await getActiveProfileName();
+  if (!activeProfileName) {
+    console.error('No active profile set.');
+    process.exit(1);
+  }
+
+  const profile = await loadProfile(activeProfileName);
+  if (!profile) {
+    console.error(`Profile '${activeProfileName}' not found.`);
+    process.exit(1);
+  }
+
+  const value = profile[key];
+  if (value === undefined) {
+    console.error(`Key '${key}' not set in profile '${activeProfileName}'`);
+    process.exit(1);
+  }
+
+  // Don't mask for get command - user wants the actual value
+  console.log(value);
+}
+
+async function showCurrentProfile() {
+  const activeProfile = await getActiveProfileName();
+
+  if (process.env.CODER_PROFILE) {
+    console.log(`${activeProfile} (from CODER_PROFILE env var)`);
+  } else if (activeProfile) {
+    console.log(activeProfile);
+  } else {
+    console.log('(none)');
+  }
+}
+
+async function migrateToProfile(profileName) {
+  if (!profileName) {
+    console.error('Usage: coder profile migrate <name>');
+    console.error('');
+    console.error('This will create a new profile from your current legacy config.');
+    process.exit(1);
+  }
+
+  if (!isValidProfileName(profileName)) {
+    console.error(`Invalid profile name: ${profileName}`);
+    process.exit(1);
+  }
+
+  if (await profileExists(profileName)) {
+    console.error(`Profile '${profileName}' already exists.`);
+    process.exit(1);
+  }
+
+  const result = await createProfileFromLegacyConfig(profileName);
+  if (!result) {
+    console.log('No legacy configuration found to migrate.');
+    console.log('');
+    console.log('Create a new profile with:');
+    console.log(`  coder profile create ${profileName}`);
+    return;
+  }
+
+  console.log(`Created profile '${profileName}' from legacy config.`);
+  console.log('');
+  console.log('Migrated settings:');
+  for (const [key, value] of Object.entries(result)) {
+    if (key !== 'name') {
+      const displayValue = key === 'apiKey' ? maskApiKey(value) : value;
+      console.log(`  ${key}: ${displayValue}`);
+    }
+  }
+
+  console.log('');
+  console.log('To use this profile:');
+  console.log(`  coder profile switch ${profileName}`);
+}
+
+async function promptConfirmation(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(`${message} [y/N] `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}

package/lib/commands/reject.js

@@ -0,0 +1,53 @@
+/**
+ * Command: coder reject - Reject task results
+ */
+
+import { request } from '../http-client.js';
+
+function parseRejectArgs(args = []) {
+  const options = {
+    taskId: null,
+    cleanup: false
+  };
+
+  for (const arg of args) {
+    if (!options.taskId && !arg.startsWith('--')) {
+      options.taskId = arg;
+      continue;
+    }
+
+    if (arg === '--cleanup') {
+      options.cleanup = true;
+      continue;
+    }
+
+    console.error(`Error: Unknown option ${arg}`);
+    console.error('Usage: coder reject <task-id> [--cleanup]');
+    process.exit(1);
+  }
+
+  return options;
+}
+
+export async function rejectTask(args = []) {
+  const { taskId, cleanup } = parseRejectArgs(args);
+
+  if (!taskId) {
+    console.error('Error: Task ID required');
+    console.error('Usage: coder reject <task-id> [--cleanup]');
+    process.exit(1);
+  }
+
+  console.log(`Rejecting task ${taskId}...`);
+
+  const body = cleanup ? { cleanup: true } : {};
+  await request(`/tasks/${taskId}/reject`, {
+    method: 'POST',
+    body: JSON.stringify(body)
+  });
+
+  console.log('✓ Task rejected');
+  if (cleanup) {
+    console.log('✓ Task artifacts cleaned up');
+  }
+}

package/lib/commands/results.js

@@ -0,0 +1,89 @@
+/**
+ * Command: coder results - Get results of a completed task
+ */
+
+import { request } from '../http-client.js';
+
+export async function getResults(taskId) {
+  if (!taskId) {
+    console.error('Error: Task ID required');
+    console.error('Usage: coder results <task-id>');
+    process.exit(1);
+  }
+
+  console.log(`Fetching results for task ${taskId}...`);
+
+  const data = await request(`/tasks/${taskId}/results`);
+
+  console.log(`\nTask Results:`);
+  console.log(`  Task ID:      ${data.task.taskId}`);
+  console.log(`  Status:       ${data.task.status}`);
+  console.log(`  Exit Code:    ${data.task.exitCode}`);
+  console.log(`  Created:      ${data.task.createdAt}`);
+  console.log(`  Finished:     ${data.task.finishedAt}`);
+  if (data.task.environment) {
+    console.log(`  Environment:  ${data.task.environment}`);
+  }
+
+  if (data.task.parameters && Object.keys(data.task.parameters || {}).length > 0) {
+    console.log('\nParameters:');
+    Object.entries(data.task.parameters).forEach(([key, value]) => {
+      console.log(`  - ${key}: ${value}`);
+    });
+  }
+
+  if (data.task.envVars && Object.keys(data.task.envVars || {}).length > 0) {
+    console.log('\nEnvironment Variables:');
+    Object.entries(data.task.envVars).forEach(([key, value]) => {
+      console.log(`  - ${key}: ${value}`);
+    });
+  }
+
+  console.log(`\nTask Metadata (from task.json):`);
+  console.log(`  Environment:  ${data.result.environment}`);
+  console.log(`  Task Type:    ${data.result.task_type}`);
+  console.log(`  Container:    ${data.result.container_id}`);
+  console.log(`  Command:      ${data.result.command}`);
+
+  if (data.task.exitCode === 0) {
+    console.log(`\n✓ Task completed successfully`);
+  } else {
+    console.log(`\n✗ Task failed with exit code ${data.task.exitCode}`);
+  }
+
+  if (data.result.summary) {
+    console.log('\nSummary:');
+    console.log(data.result.summary.trim());
+  }
+
+  const repos = Array.isArray(data.result.repos_changed) ? data.result.repos_changed : [];
+  const stats = data.result.stats || {
+    repositories: repos.length,
+    filesChanged: repos.reduce((sum, repo) => sum + (Number(repo.files_changed) || 0), 0),
+    linesAdded: repos.reduce((sum, repo) => sum + (Number(repo.lines_added) || 0), 0),
+    linesDeleted: repos.reduce((sum, repo) => sum + (Number(repo.lines_deleted) || 0), 0)
+  };
+
+  if (repos.length > 0) {
+    console.log('\nRepositories Changed:');
+    repos.forEach((repo) => {
+      const filesChanged = Number(repo.files_changed) || (Array.isArray(repo.files) ? repo.files.length : 0);
+      const linesAdded = Number(repo.lines_added) || 0;
+      const linesDeleted = Number(repo.lines_deleted) || 0;
+      console.log(`  • ${repo.name} (${filesChanged} files, +${linesAdded} -${linesDeleted})`);
+
+      if (Array.isArray(repo.files) && repo.files.length > 0) {
+        console.log('    Files:');
+        repo.files.forEach((file) => {
+          const added = Number(file.added) || 0;
+          const deleted = Number(file.deleted) || 0;
+          console.log(`      - ${file.path} (+${added} -${deleted})`);
+        });
+      }
+    });
+
+    console.log(`\nTotals: ${stats.repositories || repos.length} repos, ${stats.filesChanged || 0} files, +${stats.linesAdded || 0} -${stats.linesDeleted || 0}`);
+  } else {
+    console.log('\nNo repositories changed.');
+  }
+}