@zeroexcore/tuna 0.1.0

package/.turbo/turbo-test.log

@@ -0,0 +1,14 @@
+
+> @zeroexcore/tuna@0.1.0 test /home/runner/work/tuna/tuna/packages/cli
+> vitest run
+
+
+ RUN  v4.0.18 /home/runner/work/tuna/tuna/packages/cli
+
+ ✓ tests/unit/config.test.ts (23 tests) 9ms
+
+ Test Files  1 passed (1)
+      Tests  23 passed (23)
+   Start at  07:11:47
+   Duration  198ms (transform 47ms, setup 0ms, import 66ms, tests 9ms, environment 0ms)
+

package/.turbo/turbo-typecheck.log

@@ -0,0 +1,4 @@
+
+> @zeroexcore/tuna@0.1.0 typecheck /home/runner/work/tuna/tuna/packages/cli
+> tsc --noEmit
+

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@zeroexcore/tuna",
+  "version": "0.1.0",
+  "description": "Cloudflare Tunnel Wrapper for Development Servers",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zeroexcore/tuna.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/zeroexcore/tuna/issues"
+  },
+  "homepage": "https://github.com/zeroexcore/tuna#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "tuna": "./src/index.ts"
+  },
+  "keywords": [
+    "cloudflare",
+    "tunnel",
+    "dev",
+    "ngrok",
+    "localtunnel",
+    "development",
+    "cloudflared"
+  ],
+  "author": "zeroexcore",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^25.0.10",
+    "@vitest/ui": "^4.0.18",
+    "tsx": "^4.21.0",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "execa": "^9.6.1",
+    "find-up": "^8.0.0",
+    "inquirer": "^13.2.1",
+    "js-yaml": "^4.1.1",
+    "keytar": "^7.9.0",
+    "ora": "^9.1.0"
+  },
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "lint": "eslint src"
+  }
+}

package/src/commands/delete.ts

