aptunnel 1.0.0

package/src/lib/completions.js

@@ -0,0 +1,216 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { spawnSync } from 'child_process';
+import { logger } from './logger.js';
+import { getConfigPath } from './config-manager.js';
+
+const STATIC_CMDS = ['init', 'login', 'status', 'config', 'completions', 'help', 'all'];
+const STATIC_FLAGS = ['--close', '--force', '--help', '--version', '--port=', '--env='];
+
+/**
+ * Generate bash completion script.
+ * Reads aliases at runtime from config.yaml using awk (no YAML parser needed in bash).
+ */
+export function bashScript() {
+  const configPath = getConfigPath();
+  return `#!/usr/bin/env bash
+# aptunnel bash completion
+# Source this file or add to ~/.bashrc:
+#   source <(aptunnel completions bash)
+
+_aptunnel_completions() {
+  local cur prev
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+  # Get aliases from config at runtime
+  local config="${configPath}"
+  local db_aliases=""
+  local env_aliases=""
+  if [ -f "$config" ]; then
+    db_aliases=$(awk '/^  [a-z]/{if(alias) print alias} /alias:/{alias=$2}' "$config" 2>/dev/null | sort -u)
+    env_aliases=$(awk '/^[a-z].*:$/{env=substr($0,1,length($0)-1)} /  alias:/{print $2}' "$config" 2>/dev/null | sort -u)
+  fi
+
+  local all_cmds="${STATIC_CMDS.join(' ')} $db_aliases"
+
+  case "$prev" in
+    --env)
+      COMPREPLY=( $(compgen -W "$env_aliases" -- "$cur") )
+      return 0
+      ;;
+    --port)
+      # No completion for port numbers
+      return 0
+      ;;
+  esac
+
+  if [[ "$cur" == --* ]]; then
+    COMPREPLY=( $(compgen -W "${STATIC_FLAGS.join(' ')}" -- "$cur") )
+    return 0
+  fi
+
+  COMPREPLY=( $(compgen -W "$all_cmds" -- "$cur") )
+  return 0
+}
+
+complete -F _aptunnel_completions aptunnel
+`;
+}
+
+/**
+ * Generate zsh completion script.
+ */
+export function zshScript() {
+  const configPath = getConfigPath();
+  return `#compdef aptunnel
+# aptunnel zsh completion
+# Add to ~/.zshrc:
+#   source <(aptunnel completions zsh)
+# or copy to a directory in your $fpath.
+
+_aptunnel() {
+  local config="${configPath}"
+  local -a db_aliases env_aliases
+
+  if [[ -f "$config" ]]; then
+    db_aliases=( \${(f)"$(awk '/alias:/{print $2}' "$config" 2>/dev/null | sort -u)"} )
+    env_aliases=( \${(f)"$(awk '/^  alias:/{print $2}' "$config" 2>/dev/null | sort -u)"} )
+  fi
+
+  local -a cmds
+  cmds=(
+    'init:Setup wizard'
+    'login:Login to Aptible or show token status'
+    'status:Show all tunnel statuses'
+    'config:View or modify configuration'
+    'completions:Print shell completion script'
+    'all:Open all tunnels for an environment'
+    'help:Show help'
+  )
+
+  # Add db aliases as commands
+  for alias in $db_aliases; do
+    cmds+=("$alias:Open tunnel to $alias")
+  done
+
+  _arguments -C \\
+    '(-h --help)'{-h,--help}'[Show help]' \\
+    '(-v --version)'{-v,--version}'[Show version]' \\
+    '--close[Close tunnel(s)]' \\
+    '--force[Kill existing process on port conflict]' \\
+    '--port=[Override port]:port:' \\
+    "--env=[Target environment]:env:($env_aliases)" \\
+    '1: :->cmd' \\
+    '*:: :->args'
+
+  case $state in
+    cmd)
+      _describe 'command' cmds
+      ;;
+  esac
+}
+
+_aptunnel "$@"
+`;
+}
+
+/**
+ * Generate fish completion script.
+ */
+export function fishScript() {
+  const configPath = getConfigPath();
+  return `# aptunnel fish completion
+# Copy to ~/.config/fish/completions/aptunnel.fish
+# or run: aptunnel completions install
+
+set -l config_path "${configPath}"
+
+# Helper: extract aliases from config
+function __aptunnel_db_aliases
+  if test -f $config_path
+    awk '/alias:/{print $2}' $config_path 2>/dev/null | sort -u
+  end
+end
+
+function __aptunnel_env_aliases
+  if test -f $config_path
+    awk '/^  alias:/{print $2}' $config_path 2>/dev/null | sort -u
+  end
+end
+
+# Main commands
+complete -c aptunnel -f -n '__fish_use_subcommand' -a 'init'        -d 'Setup wizard'
+complete -c aptunnel -f -n '__fish_use_subcommand' -a 'login'       -d 'Login to Aptible'
+complete -c aptunnel -f -n '__fish_use_subcommand' -a 'status'      -d 'Show tunnel statuses'
+complete -c aptunnel -f -n '__fish_use_subcommand' -a 'config'      -d 'View/modify configuration'
+complete -c aptunnel -f -n '__fish_use_subcommand' -a 'completions' -d 'Print completion script'
+complete -c aptunnel -f -n '__fish_use_subcommand' -a 'all'         -d 'Open all tunnels'
+
+# Dynamic db aliases
+complete -c aptunnel -f -n '__fish_use_subcommand' -a '(__aptunnel_db_aliases)'
+
+# Flags
+complete -c aptunnel -l close   -d 'Close tunnel(s)'
+complete -c aptunnel -l force   -d 'Kill existing process on port conflict'
+complete -c aptunnel -l port    -d 'Override port' -r
+complete -c aptunnel -l env     -d 'Target environment' -r -a '(__aptunnel_env_aliases)'
+complete -c aptunnel -s h -l help    -d 'Show help'
+complete -c aptunnel -s v -l version -d 'Show version'
+`;
+}
+
+/**
+ * Auto-detect shell and install the completion script.
+ */
+export function installCompletions() {
+  const shell = detectShell();
+
+  if (shell === 'bash') {
+    const rcFile = join(homedir(), '.bashrc');
+    const line   = '\n# aptunnel completions\nsource <(aptunnel completions bash)\n';
+    if (existsSync(rcFile) && readFileSync(rcFile, 'utf8').includes('aptunnel completions')) {
+      logger.info('Bash completions already installed in ~/.bashrc.');
+      return;
+    }
+    writeFileSync(rcFile, readFileSync(rcFile, 'utf8') + line);
+    logger.success('Bash completions installed. Restart your shell or run: source ~/.bashrc');
+    return;
+  }
+
+  if (shell === 'zsh') {
+    const rcFile = join(homedir(), '.zshrc');
+    const line   = '\n# aptunnel completions\nsource <(aptunnel completions zsh)\n';
+    if (existsSync(rcFile) && readFileSync(rcFile, 'utf8').includes('aptunnel completions')) {
+      logger.info('Zsh completions already installed in ~/.zshrc.');
+      return;
+    }
+    writeFileSync(rcFile, readFileSync(rcFile, 'utf8') + line);
+    logger.success('Zsh completions installed. Restart your shell or run: source ~/.zshrc');
+    return;
+  }
+
+  if (shell === 'fish') {
+    const fishDir  = join(homedir(), '.config', 'fish', 'completions');
+    const fishFile = join(fishDir, 'aptunnel.fish');
+    mkdirSync(fishDir, { recursive: true });
+    writeFileSync(fishFile, fishScript());
+    logger.success(`Fish completions installed to ${fishFile}. Restart fish to activate.`);
+    return;
+  }
+
+  logger.warn(`Could not detect shell (SHELL=${process.env.SHELL ?? 'unset'}). Use one of:`);
+  logger.plain('  aptunnel completions bash   — bash');
+  logger.plain('  aptunnel completions zsh    — zsh');
+  logger.plain('  aptunnel completions fish   — fish');
+}
+
+function detectShell() {
+  const shell = process.env.SHELL ?? '';
+  if (shell.includes('zsh'))  return 'zsh';
+  if (shell.includes('bash')) return 'bash';
+  if (shell.includes('fish')) return 'fish';
+  return null;
+}

