aptunnel 1.0.0

package/src/commands/init.js

@@ -0,0 +1,300 @@
+import readline from 'readline';
+import { createInterface } from 'readline';
+import { logger } from '../lib/logger.js';
+import { isInstalled, login, listEnvironments, listDatabases } from '../lib/aptible.js';
+import { installInstructions, detectOS } from '../lib/platform.js';
+import {
+  exists, save, savePassword, getConfigDir, getConfigPath, nextAvailablePort,
+} from '../lib/config-manager.js';
+
+// ─── Entry point ──────────────────────────────────────────────────────────────
+
+export async function runInit(args) {
+  logger.section('aptunnel init — Setup Wizard');
+  console.log('');
+
+  // 1. Check aptible CLI
+  if (!isInstalled()) {
+    logger.error('Aptible CLI not found in PATH.');
+    console.log('');
+    console.log(installInstructions('aptible'));
+    process.exit(1);
+  }
+
+  // 2. Check existing config
+  if (exists()) {
+    const reinit = await ask('Config already exists. Reinitialize? (y/N) ');
+    if (!reinit.match(/^y(es)?$/i)) {
+      logger.info('Aborted.');
+      return;
+    }
+    console.log('');
+  }
+
+  // 3. Collect credentials
+  const email    = await ask('Aptible email: ');
+  const password = await askSecret('Aptible password: ');
+  console.log('');
+
+  // 4. Login (interactive — handles 2FA via stdio: inherit)
+  // Close readline BEFORE spawning aptible so stdin is fully available to the child
+  closeRL();
+  const spinner = (await import('ora')).default({ text: 'Logging in to Aptible…' }).start();
+  const ok = await login({ email, password });
+  if (!ok) {
+    spinner.fail('Login failed. Please check your credentials.');
+    process.exit(1);
+  }
+  spinner.succeed('Logged in successfully.');
+  console.log('');
+
+  // 5. Discover environments
+  const envSpinner = (await import('ora')).default({ text: 'Discovering environments…' }).start();
+  const environments = listEnvironments();
+  envSpinner.succeed(`Found ${environments.length} environment(s).`);
+
+  if (environments.length === 0) {
+    logger.warn('No environments found for this account.');
+    process.exit(1);
+  }
+
+  // 6. Select environments
+  console.log('');
+  console.log('Available environments:');
+  environments.forEach((env, i) => {
+    console.log(`  [${i + 1}] ${env.handle}`);
+  });
+  console.log('');
+
+  const selection = await ask(
+    `Select environments to configure (comma-separated numbers, or "all") [all]: `
+  );
+
+  let selectedEnvs;
+  if (!selection.trim() || selection.trim().toLowerCase() === 'all') {
+    selectedEnvs = environments;
+  } else {
+    const indices = selection.split(',').map(s => parseInt(s.trim(), 10) - 1);
+    selectedEnvs = indices
+      .filter(i => i >= 0 && i < environments.length)
+      .map(i => environments[i]);
+  }
+
+  if (selectedEnvs.length === 0) {
+    logger.error('No valid environments selected.');
+    process.exit(1);
+  }
+
+  // 7. Set default environment
+  let defaultEnvHandle = selectedEnvs[0].handle;
+  if (selectedEnvs.length > 1) {
+    console.log('');
+    selectedEnvs.forEach((env, i) => console.log(`  [${i + 1}] ${env.handle}`));
+    const defChoice = await ask(`Default environment [1]: `);
+    const defIdx = parseInt(defChoice.trim() || '1', 10) - 1;
+    if (defIdx >= 0 && defIdx < selectedEnvs.length) {
+      defaultEnvHandle = selectedEnvs[defIdx].handle;
+    }
+  }
+
+  // 8. For each environment, discover databases and assign ports
+  const configEnvironments = {};
+  let portCounter = 55550;
+
+  for (const env of selectedEnvs) {
+    console.log('');
+    const dbSpinner = (await import('ora')).default({ text: `Fetching databases for ${env.handle}…` }).start();
+    const databases = listDatabases(env.handle);
+    dbSpinner.succeed(`Found ${databases.length} database(s) in ${env.handle}.`);
+
+    if (databases.length === 0) continue;
+
+    // Auto-assign ports
+    const assignedDbs = databases.map((db) => ({
+      ...db,
+      assignedPort: portCounter++,
+      suggestedAlias: suggestDbAlias(db.handle, databases),
+    }));
+
+    // Show proposed config
+    console.log('');
+    console.log(`  Databases in ${env.handle}:`);
+    assignedDbs.forEach((db, i) => {
+      console.log(`  [${i + 1}] ${db.handle}  →  alias: ${db.suggestedAlias}  port: ${db.assignedPort}  (${db.type})`);
+    });
+
+    // 9. Customize ports?
+    const customizePorts = await ask('  Customize ports? (y/N) ');
+    if (customizePorts.match(/^y(es)?$/i)) {
+      for (const db of assignedDbs) {
+        const newPort = await ask(`    Port for ${db.handle} [${db.assignedPort}]: `);
+        if (newPort.trim()) db.assignedPort = parseInt(newPort.trim(), 10);
+      }
+    }
+
+    // 10. Customize aliases?
+    const customizeAliases = await ask('  Customize aliases? (y/N) ');
+    if (customizeAliases.match(/^y(es)?$/i)) {
+      for (const db of assignedDbs) {
+        const newAlias = await ask(`    Alias for ${db.handle} [${db.suggestedAlias}]: `);
+        if (newAlias.trim()) db.suggestedAlias = deduplicateAlias(newAlias.trim(), assignedDbs);
+      }
+    }
+
+    // Build environment alias
+    const envAlias = suggestEnvAlias(env.handle);
+    const confirmedEnvAlias = await ask(`  Alias for this environment [${envAlias}]: `);
+
+    const databasesConfig = {};
+    for (const db of assignedDbs) {
+      databasesConfig[db.handle] = {
+        alias: db.suggestedAlias,
+        port:  db.assignedPort,
+        type:  db.type,
+      };
+    }
+
+    configEnvironments[env.handle] = {
+      alias:     confirmedEnvAlias.trim() || envAlias,
+      databases: databasesConfig,
+    };
+  }
+
+  // 11. Write config
+  const config = {
+    version: 1,
+    credentials: { email },
+    defaults: {
+      environment: defaultEnvHandle,
+      lifetime:    '7d',
+    },
+    environments: configEnvironments,
+    tunnel_defaults: {
+      start_port:    55550,
+      port_increment: 1,
+    },
+  };
+
+  // All prompts done — close readline before exiting
+  closeRL();
+
+  save(config);
+  savePassword(password);
+
+  console.log('');
+  logger.success(`Config written to ${getConfigPath()}`);
+  logger.success('Credentials stored in ' + getConfigDir() + '/.credentials (mode 600)');
+  console.log('');
+  logger.section('Next steps');
+  console.log('  aptunnel status         — view all tunnel states');
+  console.log('  aptunnel <alias>        — open a tunnel');
+  console.log('  aptunnel all            — open all tunnels');
+  console.log('  aptunnel --help         — full command reference');
+  console.log('');
+}
+
+// ─── Alias generation ─────────────────────────────────────────────────────────
+
+/**
+ * Suggest a short alias for an environment handle.
+ * e.g. "ekare-inc-development-gfpkcova" → "dev"
+ */
+function suggestEnvAlias(handle) {
+  const words = handle.toLowerCase().split(/[-_]/);
+
+  const envWords = { development: 'dev', staging: 'staging', production: 'prod', test: 'test', testing: 'test' };
+  for (const word of words) {
+    if (envWords[word]) return envWords[word];
+  }
+
+  // Use the most informative non-hash word
+  const meaningful = words.filter(w => w.length > 2 && !/^[a-z0-9]{6,}$/.test(w) && !['inc', 'com', 'the'].includes(w));
+  return meaningful[meaningful.length - 1] ?? words[0];
+}
+
+/**
+ * Suggest a short alias for a database handle.
+ * e.g. "ekaredb-dev" → "dev-db", "my-company-redis" → "redis"
+ */
+function suggestDbAlias(handle, allDbs) {
+  const lower = handle.toLowerCase();
+
+  // Detect DB type from handle
+  let type = '';
+  if (lower.includes('redis'))    type = 'redis';
+  if (lower.includes('postgres') || lower.includes('pg')) type = 'pg';
+  if (lower.includes('mysql'))    type = 'mysql';
+  if (lower.includes('mongo'))    type = 'mongo';
+
+  // Detect environment part
+  let env = '';
+  const envWords = { dev: 'dev', development: 'dev', staging: 'stg', prod: 'prod', production: 'prod', test: 'test' };
+  for (const [word, alias] of Object.entries(envWords)) {
+    if (lower.includes(word)) { env = alias; break; }
+  }
+
+  if (type && env)  return `${env}-${type}`;
+  if (type)         return type;
+  if (env)          return `${env}-db`;
+
+  // Fallback: strip common company prefixes, take last meaningful segment
+  const parts = lower.split(/[-_]/).filter(p => p.length > 1 && !/^\d+$/.test(p));
+  return parts[parts.length - 1] ?? handle;
+}
+
+function deduplicateAlias(alias, allDbs) {
+  const used = new Set(allDbs.map(d => d.suggestedAlias));
+  if (!used.has(alias)) return alias;
+  let i = 2;
+  while (used.has(`${alias}${i}`)) i++;
+  return `${alias}${i}`;
+}
+
+// ─── Readline helpers ─────────────────────────────────────────────────────────
+// We use a SINGLE readline interface throughout init and only close it at the
+// very end, right before handing stdin back to the aptible child process.
+// Opening/closing multiple readline interfaces causes process.stdin to be
+// paused between calls, which makes subsequent prompts appear to hang.
+
+let _rl = null;
+
+function getRL() {
+  if (!_rl) {
+    _rl = createInterface({ input: process.stdin, output: process.stdout });
+    // Prevent readline from keeping the event loop alive indefinitely
+    _rl.on('close', () => { _rl = null; });
+  }
+  return _rl;
+}
+
+function closeRL() {
+  if (_rl) {
+    _rl.close();
+    _rl = null;
+  }
+  // Ensure stdin is resumed so child processes can read from it (e.g. aptible 2FA)
+  process.stdin.resume();
+}
+
+function ask(prompt) {
+  return new Promise((resolve) => {
+    getRL().question(prompt, (answer) => resolve(answer));
+  });
+}
+
+function askSecret(prompt) {
+  return new Promise((resolve) => {
+    const rl = getRL();
+    process.stdout.write(prompt);
+    rl._writeToOutput = function(str) {
+      if (!this.stdoutMuted) this.output.write(str);
+    };
+    rl.stdoutMuted = true;
+    rl.question('', (answer) => {
+      rl.stdoutMuted = false;
+      rl._writeToOutput = function(str) { this.output.write(str); };
+      process.stdout.write('\n');
+      resolve(answer);
+    });
+  });
+}

