@profoundlogic/coderflow-cli 0.2.1

package/lib/commands/list.js

@@ -0,0 +1,104 @@
+/**
+ * Command: coder list - List all tasks
+ */
+
+import { request } from '../http-client.js';
+
+function parseListArgs(args = []) {
+  const options = {
+    status: null,
+    environment: null
+  };
+
+  for (const arg of args) {
+    if (arg.startsWith('--status=')) {
+      options.status = arg.substring('--status='.length);
+      continue;
+    }
+
+    if (arg.startsWith('--environment=')) {
+      options.environment = arg.substring('--environment='.length);
+      continue;
+    }
+
+    console.error(`Error: Unknown option ${arg}`);
+    console.error('Usage: coder list [--status=running|completed|failed|rejected] [--environment=name]');
+    process.exit(1);
+  }
+
+  return options;
+}
+
+function formatDuration(created, finished) {
+  if (!created) {
+    return 'unknown';
+  }
+  const start = new Date(created).getTime();
+  const end = finished ? new Date(finished).getTime() : Date.now();
+  const diff = Math.max(0, end - start);
+  const minutes = Math.floor(diff / (1000 * 60));
+  const seconds = Math.floor((diff / 1000) % 60);
+  if (minutes > 0) {
+    return `${minutes}m ${seconds}s`;
+  }
+  return `${seconds}s`;
+}
+
+export async function listTasks(args = []) {
+  const filters = parseListArgs(args);
+
+  console.log('Fetching tasks...');
+
+  const query = new URLSearchParams();
+  if (filters.status) {
+    query.append('status', filters.status);
+  }
+  if (filters.environment) {
+    query.append('environment', filters.environment);
+  }
+  query.append('include', 'stats');
+
+  const path = query.toString() ? `/tasks?${query.toString()}` : '/tasks';
+  const data = await request(path);
+
+  console.log(`\nTasks (${data.count} total)`);
+  if (filters.status) {
+    console.log(`  Status: ${filters.status}`);
+  }
+  if (filters.environment) {
+    console.log(`  Environment: ${filters.environment}`);
+  }
+  console.log('');
+
+  if (data.tasks.length === 0) {
+    console.log('  No tasks found');
+    return;
+  }
+
+  for (const task of data.tasks) {
+    const statusIcon = task.status === 'completed' ? '✓'
+      : task.status === 'failed' ? '✗'
+      : task.status === 'rejected' ? '!' : '⋯';
+
+    console.log(`  ${statusIcon} ${task.taskId}`);
+    console.log(`    Status:       ${task.status}`);
+    if (task.environment) {
+      console.log(`    Environment:  ${task.environment}`);
+    }
+    if (task.taskType) {
+      console.log(`    Task Type:    ${task.taskType}`);
+    }
+    console.log(`    Created:      ${task.createdAt || 'unknown'}`);
+    if (task.finishedAt) {
+      console.log(`    Finished:     ${task.finishedAt}`);
+    }
+    console.log(`    Duration:     ${formatDuration(task.createdAt, task.finishedAt)}`);
+    if (task.stats) {
+      const filesChanged = Number(task.stats.filesChanged) || 0;
+      const linesAdded = Number(task.stats.linesAdded) || 0;
+      const linesDeleted = Number(task.stats.linesDeleted) || 0;
+      console.log(`    Changes:      ${filesChanged} files, +${linesAdded} -${linesDeleted}`);
+    }
+    console.log('');
+  }
+}

package/lib/commands/login.js