package/src/lib/config-manager.js

@@ -0,0 +1,247 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from 'fs';
+import { homedir, platform } from 'os';
+import { join, dirname } from 'path';
+import { spawnSync } from 'child_process';
+import yaml from 'js-yaml';
+
+// Allow tests to redirect config to a temp directory via APTUNNEL_CONFIG_HOME
+function getConfigHome() {
+  return process.env.APTUNNEL_CONFIG_HOME ?? join(homedir(), '.aptunnel');
+}
+
+// ─── Path helpers ─────────────────────────────────────────────────────────────
+
+export function getConfigDir()   { return getConfigHome(); }
+export function getConfigPath()  { return join(getConfigHome(), 'config.yaml'); }
+export function getCredsPath()   { return join(getConfigHome(), '.credentials'); }
+
+export function exists() {
+  return existsSync(getConfigPath());
+}
+
+// ─── Load / Save ──────────────────────────────────────────────────────────────
+
+/**
+ * Load and parse ~/.aptunnel/config.yaml
+ * @returns {object} parsed config
+ * @throws if file is missing or unparseable
+ */
+export function load() {
+  if (!existsSync(getConfigPath())) {
+    throw new Error(`Config not found. Run \`aptunnel init\` to set up.`);
+  }
+  try {
+    const raw = readFileSync(getConfigPath(), 'utf8');
+    const config = yaml.load(raw);
+    if (!config || typeof config !== 'object') {
+      throw new Error('Config file is empty or invalid.');
+    }
+    return config;
+  } catch (e) {
+    if (e.message.startsWith('Config')) throw e;
+    throw new Error(`Config file is corrupted: ${e.message}. Run \`aptunnel init\` to reinitialize.`);
+  }
+}
+
+/**
+ * Write config object back to ~/.aptunnel/config.yaml
+ * @param {object} config
+ */
+export function save(config) {
+  ensureConfigDir();
+  const raw = yaml.dump(config, { lineWidth: 120, noRefs: true });
+  writeFileSync(getConfigPath(), raw, { mode: 0o600 });
+}
+
+// ─── Credentials ─────────────────────────────────────────────────────────────
+
+/**
+ * Read password from ~/.aptunnel/.credentials
+ * @returns {string | null}
+ */
+export function readPassword() {
+  if (!existsSync(getCredsPath())) return null;
+  try {
+    const content = readFileSync(getCredsPath(), 'utf8');
+    const match = content.match(/^APTUNNEL_PASSWORD=(.+)$/m);
+    return match?.[1]?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save password to ~/.aptunnel/.credentials with restricted permissions.
+ * @param {string} password
+ */
+export function savePassword(password) {
+  ensureConfigDir();
+  const credsPath = getCredsPath();
+  writeFileSync(credsPath, `APTUNNEL_PASSWORD=${password}\n`, { mode: 0o600 });
+
+  if (platform() === 'win32') {
+    // On Windows chmod doesn't restrict access — use icacls
+    try {
+      const username = process.env.USERNAME ?? process.env.USER ?? '';
+      if (username) {
+        spawnSync('icacls', [credsPath, '/inheritance:r', '/grant:r', `${username}:(R,W)`], { encoding: 'utf8' });
+      }
+    } catch {
+      // icacls unavailable — warn via caller
+    }
+  }
+}
+
+// ─── Environment helpers ───────────────────────────────────────────────────────
+
+/**
+ * Resolve an environment alias or handle to its full handle.
+ * @param {string} aliasOrHandle
+ * @returns {string | null}
+ */
+export function getEnvironment(aliasOrHandle) {
+  const config = load();
+  const envs = config.environments ?? {};
+
+  // Direct match by handle
+  if (envs[aliasOrHandle]) return aliasOrHandle;
+
+  // Match by alias
+  for (const [handle, env] of Object.entries(envs)) {
+    if (env.alias === aliasOrHandle) return handle;
+  }
+
+  return null;
+}
+
+/**
+ * Resolve a database alias or handle across all environments.
+ * @param {string} aliasOrHandle
+ * @returns {{ handle: string, environment: string, port: number, type: string, alias: string } | null}
+ */
+export function getDatabase(aliasOrHandle) {
+  const config = load();
+
+  for (const [envHandle, env] of Object.entries(config.environments ?? {})) {
+    const dbs = env.databases ?? {};
+
+    for (const [dbHandle, db] of Object.entries(dbs)) {
+      if (dbHandle === aliasOrHandle || db.alias === aliasOrHandle) {
+        return {
+          handle:      dbHandle,
+          environment: envHandle,
+          port:        db.port,
+          type:        db.type ?? 'unknown',
+          alias:       db.alias ?? dbHandle,
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Return the default environment handle.
+ * @returns {string | null}
+ */
+export function getDefaultEnv() {
+  const config = load();
+  return config.defaults?.environment ?? null;
+}
+
+/**
+ * Update the port for a database.
+ * @param {string} aliasOrHandle
+ * @param {number} port
+ */
+export function setPort(aliasOrHandle, port) {
+  const config = load();
+
+  for (const [, env] of Object.entries(config.environments ?? {})) {
+    const dbs = env.databases ?? {};
+    for (const [dbHandle, db] of Object.entries(dbs)) {
+      if (dbHandle === aliasOrHandle || db.alias === aliasOrHandle) {
+        db.port = port;
+        save(config);
+        return;
+      }
+    }
+  }
+
+  throw new Error(`Database not found: ${aliasOrHandle}`);
+}
+
+/**
+ * Return all databases for an environment (resolved by alias or handle).
+ * @param {string} envAliasOrHandle
+ * @returns {{ handle: string, alias: string, port: number, type: string }[]}
+ */
+export function getAllTunnelTargets(envAliasOrHandle) {
+  const config = load();
+  const envHandle = getEnvironment(envAliasOrHandle) ?? envAliasOrHandle;
+  const env = config.environments?.[envHandle];
+
+  if (!env) return [];
+
+  return Object.entries(env.databases ?? {}).map(([handle, db]) => ({
+    handle,
+    alias: db.alias ?? handle,
+    port:  db.port,
+    type:  db.type ?? 'unknown',
+    environment: envHandle,
+  }));
+}
+
+/**
+ * Return every database across all environments.
+ * @returns {{ handle: string, alias: string, port: number, type: string, environment: string, envAlias: string }[]}
+ */
+export function getAllDatabases() {
+  const config = load();
+  const result = [];
+
+  for (const [envHandle, env] of Object.entries(config.environments ?? {})) {
+    for (const [dbHandle, db] of Object.entries(env.databases ?? {})) {
+      result.push({
+        handle:      dbHandle,
+        alias:       db.alias ?? dbHandle,
+        port:        db.port,
+        type:        db.type ?? 'unknown',
+        environment: envHandle,
+        envAlias:    env.alias ?? envHandle,
+      });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Find the next free port starting from tunnel_defaults.start_port.
+ * @returns {number}
+ */
+export function nextAvailablePort() {
+  const config = load();
+  const start = config.tunnel_defaults?.start_port ?? 55550;
+
+  const usedPorts = new Set();
+  for (const env of Object.values(config.environments ?? {})) {
+    for (const db of Object.values(env.databases ?? {})) {
+      if (db.port) usedPorts.add(db.port);
+    }
+  }
+
+  let port = start;
+  while (usedPorts.has(port)) port++;
+  return port;
+}
+
+// ─── Internal ─────────────────────────────────────────────────────────────────
+
+function ensureConfigDir() {
+  const dir = getConfigHome();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+}

package/src/lib/logger.js

@@ -0,0 +1,26 @@
+import chalk from 'chalk';
+
+export const logger = {
+  success(msg) { console.log(chalk.green('✔ ') + msg); },
+  error(msg)   { console.error(chalk.red('✖ ') + msg); },
+  warn(msg)    { console.warn(chalk.yellow('⚠ ') + msg); },
+  info(msg)    { console.log(chalk.cyan('ℹ ') + msg); },
+  dim(msg)     { console.log(chalk.dim(msg)); },
+  plain(msg)   { console.log(msg); },
+
+  // Print a key/value pair indented under a success/info block
+  detail(key, value) {
+    const k = chalk.dim(key.padEnd(10));
+    console.log(`  ${k} ${value}`);
+  },
+
+  // Print a section header
+  section(title) {
+    console.log('\n' + chalk.bold.underline(title));
+  },
+
+  // Print a horizontal rule
+  rule() {
+    console.log(chalk.dim('─'.repeat(60)));
+  },
+};