@@ -0,0 +1,193 @@
+/**
+ * Delete command - delete a tunnel and its DNS records
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { readConfig, generateTunnelName } from '../lib/config.ts';
+import { getCredentials, getRootDomain, listDomains } from '../lib/credentials.ts';
+import { CloudflareAPI } from '../lib/api.ts';
+import { deleteDnsRecordForDomain, listDnsRecordsForTunnel } from '../lib/dns.ts';
+import {
+  stopService,
+  deleteTunnelCredentials,
+  deleteTunnelConfig,
+  isServiceInstalled,
+} from '../lib/service.ts';
+import { removeAccess } from '../lib/access.ts';
+import type { Tunnel } from '../types/index.ts';
+
+/**
+ * Delete a specific tunnel by name or from package.json config
+ */
+export async function deleteCommand(tunnelNameArg?: string | boolean): Promise<void> {
+  console.log('');
+
+  let tunnelName: string;
+  let forward: string | undefined;
+  let rootDomain: string;
+
+  // Determine tunnel name
+  if (tunnelNameArg && typeof tunnelNameArg === 'string') {
+    // Tunnel name provided as argument
+    tunnelName = tunnelNameArg;
+    if (!tunnelName.startsWith('tuna-')) {
+      tunnelName = `tuna-${tunnelName}`;
+    }
+  } else {
+    // Try to read from package.json
+    try {
+      const config = await readConfig();
+      forward = config.forward;
+      tunnelName = generateTunnelName(forward);
+    } catch {
+      // No config found, ask user to specify
+      console.error(chalk.red('No tunnel name specified and no tuna config in package.json.'));
+      console.log(chalk.dim('\nUsage: tuna --delete <tunnel-name>'));
+      console.log(chalk.dim('Or run from a directory with tuna config in package.json.\n'));
+      process.exit(1);
+    }
+  }
+
+  // Get root domain - either from forward or ask user
+  if (forward) {
+    rootDomain = getRootDomain(forward);
+  } else {
+    // Get all configured domains
+    const domains = await listDomains();
+
+    if (domains.length === 0) {
+      console.error(chalk.red('No credentials configured.'));
+      console.log(chalk.dim('Run: tuna --login\n'));
+      process.exit(1);
+    }
+
+    if (domains.length === 1) {
+      rootDomain = domains[0];
+    } else {
+      const { domain } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'domain',
+          message: 'Select domain for this tunnel:',
+          choices: domains,
+        },
+      ]);
+      rootDomain = domain;
+    }
+  }
+
+  // Get credentials
+  const credentials = await getCredentials(rootDomain);
+  if (!credentials) {
+    console.error(chalk.red(`No credentials found for ${rootDomain}`));
+    console.log(chalk.dim('Run: tuna --login\n'));
+    process.exit(1);
+  }
+
+  // Find the tunnel
+  const spinner = ora('Finding tunnel...').start();
+  const api = new CloudflareAPI(credentials);
+
+  let tunnel: Tunnel | undefined;
+  try {
+    const tunnels = await api.listTunnels();
+    tunnel = tunnels.find((t) => t.name === tunnelName && !t.deleted_at);
+  } catch (error) {
+    spinner.fail('Failed to fetch tunnels');
+    console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+    process.exit(1);
+  }
+
+  if (!tunnel) {
+    spinner.fail(`Tunnel not found: ${tunnelName}`);
+    console.log(chalk.dim('\nRun: tuna --list to see all tunnels.\n'));
+    process.exit(1);
+  }
+
+  spinner.stop();
+
+  // Get DNS records for this tunnel
+  let dnsRecords: string[] = [];
+  try {
+    dnsRecords = await listDnsRecordsForTunnel(credentials, tunnel.id, rootDomain);
+  } catch {
+    // Ignore errors
+  }
+
+  // Show what will be deleted
+  console.log(chalk.yellow('The following will be deleted:\n'));
+  console.log(`  Tunnel: ${chalk.cyan(tunnel.name)}`);
+  console.log(`  ID: ${chalk.dim(tunnel.id)}`);
+
+  if (dnsRecords.length > 0) {
+    console.log(`  DNS records: ${dnsRecords.join(', ')}`);
+  }
+
+  console.log('');
+
+  // Confirm deletion
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Are you sure you want to delete this tunnel?',
+      default: false,
+    },
+  ]);
+
+  if (!confirm) {
+    console.log(chalk.dim('\nDeletion cancelled.\n'));
+    return;
+  }
+
+  // Delete process
+  const deleteSpinner = ora('Deleting tunnel...').start();
+
+  try {
+    // 1. Stop service if running
+    deleteSpinner.text = 'Stopping service...';
+    if (isServiceInstalled()) {
+      await stopService();
+    }
+
+    // 2. Delete Access application (if exists)
+    deleteSpinner.text = 'Removing access control...';
+    for (const record of dnsRecords) {
+      try {
+        await removeAccess(credentials, record);
+      } catch {
+        // Ignore errors - may not have permissions or app doesn't exist
+      }
+    }
+
+    // 3. Delete DNS records
+    deleteSpinner.text = 'Deleting DNS records...';
+    for (const record of dnsRecords) {
+      await deleteDnsRecordForDomain(credentials, record);
+    }
+
+    // 4. Delete tunnel from Cloudflare
+    deleteSpinner.text = 'Deleting tunnel...';
+    await api.deleteTunnel(tunnel.id);
+
+    // 5. Delete local files
+    deleteSpinner.text = 'Cleaning up local files...';
+    deleteTunnelCredentials(tunnel.id);
+    deleteTunnelConfig(tunnel.id);
+
+    // 6. Uninstall service if no other tunnels
+    // (We leave the service installed for now - user can manually uninstall)
+
+    deleteSpinner.succeed('Tunnel deleted');
+    console.log('');
+    console.log(chalk.green(`✓ Tunnel ${tunnelName} has been deleted.\n`));
+  } catch (error) {
+    deleteSpinner.fail('Failed to delete tunnel');
+    console.error(chalk.red(`\nError: ${(error as Error).message}`));
+    console.log(chalk.yellow('\nPartial deletion may have occurred.'));
+    console.log(chalk.dim('Check: tuna --list\n'));
+    process.exit(1);
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,219 @@
+/**
+ * Init command - interactive project setup
+ */
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { readFile, writeFile } from 'fs/promises';
+import { findPackageJson } from '../lib/config.ts';
+import { listDomains, getCredentials } from '../lib/credentials.ts';
+
+interface InitAnswers {
+  subdomain: string;
+  port: number;
+  useEnvVar: boolean;
+  enableAccess: boolean;
+  accessRules?: string;
+}
+
+/**
+ * Interactive init flow to setup tuna config in package.json
+ */
+export async function initCommand(): Promise<void> {
+  console.log(chalk.blue('\n🐟 Tuna Project Setup\n'));
+
+  // Check for package.json
+  const pkgPath = await findPackageJson();
+  if (!pkgPath) {
+    console.error(chalk.red('Error: No package.json found.'));
+    console.log(chalk.dim('Run this command from your project directory.'));
+    console.log(chalk.dim('\nTo create a new project:'));
+    console.log(chalk.cyan('  npm init -y'));
+    process.exit(1);
+  }
+
+  // Read existing package.json
+  const pkgContent = await readFile(pkgPath, 'utf-8');
+  const pkg = JSON.parse(pkgContent);
+
+  // Check if tuna config already exists
+  if (pkg.tuna) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: 'Tuna config already exists. Overwrite?',
+        default: false,
+      },
+    ]);
+
+    if (!overwrite) {
+      console.log(chalk.dim('Keeping existing config.'));
+      return;
+    }
+  }
+
+  // Try to get stored credentials to suggest domain
+  let storedDomain: string | undefined;
+  try {
+    // Check if we have any credentials stored
+    const domains = await listDomains();
+    if (domains.length > 0) {
+      // Use the first configured domain
+      const creds = await getCredentials(domains[0]);
+      if (creds) {
+        storedDomain = creds.domain;
+      }
+    }
+  } catch {
+    // No credentials stored, that's fine
+  }
+
+  // Check if credentials are set up
+  if (!storedDomain) {
+    console.log(chalk.yellow('No Cloudflare credentials found.'));
+    console.log(chalk.dim('Run `tuna --login` first to set up your credentials.\n'));
+    
+    const { continueAnyway } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'continueAnyway',
+        message: 'Continue with setup anyway?',
+        default: true,
+      },
+    ]);
+
+    if (!continueAnyway) {
+      console.log(chalk.dim('\nRun `tuna --login` then `tuna --init`'));
+      return;
+    }
+  }
+
+  const domainSuffix = storedDomain ? `.${storedDomain}` : '.example.com';
+  const projectName = pkg.name || 'my-app';
+
+  // Interactive prompts
+  const answers = await inquirer.prompt<InitAnswers>([
+    {
+      type: 'confirm',
+      name: 'useEnvVar',
+      message: 'Use $USER variable for unique subdomains per developer?',
+      default: true,
+    },
+    {
+      type: 'input',
+      name: 'subdomain',
+      message: (answers) => 
+        answers.useEnvVar 
+          ? `Subdomain pattern (will become $USER-<pattern>${domainSuffix}):`
+          : `Full subdomain (will become <subdomain>${domainSuffix}):`,
+      default: projectName.replace(/[^a-z0-9-]/gi, '-').toLowerCase(),
+      validate: (input: string) => {
+        if (!input || input.trim().length === 0) {
+          return 'Subdomain is required';
+        }
+        if (!/^[a-z0-9][a-z0-9-]*$/i.test(input.trim())) {
+          return 'Subdomain must start with a letter/number and contain only letters, numbers, and hyphens';
+        }
+        return true;
+      },
+    },
+    {
+      type: 'number',
+      name: 'port',
+      message: 'Local port to forward:',
+      default: 3000,
+      validate: (input: number) => {
+        if (isNaN(input) || input < 1 || input > 65535) {
+          return 'Port must be between 1 and 65535';
+        }
+        return true;
+      },
+    },
+    {
+      type: 'confirm',
+      name: 'enableAccess',
+      message: 'Enable Zero Trust Access control?',
+      default: false,
+    },
+    {
+      type: 'input',
+      name: 'accessRules',
+      message: 'Access rules (comma-separated emails or @domains):',
+      when: (answers) => answers.enableAccess,
+      default: storedDomain ? `@${storedDomain}` : '@yourcompany.com',
+      validate: (input: string) => {
+        if (!input || input.trim().length === 0) {
+          return 'At least one access rule is required';
+        }
+        return true;
+      },
+    },
+  ]);
+
+  // Build the forward domain
+  const subdomain = answers.subdomain.trim().toLowerCase();
+  const forward = answers.useEnvVar
+    ? `$USER-${subdomain}${domainSuffix}`
+    : `${subdomain}${domainSuffix}`;
+
+  // Build config
+  const tunaConfig: Record<string, unknown> = {
+    forward,
+    port: answers.port,
+  };
+
+  if (answers.enableAccess && answers.accessRules) {
+    tunaConfig.access = answers.accessRules
+      .split(',')
+      .map((rule) => rule.trim())
+      .filter((rule) => rule.length > 0);
+  }
+
+  // Update package.json
+  const spinner = ora('Updating package.json...').start();
+
+  try {
+    pkg.tuna = tunaConfig;
+    
+    // Preserve formatting by using 2-space indent
+    const newContent = JSON.stringify(pkg, null, 2) + '\n';
+    await writeFile(pkgPath, newContent, 'utf-8');
+    
+    spinner.succeed('Configuration saved to package.json');
+  } catch (error) {
+    spinner.fail('Failed to update package.json');
+    console.error(chalk.red(`\nError: ${(error as Error).message}`));
+    process.exit(1);
+  }
+
+  // Show result
+  console.log(chalk.green('\n✓ Tuna configured!\n'));
+  console.log(chalk.dim('Added to package.json:'));
+  console.log(chalk.cyan(JSON.stringify({ tuna: tunaConfig }, null, 2)));
+
+  // Show next steps
+  console.log(chalk.dim('\nNext steps:'));
+  if (!storedDomain) {
+    console.log(chalk.dim('  1. Run: ') + chalk.cyan('tuna --login'));
+    console.log(chalk.dim('  2. Update the domain in package.json'));
+    console.log(chalk.dim('  3. Run: ') + chalk.cyan('tuna npm run dev'));
+  } else {
+    console.log(chalk.dim('  Run: ') + chalk.cyan('tuna npm run dev'));
+  }
+
+  // Show example URL
+  const exampleUser = process.env.USER || 'alice';
+  const exampleUrl = answers.useEnvVar
+    ? `https://${exampleUser}-${subdomain}${domainSuffix}`
+    : `https://${subdomain}${domainSuffix}`;
+  
+  console.log(chalk.dim('\nYour tunnel URL will be:'));
+  console.log(chalk.cyan(`  ${exampleUrl}`));
+  
+  if (answers.useEnvVar) {
+    console.log(chalk.dim(`\n  (Each developer gets their own URL based on $USER)`));
+  }
+  console.log();
+}

