@profoundlogic/coderflow-cli 0.2.1

package/lib/commands/jira.js

@@ -0,0 +1,464 @@
+/**
+ * Command: coder jira - JIRA integration management
+ */
+
+import readline from 'readline';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { getCoderSetupPath } from '../config.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * 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 API token (visible input for easy paste verification)
+ */
+function promptSecret(question) {
+  // Use regular prompt - hiding prevents paste from working properly
+  // and adds no real security value for a pasted token in local CLI
+  return prompt(question);
+}
+
+/**
+ * Test JIRA connection
+ */
+async function testJiraConnection(baseUrl, email, apiToken) {
+  try {
+    const auth = Buffer.from(`${email}:${apiToken}`).toString('base64');
+
+    // Use node's fetch (Node 18+) or dynamic import
+    const response = await fetch(`${baseUrl}/rest/api/3/myself`, {
+      headers: {
+        'Authorization': `Basic ${auth}`,
+        'Accept': 'application/json'
+      }
+    });
+
+    if (response.ok) {
+      const user = await response.json();
+      return { success: true, user };
+    } else {
+      const error = await response.text();
+      return { success: false, error: `HTTP ${response.status}: ${error}` };
+    }
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Open browser to JIRA API token page
+ */
+async function openTokenPage() {
+  const url = 'https://id.atlassian.com/manage-profile/security/api-tokens';
+
+  try {
+    const platform = process.platform;
+    let command;
+
+    if (platform === 'darwin') {
+      command = `open "${url}"`;
+    } else if (platform === 'win32') {
+      command = `start "${url}"`;
+    } else {
+      command = `xdg-open "${url}"`;
+    }
+
+    await execAsync(command);
+    return true;
+  } catch (error) {
+    console.warn('Could not open browser automatically.');
+    console.log(`Please visit: ${url}`);
+    return false;
+  }
+}
+
+/**
+ * Connect to JIRA - interactive setup
+ */
+export async function connect(args) {
+  console.log('═══════════════════════════════════════');
+  console.log('    JIRA Integration Setup');
+  console.log('═══════════════════════════════════════');
+  console.log('');
+
+  // Get coder-setup path
+  let setupPath = args.setup || args['setup-path'];
+  if (!setupPath) {
+    setupPath = await getCoderSetupPath();
+  }
+
+  if (!setupPath) {
+    console.error('Error: No coder-setup path configured.');
+    console.log('');
+    console.log('Please specify a setup path using one of:');
+    console.log('  • coder jira connect --setup-path /path/to/setup');
+    console.log('  • coder server start --setup /path/to/setup  (then try again)');
+    console.log('  • Set CODER_SETUP_PATH environment variable');
+    console.log('');
+    process.exit(1);
+  }
+
+  console.log(`Using setup: ${setupPath}`);
+  console.log('');
+
+  // Check if setup path exists
+  try {
+    await fs.access(setupPath);
+  } catch (error) {
+    console.error(`Error: Setup path does not exist: ${setupPath}`);
+    process.exit(1);
+  }
+
+  // Load existing JIRA config if any
+  const jiraConfigPath = path.join(setupPath, 'jira.json');
+  let existingConfig = null;
+  try {
+    const content = await fs.readFile(jiraConfigPath, 'utf-8');
+    existingConfig = JSON.parse(content);
+    console.log('✓ Found existing JIRA configuration');
+    console.log('');
+  } catch {
+    // No existing config
+  }
+
+  // Prompt for JIRA URL
+  console.log('Step 1/4: JIRA Base URL');
+  console.log('────────────────────────────────────────');
+  const defaultUrl = existingConfig?.baseUrl || 'https://your-company.atlassian.net';
+  const baseUrl = await prompt(`JIRA Base URL [${defaultUrl}]: `);
+  const finalBaseUrl = (baseUrl.trim() || defaultUrl).replace(/\/$/, ''); // Remove trailing slash
+  console.log('');
+
+  // Prompt for email
+  console.log('Step 2/4: JIRA Email');
+  console.log('────────────────────────────────────────');
+  const defaultEmail = existingConfig?.auth?.email || '';
+  const emailPrompt = defaultEmail ? `Email [${defaultEmail}]: ` : 'Email: ';
+  const email = await prompt(emailPrompt);
+  const finalEmail = email.trim() || defaultEmail;
+
+  if (!finalEmail) {
+    console.error('Error: Email is required');
+    process.exit(1);
+  }
+  console.log('');
+
+  // Prompt for API token
+  console.log('Step 3/4: JIRA API Token');
+  console.log('────────────────────────────────────────');
+  console.log('You need a personal API token from JIRA.');
+  console.log('');
+
+  const shouldOpen = await prompt('Open browser to get API token? [Y/n]: ');
+  if (!shouldOpen.trim() || shouldOpen.toLowerCase() === 'y' || shouldOpen.toLowerCase() === 'yes') {
+    console.log('Opening browser...');
+    await openTokenPage();
+    console.log('');
+    console.log('Instructions:');
+    console.log('  1. Click "Create API token"');
+    console.log('  2. Give it a name (e.g., "CoderFlow")');
+    console.log('  3. Copy the token');
+    console.log('  4. Paste it below');
+    console.log('');
+  } else {
+    console.log('');
+    console.log('Get your API token at:');
+    console.log('https://id.atlassian.com/manage-profile/security/api-tokens');
+    console.log('');
+  }
+
+  const apiToken = await promptSecret('API Token: ');
+  if (!apiToken.trim()) {
+    console.error('Error: API Token is required');
+    process.exit(1);
+  }
+  console.log('');
+
+  // Test connection
+  console.log('Step 4/4: Testing Connection');
+  console.log('────────────────────────────────────────');
+  console.log('Connecting to JIRA...');
+
+  const testResult = await testJiraConnection(finalBaseUrl, finalEmail, apiToken.trim());
+
+  if (!testResult.success) {
+    console.error('✗ Connection failed');
+    console.error('');
+    console.error('Error:', testResult.error);
+    console.error('');
+    console.error('Please check your credentials and try again.');
+    process.exit(1);
+  }
+
+  console.log(`✓ Connected successfully as ${testResult.user.displayName || finalEmail}`);
+  console.log('');
+
+  // Save configuration
+  const jiraConfig = {
+    enabled: true,
+    baseUrl: finalBaseUrl,
+    auth: {
+      email: finalEmail,
+      apiToken: apiToken.trim()
+    }
+  };
+
+  try {
+    await fs.writeFile(jiraConfigPath, JSON.stringify(jiraConfig, null, 2), 'utf-8');
+    console.log('✓ Configuration saved');
+    console.log('');
+    console.log(`Saved to: ${jiraConfigPath}`);
+    console.log('');
+    console.log('═══════════════════════════════════════');
+    console.log('✓ JIRA integration is now configured!');
+    console.log('═══════════════════════════════════════');
+    console.log('');
+    console.log('The server will automatically use this configuration.');
+    console.log('No environment variables needed!');
+    console.log('');
+    console.log('Next steps:');
+    console.log('  • Start/restart the server: coder server start');
+    console.log('  • Open the web UI and look for "Import from JIRA"');
+    console.log('');
+  } catch (error) {
+    console.error('✗ Failed to save configuration');
+    console.error('');
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Show JIRA connection status
+ */
+export async function status(args) {
+  let setupPath = args.setup || args['setup-path'];
+  if (!setupPath) {
+    setupPath = await getCoderSetupPath();
+  }
+
+  if (!setupPath) {
+    console.log('JIRA Status: Not configured');
+    console.log('');
+    console.log('Run: coder jira connect --setup-path /path/to/setup');
+    return;
+  }
+
+  const jiraConfigPath = path.join(setupPath, 'jira.json');
+
+  try {
+    const content = await fs.readFile(jiraConfigPath, 'utf-8');
+    const config = JSON.parse(content);
+
+    console.log('JIRA Status: Configured ✓');
+    console.log('');
+    console.log(`  Base URL: ${config.baseUrl}`);
+    console.log(`  Email:    ${config.auth?.email || 'Not set'}`);
+
+    // Show first and last few chars to help verify token is correct
+    const token = config.auth?.apiToken || '';
+    const tokenDisplay = token.length > 10
+      ? `${token.substring(0, 8)}...${token.substring(token.length - 8)}`
+      : (token ? '*'.repeat(token.length) : 'Not set');
+    console.log(`  Token:    ${tokenDisplay}`);
+
+    console.log(`  Enabled:  ${config.enabled ? 'Yes' : 'No'}`);
+    console.log('');
+    console.log(`Config file: ${jiraConfigPath}`);
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      console.log('JIRA Status: Not configured');
+      console.log('');
+      console.log('Run: coder jira connect');
+    } else {
+      console.error('Error reading JIRA configuration:', error.message);
+    }
+  }
+}
+
+/**
+ * Disable JIRA integration
+ */
+export async function disable(args) {
+  let setupPath = args.setup || args['setup-path'];
+  if (!setupPath) {
+    setupPath = await getCoderSetupPath();
+  }
+
+  if (!setupPath) {
+    console.error('Error: No coder-setup path configured.');
+    process.exit(1);
+  }
+
+  const jiraConfigPath = path.join(setupPath, 'jira.json');
+
+  try {
+    const content = await fs.readFile(jiraConfigPath, 'utf-8');
+    const config = JSON.parse(content);
+    config.enabled = false;
+    await fs.writeFile(jiraConfigPath, JSON.stringify(config, null, 2), 'utf-8');
+
+    console.log('✓ JIRA integration disabled');
+    console.log('');
+    console.log('To re-enable: coder jira enable');
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      console.log('JIRA is not configured yet.');
+    } else {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  }
+}
+
+/**
+ * Enable JIRA integration
+ */
+export async function enable(args) {
+  let setupPath = args.setup || args['setup-path'];
+  if (!setupPath) {
+    setupPath = await getCoderSetupPath();
+  }
+
+  if (!setupPath) {
+    console.error('Error: No coder-setup path configured.');
+    process.exit(1);
+  }
+
+  const jiraConfigPath = path.join(setupPath, 'jira.json');
+
+  try {
+    const content = await fs.readFile(jiraConfigPath, 'utf-8');
+    const config = JSON.parse(content);
+    config.enabled = true;
+    await fs.writeFile(jiraConfigPath, JSON.stringify(config, null, 2), 'utf-8');
+
+    console.log('✓ JIRA integration enabled');
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      console.log('JIRA is not configured yet.');
+      console.log('');
+      console.log('Run: coder jira connect');
+    } else {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  }
+}
+
+/**
+ * Test JIRA connection with saved configuration
+ */
+export async function test(args) {
+  let setupPath = args.setup || args['setup-path'];
+  if (!setupPath) {
+    setupPath = await getCoderSetupPath();
+  }
+
+  if (!setupPath) {
+    console.error('Error: No coder-setup path configured.');
+    process.exit(1);
+  }
+
+  const jiraConfigPath = path.join(setupPath, 'jira.json');
+
+  try {
+    const content = await fs.readFile(jiraConfigPath, 'utf-8');
+    const config = JSON.parse(content);
+
+    if (!config.enabled) {
+      console.log('JIRA integration is disabled.');
+      console.log('Run: coder jira enable');
+      return;
+    }
+
+    console.log('Testing JIRA connection...');
+    console.log('');
+
+    const testResult = await testJiraConnection(config.baseUrl, config.auth.email, config.auth.apiToken);
+
+    if (testResult.success) {
+      console.log('✓ Connection successful!');
+      console.log(`  User: ${testResult.user.displayName || config.auth.email}`);
+      console.log('');
+    } else {
+      console.error('✗ Connection failed');
+      console.error('');
+      console.error('Error:', testResult.error);
+      console.error('');
+      process.exit(1);
+    }
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      console.log('JIRA is not configured yet.');
+      console.log('');
+      console.log('Run: coder jira connect');
+    } else {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  }
+}
+
+/**
+ * Main jira command handler
+ */
+export async function jira(args) {
+  const subcommand = args._[0];
+
+  switch (subcommand) {
+    case 'connect':
+      await connect(args);
+      break;
+    case 'status':
+      await status(args);
+      break;
+    case 'test':
+      await test(args);
+      break;
+    case 'disable':
+      await disable(args);
+      break;
+    case 'enable':
+      await enable(args);
+      break;
+    default:
+      console.log('Usage: coder jira <command>');
+      console.log('');
+      console.log('Commands:');
+      console.log('  connect      Set up JIRA integration (interactive)');
+      console.log('  status       Show JIRA configuration status');
+      console.log('  test         Test JIRA connection');
+      console.log('  enable       Enable JIRA integration');
+      console.log('  disable      Disable JIRA integration');
+      console.log('');
+      console.log('Options:');
+      console.log('  --setup-path <path>   Path to coder-setup directory');
+      console.log('');
+      console.log('Examples:');
+      console.log('  coder jira connect');
+      console.log('  coder jira status');
+      console.log('  coder jira test');
+      console.log('  coder jira connect --setup-path /path/to/setup');
+      break;
+  }
+}

package/lib/commands/license.js

@@ -0,0 +1,172 @@
+/**
+ * License command - manage CoderFlow license
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { getCoderSetupPath } from '../config.js';
+
+/**
+ * Handle license command
+ * Usage:
+ *   coder license set <key>
+ *   coder license show
+ *   coder license verify
+ */
+export async function handleLicense(args) {
+  const subcommand = args[0];
+
+  if (!subcommand) {
+    console.error('Usage: coder license <set|show|verify> [key]');
+    console.error('');
+    console.error('Commands:');
+    console.error('  set <key>   Install a license key');
+    console.error('  show        Show current license status');
+    console.error('  verify      Verify the license with the server');
+    console.error('');
+    console.error('Example:');
+    console.error('  coder license set <your-license-key>');
+    process.exit(1);
+  }
+
+  try {
+    switch (subcommand) {
+      case 'set':
+        await setLicense(args[1]);
+        break;
+
+      case 'show':
+        await showLicense();
+        break;
+
+      case 'verify':
+        await verifyLicense();
+        break;
+
+      default:
+        console.error(`Unknown subcommand: ${subcommand}`);
+        console.error('Run "coder license" for usage information');
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+async function setLicense(key) {
+  if (!key) {
+    console.error('Usage: coder license set <key>');
+    console.error('');
+    console.error('Example:');
+    console.error('  coder license set <your-license-key>');
+    process.exit(1);
+  }
+
+  const setupPath = await getCoderSetupPath();
+  if (!setupPath) {
+    console.error('Error: CODER_SETUP_PATH not set');
+    console.error('');
+    console.error('The license file must be saved to your coder-setup directory.');
+    console.error('Set it with:');
+    console.error('  export CODER_SETUP_PATH=/path/to/coder-setup');
+    console.error('Or save to config:');
+    console.error('  coder server init /path/to/coder-setup');
+    process.exit(1);
+  }
+
+  const licensePath = path.join(setupPath, 'license.json');
+
+  // Create license data
+  const licenseData = {
+    key: key.trim().toUpperCase(),
+    installedAt: new Date().toISOString()
+  };
+
+  // Write license file
+  await fs.writeFile(licensePath, JSON.stringify(licenseData, null, 2), 'utf-8');
+
+  console.log('License installed successfully');
+  console.log(`  Location: ${licensePath}`);
+  console.log('');
+  console.log('Restart the CoderFlow server for the license to take effect.');
+}
+
+async function showLicense() {
+  const setupPath = await getCoderSetupPath();
+  if (!setupPath) {
+    console.error('Error: CODER_SETUP_PATH not set');
+    console.error('');
+    console.error('Set it with:');
+    console.error('  export CODER_SETUP_PATH=/path/to/coder-setup');
+    process.exit(1);
+  }
+
+  const licensePath = path.join(setupPath, 'license.json');
+
+  try {
+    const content = await fs.readFile(licensePath, 'utf-8');
+    const licenseData = JSON.parse(content);
+
+    console.log('=== License Information ===');
+    console.log('');
+
+    // Mask the license key for display (show first and last segments)
+    const keyParts = licenseData.key.split('-');
+    let maskedKey;
+    if (keyParts.length >= 3) {
+      maskedKey = keyParts[0] + '-****-****-****-' + keyParts[keyParts.length - 1];
+    } else {
+      maskedKey = licenseData.key.slice(0, 4) + '****' + licenseData.key.slice(-4);
+    }
+
+    console.log(`Key: ${maskedKey}`);
+    console.log(`Installed: ${licenseData.installedAt}`);
+    console.log('');
+    console.log(`Location: ${licensePath}`);
+    console.log('');
+    console.log('Use "coder license verify" to check license validity with the server.');
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      console.log('No license installed');
+      console.log('');
+      console.log('Install a license with:');
+      console.log('  coder license set <key>');
+    } else {
+      throw error;
+    }
+  }
+}
+
+async function verifyLicense() {
+  try {
+    const { request } = await import('../http-client.js');
+
+    // Make a simple request to the server - if license is invalid, server won't start
+    // or will return 403 on protected routes
+    const health = await request('/health');
+
+    console.log('License status: Valid');
+    console.log('');
+    console.log('The server is running and accepting requests.');
+  } catch (error) {
+    if (error.message.includes('License') || error.message.includes('403')) {
+      console.error('License status: Invalid or Expired');
+      console.error('');
+      console.error(error.message);
+      console.error('');
+      console.error('Please contact Profound Logic to obtain a valid CoderFlow license.');
+      process.exit(1);
+    } else if (error.message.includes('ECONNREFUSED') || error.message.includes('connect')) {
+      console.error('Cannot verify license: Server is not running');
+      console.error('');
+      console.error('Start the server with:');
+      console.error('  coder server start');
+      console.error('');
+      console.error('If the server fails to start, check the license status in server logs.');
+      process.exit(1);
+    } else {
+      throw error;
+    }
+  }
+}