@@ -0,0 +1,329 @@
+/**
+ * Command: coder login - Authenticate with the Coder server
+ */
+
+import readline from 'readline';
+import { request } from '../http-client.js';
+import { saveApiKey, getCredentialsPathForDisplay } from '../config.js';
+import { getActiveProfileName } from '../profile.js';
+import { checkOidcConfig, initiateDeviceFlow, pollDeviceFlow } from '../oidc.js';
+
+/**
+ * Prompt for input from stdin
+ */
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+/**
+ * Prompt for password (hidden input)
+ */
+function promptPassword(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    // Hide password input
+    const stdin = process.stdin;
+    const onData = () => {};
+
+    stdin.on('data', onData);
+
+    rl.question(question, (password) => {
+      stdin.removeListener('data', onData);
+      rl.close();
+      console.log(''); // New line after password
+      resolve(password);
+    });
+
+    // Disable echo
+    rl._writeToOutput = function(stringToWrite) {
+      if (stringToWrite.charCodeAt(0) === 13) {
+        rl.output.write('\n');
+      } else if (rl.line.length === 0) {
+        rl.output.write(question);
+      }
+    };
+  });
+}
+
+/**
+ * Draw a box around text for visual emphasis
+ */
+function drawBox(content, title = '') {
+  const lines = content.split('\n');
+  const maxWidth = Math.max(...lines.map(l => l.length), title.length);
+  const width = maxWidth + 4;
+
+  const horizontal = '─'.repeat(width);
+  const top = title
+    ? `┌─ ${title} ${'─'.repeat(width - title.length - 3)}┐`
+    : `┌${horizontal}┐`;
+
+  console.log(top);
+  for (const line of lines) {
+    const padding = ' '.repeat(maxWidth - line.length);
+    console.log(`│  ${line}${padding}  │`);
+  }
+  console.log(`└${horizontal}┘`);
+}
+
+/**
+ * SSO login flow using OIDC device flow
+ */
+async function ssoLogin() {
+  console.log('SSO Login');
+  console.log('');
+
+  // Check if OIDC is enabled
+  console.log('Checking SSO configuration...');
+  let oidcConfig;
+  try {
+    oidcConfig = await checkOidcConfig();
+  } catch (error) {
+    console.error('');
+    console.error(`Error: Failed to check SSO configuration: ${error.message}`);
+    console.error('');
+    console.error('Make sure the server is running and accessible.');
+    process.exit(1);
+  }
+
+  if (!oidcConfig.enabled) {
+    console.error('');
+    console.error('Error: SSO is not enabled on this server.');
+    console.error('');
+    console.error('Please contact your administrator to enable OIDC authentication,');
+    console.error('or use `coder login` without --sso for username/password login.');
+    process.exit(1);
+  }
+
+  // Initiate device flow
+  console.log('Initiating SSO authentication...');
+  let deviceFlow;
+  try {
+    deviceFlow = await initiateDeviceFlow();
+  } catch (error) {
+    console.error('');
+    console.error(`Error: Failed to start SSO flow: ${error.message}`);
+    process.exit(1);
+  }
+
+  console.log('');
+
+  // Display user code prominently
+  drawBox(deviceFlow.userCode, 'Your Code');
+
+  console.log('');
+  console.log('To sign in:');
+  console.log(`  1. Open: ${deviceFlow.verificationUrl}`);
+  console.log('  2. Enter the code shown above');
+  console.log('  3. Follow the prompts to authenticate');
+  console.log('');
+
+  // Try to open browser
+  try {
+    const open = (await import('open')).default;
+    await open(deviceFlow.verificationUrl);
+    console.log('Browser opened automatically.');
+  } catch {
+    console.log('Could not open browser automatically.');
+    console.log(`Please open this URL manually: ${deviceFlow.verificationUrl}`);
+  }
+
+  console.log('');
+  console.log('Waiting for authentication...');
+
+  // Set up Ctrl+C handler
+  let cancelled = false;
+  const cleanup = () => {
+    cancelled = true;
+    console.log('');
+    console.log('Authentication cancelled.');
+    process.exit(0);
+  };
+  process.on('SIGINT', cleanup);
+
+  // Poll for approval
+  const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let spinnerIndex = 0;
+  const startTime = Date.now();
+  const expiresAt = startTime + (deviceFlow.expiresIn * 1000);
+  const pollInterval = Math.max(deviceFlow.interval * 1000, 2000); // At least 2 seconds
+
+  while (!cancelled) {
+    // Check if expired
+    const now = Date.now();
+    if (now >= expiresAt) {
+      process.removeListener('SIGINT', cleanup);
+      console.log('');
+      console.error('');
+      console.error('Error: Authentication session expired.');
+      console.error('Please run `coder login --sso` again to start a new session.');
+      process.exit(1);
+    }
+
+    // Show spinner with time remaining
+    const remaining = Math.ceil((expiresAt - now) / 1000);
+    const minutes = Math.floor(remaining / 60);
+    const seconds = remaining % 60;
+    const timeStr = minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+
+    process.stdout.write(`\r${spinnerFrames[spinnerIndex]} Waiting for approval (expires in ${timeStr})...  `);
+    spinnerIndex = (spinnerIndex + 1) % spinnerFrames.length;
+
+    // Poll
+    try {
+      const result = await pollDeviceFlow(deviceFlow.deviceCode);
+
+      if (result.status === 'approved') {
+        process.removeListener('SIGINT', cleanup);
+        process.stdout.write('\r' + ' '.repeat(60) + '\r'); // Clear spinner line
+
+        // Save API key
+        await saveApiKey(result.apiKey);
+
+        // Get the active profile name to show in output
+        const activeProfile = await getActiveProfileName();
+        const credentialsPath = await getCredentialsPathForDisplay();
+
+        console.log('');
+        console.log(`✓ Logged in as ${result.user?.name || result.user?.username || 'user'}`);
+        if (result.user?.email) {
+          console.log(`  Email: ${result.user.email}`);
+        }
+        if (result.user?.role) {
+          console.log(`  Role: ${result.user.role}`);
+        }
+        console.log('');
+        if (activeProfile) {
+          console.log(`Credentials saved to profile '${activeProfile}'`);
+          console.log(`  Location: ${credentialsPath}`);
+        } else {
+          console.log(`Credentials saved to ${credentialsPath}`);
+        }
+        console.log('');
+        return;
+      }
+
+      if (result.status === 'expired') {
+        process.removeListener('SIGINT', cleanup);
+        process.stdout.write('\r' + ' '.repeat(60) + '\r');
+        console.error('');
+        console.error('Error: Authentication session expired.');
+        console.error('Please run `coder login --sso` again to start a new session.');
+        process.exit(1);
+      }
+
+      if (result.status === 'denied') {
+        process.removeListener('SIGINT', cleanup);
+        process.stdout.write('\r' + ' '.repeat(60) + '\r');
+        console.error('');
+        console.error('Error: Authentication was denied.');
+        console.error('Please try again or contact your administrator.');
+        process.exit(1);
+      }
+
+      // Still pending, wait before polling again
+    } catch (error) {
+      // Log error but keep polling unless it's fatal
+      if (error.message.includes('ECONNREFUSED') || error.message.includes('ENOTFOUND')) {
+        process.removeListener('SIGINT', cleanup);
+        process.stdout.write('\r' + ' '.repeat(60) + '\r');
+        console.error('');
+        console.error(`Error: Lost connection to server: ${error.message}`);
+        process.exit(1);
+      }
+      // For other errors, continue polling
+    }
+
+    // Wait before next poll
+    await new Promise(resolve => setTimeout(resolve, pollInterval));
+  }
+}
+
+/**
+ * Username/password login flow
+ */
+async function passwordLogin() {
+  console.log('Coder Login');
+  console.log('');
+
+  // Prompt for username
+  const username = await prompt('Username: ');
+
+  if (!username || !username.trim()) {
+    console.error('Error: Username is required');
+    process.exit(1);
+  }
+
+  // Prompt for password
+  const password = await promptPassword('Password: ');
+
+  if (!password) {
+    console.error('Error: Password is required');
+    process.exit(1);
+  }
+
+  console.log('Authenticating...');
+
+  try {
+    // Call the CLI login endpoint (doesn't require auth)
+    const response = await request('/auth/cli-login', {
+      method: 'POST',
+      body: JSON.stringify({
+        username: username.trim(),
+        password
+      })
+    });
+
+    // Save API key to config file or active profile
+    await saveApiKey(response.apiKey);
+
+    // Get the active profile name to show in output
+    const activeProfile = await getActiveProfileName();
+    const credentialsPath = await getCredentialsPathForDisplay();
+
+    console.log('');
+    console.log(`✓ Logged in as ${response.user.name || response.user.username}`);
+    console.log(`  Email: ${response.user.email}`);
+    console.log(`  Role: ${response.user.role}`);
+    console.log('');
+    if (activeProfile) {
+      console.log(`Credentials saved to profile '${activeProfile}'`);
+      console.log(`  Location: ${credentialsPath}`);
+    } else {
+      console.log(`Credentials saved to ${credentialsPath}`);
+    }
+    console.log('');
+
+  } catch (error) {
+    console.error('');
+    console.error(`✗ Login failed: ${error.message}`);
+    console.error('');
+    console.error('Please check your username and password and try again.');
+    process.exit(1);
+  }
+}
+
+export async function login(args = []) {
+  // Parse --sso flag
+  const useSso = args.includes('--sso');
+
+  if (useSso) {
+    await ssoLogin();
+  } else {
+    await passwordLogin();
+  }
+}