package/src/commands/login.js

@@ -0,0 +1,118 @@
+import { createInterface } from 'readline';
+import chalk from 'chalk';
+import { logger } from '../lib/logger.js';
+import { isInstalled, login, getTokenInfo } from '../lib/aptible.js';
+import { exists, load, savePassword } from '../lib/config-manager.js';
+import { installInstructions } from '../lib/platform.js';
+
+export async function runLogin(args) {
+  if (!isInstalled()) {
+    logger.error('Aptible CLI not found.');
+    console.log(installInstructions('aptible'));
+    process.exit(1);
+  }
+
+  // --status only
+  if (args.includes('--status')) {
+    printTokenStatus();
+    return;
+  }
+
+  // Collect credentials
+  let email    = parseFlag(args, '--email');
+  let password = parseFlag(args, '--password');
+  const lifetime = parseFlag(args, '--lifetime') ?? '7d';
+
+  // Fall back to saved config
+  if (!email || !password) {
+    if (exists()) {
+      const config = load();
+      if (!email)    email    = config.credentials?.email ?? null;
+      if (!password) password = (await import('../lib/config-manager.js')).readPassword();
+    }
+  }
+
+  // Interactive prompts for missing values
+  if (!email)    email    = await ask('Aptible email: ');
+  if (!password) password = await askSecret('Aptible password: ');
+
+  // Close readline before handing stdin to aptible (2FA prompt needs raw terminal)
+  closeRL();
+
+  const ok = await login({ email, password, lifetime });
+
+  if (!ok) {
+    logger.error('Login failed.');
+    process.exit(1);
+  }
+
+  // Persist updated password if it changed
+  if (password) savePassword(password);
+
+  logger.success('Logged in successfully.');
+  printTokenStatus();
+}
+
+// ─── Token status display ─────────────────────────────────────────────────────
+
+function printTokenStatus() {
+  const token = getTokenInfo();
+  if (!token) {
+    logger.warn('No token found. Run `aptunnel login` to authenticate.');
+    return;
+  }
+
+  console.log('');
+  logger.detail('User:', chalk.cyan(token.email));
+  if (token.issuedAt) logger.detail('Issued:', token.issuedAt.toLocaleString());
+  logger.detail('Expires:', token.expiresAt.toLocaleString());
+
+  if (token.isExpired) {
+    logger.detail('Status:', chalk.red('EXPIRED'));
+  } else {
+    const d = Math.floor(token.remainingHours / 24);
+    const h = token.remainingHours % 24;
+    const remaining = d > 0 ? `${d}d ${h}h` : `${h}h`;
+    logger.detail('Status:', chalk.green(`valid (expires in ${remaining})`));
+  }
+  console.log('');
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function parseFlag(args, flag) {
+  const entry = args.find(a => a.startsWith(`${flag}=`));
+  return entry ? entry.slice(flag.length + 1) : null;
+}
+
+// Single shared readline — avoids stdin pause issues between consecutive prompts
+let _rl = null;
+function getRL() {
+  if (!_rl) _rl = createInterface({ input: process.stdin, output: process.stdout });
+  return _rl;
+}
+function closeRL() {
+  if (_rl) { _rl.close(); _rl = null; }
+  process.stdin.resume();
+}
+
+function ask(prompt) {
+  return new Promise((resolve) => {
+    getRL().question(prompt, (answer) => resolve(answer));
+  });
+}
+
+function askSecret(prompt) {
+  return new Promise((resolve) => {
+    const rl = getRL();
+    process.stdout.write(prompt);
+    rl._writeToOutput = function(str) { if (!this.stdoutMuted) this.output.write(str); };
+    rl.stdoutMuted = true;
+    rl.question('', (answer) => {
+      rl.stdoutMuted = false;
+      rl._writeToOutput = function(str) { this.output.write(str); };
+      process.stdout.write('\n');
+      resolve(answer);
+    });
+  });
+}

package/src/commands/status.js

@@ -0,0 +1,99 @@
+import chalk from 'chalk';
+import { logger } from '../lib/logger.js';
+import { exists, getAllDatabases, load } from '../lib/config-manager.js';
+import { isRunning, readPid, readConnectionInfo, toIdentifier } from '../lib/process-manager.js';
+import { getProcessUptime, formatUptime } from '../lib/platform.js';
+import { getTokenInfo } from '../lib/aptible.js';
+
+export function runStatus() {
+  if (!exists()) {
+    logger.warn('No config found. Run `aptunnel init` to set up.');
+    return;
+  }
+
+  // ── Login status ──────────────────────────────────────────────────────────
+  logger.section('LOGIN STATUS');
+  const token = getTokenInfo();
+  if (!token) {
+    logger.warn('  Token:  not found — run `aptunnel login`');
+  } else {
+    console.log(`  User:   ${chalk.cyan(token.email)}`);
+    if (token.isExpired) {
+      console.log(`  Token:  ${chalk.red('EXPIRED')} — run \`aptunnel login\` to re-authenticate`);
+    } else {
+      const d = Math.floor(token.remainingHours / 24);
+      const h = token.remainingHours % 24;
+      const remaining = d > 0 ? `${d}d ${h}h` : `${h}h`;
+      console.log(`  Token:  ${chalk.green('valid')} (expires in ${remaining})`);
+    }
+  }
+
+  // ── Tunnel table ──────────────────────────────────────────────────────────
+  console.log('');
+  logger.section('TUNNELS');
+  console.log('');
+
+  const dbs = getAllDatabases();
+  if (dbs.length === 0) {
+    logger.dim('  No databases configured.');
+    return;
+  }
+
+  // Compute column widths
+  const cols = {
+    env:     Math.max(11, ...dbs.map(d => d.envAlias.length)),
+    db:      Math.max(8,  ...dbs.map(d => d.handle.length)),
+    alias:   Math.max(5,  ...dbs.map(d => d.alias.length)),
+    port:    6,
+    status:  6,
+    uptime:  11,
+    pid:     6,
+    url:     3,
+  };
+
+  const header = [
+    'ENVIRONMENT'.padEnd(cols.env),
+    'DATABASE'.padEnd(cols.db),
+    'ALIAS'.padEnd(cols.alias),
+    'PORT'.padEnd(cols.port),
+    'STATUS'.padEnd(cols.status),
+    'UPTIME'.padEnd(cols.uptime),
+    'PID'.padEnd(cols.pid),
+    'CONNECTION URL',
+  ].join('  ');
+
+  console.log(chalk.bold(header));
+  console.log(chalk.dim('─'.repeat(Math.min(header.length, 120))));
+
+  for (const db of dbs) {
+    const id      = toIdentifier(db.alias);
+    const running = isRunning(id);
+    const pid     = running ? readPid(id) : null;
+    const uptime  = pid ? getProcessUptime(pid) : null;
+    const conn    = running ? readConnectionInfo(id) : null;
+
+    const statusLabel = running ? 'UP' : 'DOWN';
+    const statusStr   = running ? chalk.green('UP') : chalk.dim('DOWN');
+    const uptimeStr   = running ? formatUptime(uptime) : '-';
+    const pidStr      = pid ? String(pid) : '-';
+    const urlStr      = conn?.url ? chalk.dim(conn.url) : '-';
+
+    // padEnd doesn't account for invisible ANSI escape chars — pad manually
+    const statusPad = ' '.repeat(Math.max(0, cols.status - statusLabel.length));
+
+    const row = [
+      db.envAlias.padEnd(cols.env),
+      db.handle.padEnd(cols.db),
+      db.alias.padEnd(cols.alias),
+      String(db.port).padEnd(cols.port),
+      statusStr + statusPad,
+      uptimeStr.padEnd(cols.uptime),
+      pidStr.padEnd(cols.pid),
+      urlStr,
+    ].join('  ');
+
+    console.log(row);
+  }
+
+  console.log('');
+}