package/src/commands/list.ts

@@ -0,0 +1,159 @@
+/**
+ * List command - display all tunnels for configured domains
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { listDomains, getCredentials } from '../lib/credentials.ts';
+import { CloudflareAPI } from '../lib/api.ts';
+import { listDnsRecordsForTunnel } from '../lib/dns.ts';
+import type { Tunnel } from '../types/index.ts';
+
+/**
+ * Format tunnel status with color
+ */
+function formatStatus(status: Tunnel['status']): string {
+  switch (status) {
+    case 'healthy':
+      return chalk.green('● healthy');
+    case 'degraded':
+      return chalk.yellow('● degraded');
+    case 'down':
+      return chalk.red('● down');
+    case 'inactive':
+      return chalk.dim('○ inactive');
+    default:
+      return chalk.dim('○ unknown');
+  }
+}
+
+/**
+ * Format tunnel name (highlight tuna- tunnels)
+ */
+function formatTunnelName(name: string): string {
+  if (name.startsWith('tuna-')) {
+    return chalk.cyan(name);
+  }
+  return chalk.dim(name);
+}
+
+/**
+ * List all tunnels for configured domains
+ */
+export async function listCommand(): Promise<void> {
+  // Get all configured domains
+  const domains = await listDomains();
+
+  if (domains.length === 0) {
+    console.log(chalk.yellow('\nNo credentials configured.'));
+    console.log(chalk.dim('Run: tuna --login\n'));
+    return;
+  }
+
+  // If multiple domains, let user choose
+  let selectedDomain: string;
+
+  if (domains.length === 1) {
+    selectedDomain = domains[0];
+  } else {
+    const { domain } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'domain',
+        message: 'Select domain:',
+        choices: domains,
+      },
+    ]);
+    selectedDomain = domain;
+  }
+
+  // Get credentials
+  const spinner = ora('Fetching tunnels...').start();
+
+  const credentials = await getCredentials(selectedDomain);
+  if (!credentials) {
+    spinner.fail('Failed to get credentials');
+    console.error(chalk.red(`\nNo credentials found for ${selectedDomain}`));
+    return;
+  }
+
+  // Fetch tunnels
+  const api = new CloudflareAPI(credentials);
+  let tunnels: Tunnel[];
+
+  try {
+    tunnels = await api.listTunnels();
+    // Filter out deleted tunnels
+    tunnels = tunnels.filter((t) => !t.deleted_at);
+  } catch (error) {
+    spinner.fail('Failed to fetch tunnels');
+    console.error(chalk.red(`\nError: ${(error as Error).message}`));
+    return;
+  }
+
+  spinner.stop();
+
+  // Separate tuna tunnels from others
+  const tunaTunnels = tunnels.filter((t) => t.name.startsWith('tuna-'));
+  const otherTunnels = tunnels.filter((t) => !t.name.startsWith('tuna-'));
+
+  console.log('');
+  console.log(chalk.bold(`TUNNELS for ${selectedDomain}`), chalk.dim(`(${tunnels.length} total)`));
+  console.log('');
+
+  if (tunaTunnels.length === 0 && otherTunnels.length === 0) {
+    console.log(chalk.dim('  No tunnels found.\n'));
+    return;
+  }
+
+  // Display tuna tunnels
+  if (tunaTunnels.length > 0) {
+    console.log(chalk.dim('  Tuna Tunnels:'));
+
+    for (const tunnel of tunaTunnels) {
+      // Try to get DNS records for this tunnel
+      let dnsRecords: string[] = [];
+      try {
+        dnsRecords = await listDnsRecordsForTunnel(credentials, tunnel.id, selectedDomain);
+      } catch {
+        // Ignore DNS lookup errors
+      }
+
+      const name = formatTunnelName(tunnel.name);
+      const status = formatStatus(tunnel.status);
+      const domains = dnsRecords.length > 0 ? dnsRecords.join(', ') : chalk.dim('no DNS');
+
+      console.log(`    ${name}`);
+      console.log(`      ${status}  ${domains}`);
+    }
+    console.log('');
+  }
+
+  // Display other tunnels (non-tuna)
+  if (otherTunnels.length > 0) {
+    console.log(chalk.dim('  Other Tunnels:'));
+
+    for (const tunnel of otherTunnels) {
+      const name = formatTunnelName(tunnel.name);
+      const status = formatStatus(tunnel.status);
+
+      console.log(`    ${name}  ${status}`);
+    }
+    console.log('');
+  }
+
+  // Show connection info for active tunnels
+  const activeTunnels = tunaTunnels.filter((t) => t.status === 'healthy');
+  if (activeTunnels.length > 0) {
+    console.log(chalk.dim('  Active connections:'));
+    for (const tunnel of activeTunnels) {
+      if (tunnel.connections && tunnel.connections.length > 0) {
+        for (const conn of tunnel.connections) {
+          console.log(chalk.dim(`    ${tunnel.name}: ${conn.colo_name} (${conn.origin_ip})`));
+        }
+      }
+    }
+    console.log('');
+  }
+}