package/lib/commands/logs.js

@@ -0,0 +1,66 @@
+/**
+ * Command: coder logs - Show logs for a task
+ */
+
+import { request } from '../http-client.js';
+
+function parseLogsArgs(args) {
+  const options = {
+    taskId: null,
+    tail: null
+  };
+
+  for (const arg of args) {
+    if (!options.taskId && !arg.startsWith('--')) {
+      options.taskId = arg;
+      continue;
+    }
+
+    if (arg.startsWith('--tail=')) {
+      const value = arg.substring('--tail='.length);
+      const parsed = parseInt(value, 10);
+      if (Number.isNaN(parsed)) {
+        console.error('Error: --tail must be a number');
+        process.exit(1);
+      }
+      options.tail = parsed;
+      continue;
+    }
+
+    console.error(`Error: Unknown option: ${arg}`);
+    console.error('Usage: coder logs <task-id> [--tail=N]');
+    process.exit(1);
+  }
+
+  return options;
+}
+
+export async function showLogs(args = []) {
+  const { taskId, tail } = parseLogsArgs(args);
+
+  if (!taskId) {
+    console.error('Error: Task ID required');
+    console.error('Usage: coder logs <task-id> [--tail=N]');
+    process.exit(1);
+  }
+
+  console.log(`Fetching logs for task ${taskId}...`);
+
+  const query = tail ? `?tail=${tail}` : '';
+  const logs = await request(`/tasks/${taskId}/logs${query}`, {
+    parse: 'text',
+    headers: {
+      Accept: 'text/plain'
+    }
+  });
+
+  if (!logs) {
+    console.log('\nNo logs available.');
+    return;
+  }
+
+  // If request() parsed JSON (due to content-type), handle both string or { logs }
+  const output = typeof logs === 'string' ? logs : logs.logs || '';
+
+  console.log('\n' + output.trimEnd());
+}