@stagepass/cli 1.0.0

package/bin/index.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import chalk from 'chalk';
+import { setup } from '../src/commands/setup.js';
+import { link } from '../src/commands/link.js';
+import { unlink } from '../src/commands/unlink.js';
+import { start } from '../src/commands/start.js';
+import { stop } from '../src/commands/stop.js';
+import { reload } from '../src/commands/reload.js';
+
+program
+  .name('stagepass')
+  .description('The missing link between Webflow and local dev.')
+  .version('1.0.0');
+
+// Command: SETUP
+program
+  .command('setup')
+  .description('Install dependencies (Caddy, PHP, Dnsmasq) and configure .sp domain')
+  .option('-v, --verbose', 'Show detailed installation logs')
+  .action(async (options) => {
+    try {
+      await setup(options);
+    } catch (error) {
+      console.error(chalk.red('\nSetup failed.'));
+      if (options.verbose) console.error(error);
+      else console.error(chalk.dim('Run with -v for details.'));
+    }
+  });
+
+// Command: LINK
+program
+  .command('link')
+  .description('Link current directory to a .sp domain')
+  .argument('[domain]', 'Domain name (optional)')
+  .option('-v, --verbose', 'Show Caddy reload output')
+  .action(async (domain, options) => {
+    await link(domain, options);
+  });
+
+// Command: UNLINK
+program
+  .command('unlink')
+  .description('Unlink current directory from .sp domain')
+  .argument('[domain]', 'Domain name (optional, defaults to current folder name)')
+  .option('-v, --verbose', 'Show Caddy reload output')
+  .action(async (domain, options) => {
+    await unlink(domain, options);
+  });
+
+// Command: RELOAD
+program
+  .command('reload')
+  .description('Reload Caddy configuration')
+  .option('-v, --verbose', 'Show Caddy reload output')
+  .action(async (options) => {
+    await reload(options);
+  });
+
+// Command: START
+program
+  .command('start')
+  .description('Start background services (Caddy & PHP)')
+  .option('-v, --verbose', 'Show detailed Caddy server logs')
+  .action(async (options) => {
+    await start(options);
+  });
+
+// Command: STOP
+program
+  .command('stop')
+  .description('Stop all background services')
+  .option('-v, --verbose', 'Show detailed stop logs')
+  .action(async (options) => {
+    await stop(options);
+  });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@stagepass/cli",
+  "version": "1.0.0",
+  "description": "Local Development Orchestrator for Webflow",
+  "type": "module",
+  "main": "bin/index.js",
+  "bin": {
+    "stagepass": "./bin/index.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "scripts": {
+    "start": "node bin/index.js"
+  },
+  "keywords": [
+    "webflow",
+    "development",
+    "local",
+    "proxy",
+    "ssl",
+    "caddy",
+    "hot-reload"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/arobertherz/stagepass.git",
+    "directory": "packages/cli"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "execa": "^8.0.0",
+    "fs-extra": "^11.2.0",
+    "inquirer": "^9.2.0",
+    "ora": "^7.0.1",
+    "sudo-prompt": "^9.2.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/commands/link.js

@@ -0,0 +1,79 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import ora from 'ora';
+
+export async function link(domain, options = {}) {
+  const currentDir = process.cwd();
+
+  // Domain logic
+  let targetDomain = domain;
+  if (!targetDomain) {
+    targetDomain = path.basename(currentDir);
+  }
+  targetDomain = targetDomain.replace(/\.sp$/, '') + '.sp';
+
+  // Config paths
+  const caddyDir = path.join(os.homedir(), '.stagepass');
+  const caddyFilePath = path.join(caddyDir, 'Caddyfile');
+
+  const spinner = ora(`Linking ${chalk.bold(targetDomain)}...`).start();
+
+  // 1. Write config
+  try {
+      await fs.ensureDir(caddyDir);
+      
+      let content = '';
+      if (await fs.pathExists(caddyFilePath)) {
+        content = await fs.readFile(caddyFilePath, 'utf-8');
+      }
+
+      const blockStart = `# START: ${targetDomain}`;
+      const blockEnd = `# END: ${targetDomain}`;
+
+      const newBlock = `
+${blockStart}
+${targetDomain} {
+    root * "${currentDir}"
+    php_fastcgi 127.0.0.1:9000
+    file_server
+    tls internal
+    header Access-Control-Allow-Origin *
+}
+${blockEnd}`;
+
+      const regex = new RegExp(`${escapeRegExp(blockStart)}[\\s\\S]*?${escapeRegExp(blockEnd)}`, 'g');
+
+      if (regex.test(content)) {
+        content = content.replace(regex, newBlock.trim());
+      } else {
+        content += `\n${newBlock.trim()}\n`;
+      }
+
+      await fs.writeFile(caddyFilePath, content.trim());
+  } catch (e) {
+      spinner.fail('Failed to write config.');
+      if (options.verbose) console.error(e);
+      return;
+  }
+
+  // 2. Reload Caddy
+  try {
+    // If verbose is ON, show output. If OFF, ignore it (pipe).
+    const stdioMode = options.verbose ? 'inherit' : 'ignore';
+    
+    await execa('caddy', ['reload', '--config', caddyFilePath], { stdio: stdioMode });
+    
+    spinner.succeed(`Linked: https://${targetDomain} -> ${currentDir}`);
+  } catch (error) {
+    spinner.warn('Config written, but Caddy reload failed.');
+    console.log(chalk.dim('   Is Stagepass running? Try: stagepass start'));
+    if (options.verbose) console.error(error);
+  }
+}
+
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/commands/reload.js

@@ -0,0 +1,41 @@
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import ora from 'ora';
+import fs from 'fs-extra';
+
+export async function reload(options = {}) {
+  const caddyDir = path.join(os.homedir(), '.stagepass');
+  const caddyFilePath = path.join(caddyDir, 'Caddyfile');
+
+  const spinner = ora('Reloading Caddy...').start();
+
+  // Check if Caddyfile exists
+  if (!await fs.pathExists(caddyFilePath)) {
+    spinner.fail('No Caddyfile found. Run "stagepass link" first.');
+    return;
+  }
+
+  // Check if Caddy is running
+  try {
+    await execa('caddy', ['version'], { stdio: 'ignore' });
+  } catch (e) {
+    spinner.fail('Caddy is not installed or not accessible.');
+    console.log(chalk.dim('   Run "stagepass setup" to install dependencies.'));
+    return;
+  }
+
+  // Reload Caddy
+  try {
+    const stdioMode = options.verbose ? 'inherit' : 'ignore';
+    
+    await execa('caddy', ['reload', '--config', caddyFilePath], { stdio: stdioMode });
+    
+    spinner.succeed('Caddy reloaded successfully.');
+  } catch (error) {
+    spinner.fail('Failed to reload Caddy.');
+    console.log(chalk.dim('   Is Stagepass running? Try: stagepass start'));
+    if (options.verbose) console.error(error);
+  }
+}

package/src/commands/setup.js

@@ -0,0 +1,111 @@
+import { execa } from 'execa';
+import ora from 'ora';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import sudo from 'sudo-prompt';
+
+const sudoExec = (command) => {
+  return new Promise((resolve, reject) => {
+    sudo.exec(command, { name: 'Stagepass Setup' }, (error, stdout, stderr) => {
+      if (error) reject(error);
+      else resolve(stdout);
+    });
+  });
+};
+
+export async function setup(options = {}) {
+  console.log(chalk.bold('\n🛠  Initializing Stagepass Environment...'));
+  
+  const execOpts = options.verbose ? { stdio: 'inherit' } : {};
+
+  // 1. Check Homebrew
+  const brewSpinner = ora('Checking system requirements...').start();
+  try {
+    await execa('brew', ['--version']);
+    brewSpinner.succeed('System requirements met.');
+  } catch (e) {
+    brewSpinner.fail('Homebrew is missing.');
+    return;
+  }
+
+  // 2. Install Dependencies
+  const installSpinner = ora('Installing dependencies...').start();
+  try {
+    await execa('brew', ['install', 'caddy', 'php', 'dnsmasq'], execOpts);
+    installSpinner.succeed('Core dependencies installed.');
+  } catch (e) {
+    installSpinner.fail('Installation failed.');
+    throw e;
+  }
+  
+  // 3. Configure Dnsmasq (DIRECT WRITE STRATEGY)
+  const dnsSpinner = ora('Configuring local DNS (.sp)...').start();
+  try {
+    const { stdout: brewPrefixRaw } = await execa('brew', ['--prefix']);
+    const brewPrefix = brewPrefixRaw.trim();
+    const mainConfFile = path.join(brewPrefix, 'etc', 'dnsmasq.conf');
+
+    // Ensure config exists
+    if (!await fs.pathExists(mainConfFile)) {
+        await fs.writeFile(mainConfFile, '# Stagepass Config\n');
+    }
+
+    let content = await fs.readFile(mainConfFile, 'utf-8');
+    const rule = 'address=/.sp/127.0.0.1';
+
+    // Check if rule already exists
+    if (!content.includes(rule)) {
+        await fs.appendFile(mainConfFile, `\n\n# Stagepass Rule\n${rule}\n`);
+    }
+
+    dnsSpinner.succeed('Local DNS configured.');
+  } catch (e) {
+    dnsSpinner.fail('DNS config failed.');
+    if (options.verbose) console.error(e);
+    throw e;
+  }
+
+  // 4. Configure System Resolver (Root)
+  const resolverFile = '/etc/resolver/sp';
+  if (!fs.existsSync(resolverFile)) {
+    console.log(chalk.yellow('   sudo access required for system resolver...'));
+    try {
+      const cmd = `mkdir -p /etc/resolver && echo "nameserver 127.0.0.1" > ${resolverFile}`;
+      await sudoExec(cmd);
+      console.log(chalk.green('   ✔ Root permissions granted.'));
+    } catch (e) {
+      console.log(chalk.red('   ❌ Permission denied.'));
+      return;
+    }
+  }
+
+  // 5. Restart DNS Services
+  const restartSpinner = ora('Restarting DNS services...').start();
+  try {
+      // Dnsmasq Restart
+      try {
+        await execa('sudo', ['brew', 'services', 'restart', 'dnsmasq'], execOpts);
+      } catch (e) {
+        await execa('brew', ['services', 'restart', 'dnsmasq'], execOpts);
+      }
+      
+      // DNS Cache Flush
+      try { await execa('sudo', ['killall', '-HUP', 'mDNSResponder']); } catch(e) {}
+      
+      restartSpinner.succeed('DNS services active.');
+  } catch(e) {
+      restartSpinner.warn('Could not restart Dnsmasq automatically.');
+  }
+
+  // 6. Init Caddyfile
+  const caddyDir = path.join(os.homedir(), '.stagepass');
+  await fs.ensureDir(caddyDir);
+  const caddyFile = path.join(caddyDir, 'Caddyfile');
+  if (!await fs.pathExists(caddyFile)) {
+      await fs.writeFile(caddyFile, '# Stagepass Global Config\n');
+  }
+
+  console.log(chalk.green('\n✅ Setup complete!'));
+}

package/src/commands/start.js

@@ -0,0 +1,133 @@
+import { execa } from 'execa';
+import chalk from 'chalk';
+import path from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+import inquirer from 'inquirer';
+import ora from 'ora';
+
+// --- HELPERS ---
+
+async function checkPort443() {
+  try {
+    const cmd = "sudo lsof -iTCP:443 -n -P | grep LISTEN | awk '{print $2}'";
+    const { stdout: rawOutput } = await execa(cmd, { shell: true });
+    
+    if (!rawOutput || !rawOutput.trim()) return null;
+
+    const pids = rawOutput.trim().split('\n');
+    const pid = pids[0].trim();
+    if (!pid) return null;
+    
+    const { stdout: commandPath } = await execa('ps', ['-p', pid, '-o', 'comm=']);
+    const name = path.basename(commandPath.trim());
+
+    const ignoreList = ['Google Chrome', 'Chrome Helper', 'OneDrive', 'Music', 'Safari', 'caddy'];
+    if (ignoreList.some(ignore => name.includes(ignore))) {
+        return null; 
+    }
+
+    return { pid, name };
+  } catch (e) {
+    return null; 
+  }
+}
+
+async function killProcess(proc) {
+  try {
+    if (proc.name.includes('nginx')) {
+        try { await execa('valet', ['stop']); return true; } catch (e) {}
+        try { await execa('brew', ['services', 'stop', 'nginx']); return true; } catch (e) {}
+    }
+    if (proc.name.includes('httpd')) {
+        await execa('sudo', ['apachectl', 'stop']);
+        return true;
+    }
+    await execa('sudo', ['kill', '-9', proc.pid]);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+// --- MAIN COMMAND ---
+
+export async function start(options = {}) {
+  const caddyDir = path.join(os.homedir(), '.stagepass');
+  const caddyFile = path.join(caddyDir, 'Caddyfile');
+  const logFile = path.join(caddyDir, 'server.log');
+
+  console.log(chalk.bold('\n🚀 Starting Stagepass...'));
+
+  // 1. Sudo warm-up (interactive, before spinner starts)
+  try {
+    await execa('sudo', ['-v'], { stdio: 'inherit' });
+  } catch (e) {
+    console.log(chalk.red('❌ Root permissions required.'));
+    return;
+  }
+
+  // 2. Port check (interactive)
+  const conflict = await checkPort443();
+  if (conflict) {
+    console.log(chalk.yellow(`\n⚠️  Port 443 is blocked by: ${chalk.bold(conflict.name)}`));
+    const { shouldKill } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'shouldKill',
+      message: 'Auto-fix conflict?',
+      default: true
+    }]);
+
+    if (shouldKill) {
+      const killSpinner = ora('Freeing port...').start();
+      const success = await killProcess(conflict);
+      if (success) killSpinner.succeed('Port freed.');
+      else {
+        killSpinner.fail('Could not free port.');
+        return;
+      }
+    } else {
+      return;
+    }
+  }
+
+  // 3. Boot services
+  const spinner = ora('Booting background services...').start();
+  
+  // Prepare logging (standard mode)
+  let stdioMode = 'ignore';
+  if (options.verbose) {
+    spinner.stop();
+    console.log(chalk.dim('--- Verbose Logs ---'));
+    stdioMode = 'inherit';
+  } else {
+    // Redirect stdout/stderr to logfile
+    const logStream = fs.openSync(logFile, 'w');
+    stdioMode = ['ignore', logStream, logStream];
+  }
+
+  try {
+    // Start PHP
+    try {
+        await execa('brew', ['services', 'restart', 'php'], { stdio: stdioMode === 'inherit' ? 'inherit' : 'ignore' });
+    } catch (e) { /* ignore php errors */ }
+
+    // Start Caddy
+    // Stop old first
+    try { await execa('caddy', ['stop']); } catch (e) {}
+
+    await execa('caddy', ['start', '--config', caddyFile], { stdio: stdioMode });
+
+    if (!options.verbose) {
+        spinner.succeed(chalk.green('Stagepass is active.'));
+        console.log(chalk.dim(`   Logs: ${logFile}`));
+    }
+
+  } catch (error) {
+    spinner.fail('Failed to start.');
+    if (!options.verbose) {
+        console.log(chalk.red('See error log for details:'));
+        console.log(chalk.dim(logFile));
+    }
+  }
+}

package/src/commands/stop.js

@@ -0,0 +1,41 @@
+import { execa } from 'execa';
+import chalk from 'chalk';
+import ora from 'ora';
+
+export async function stop(options = {}) {
+  console.log(chalk.bold('\n🛑 Stopping Stagepass...'));
+  
+  const spinner = ora('Shutting down services...').start();
+  const stdioMode = options.verbose ? 'inherit' : 'ignore';
+
+  if (options.verbose) {
+      spinner.stop();
+      console.log(chalk.dim('--- Verbose Logs ---'));
+  }
+
+  try {
+    // 1. Stop Caddy
+    try {
+      await execa('caddy', ['stop'], { stdio: stdioMode });
+    } catch (e) {
+      // Ignore if already stopped
+    }
+
+    // 2. Stop PHP (optional, but cleaner)
+    try {
+      await execa('brew', ['services', 'stop', 'php'], { stdio: stdioMode });
+    } catch (e) {
+        // Ignore
+    }
+
+    if (!options.verbose) {
+        spinner.succeed(chalk.green('Services stopped.'));
+    } else {
+        console.log(chalk.green('✔ Services stopped.'));
+    }
+
+  } catch (error) {
+    if (!options.verbose) spinner.fail('Error stopping services.');
+    console.error(chalk.red(error.message));
+  }
+}

package/src/commands/unlink.js

@@ -0,0 +1,71 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import ora from 'ora';
+
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export async function unlink(domain, options = {}) {
+  const currentDir = process.cwd();
+
+  // Domain Logic
+  let targetDomain = domain;
+  if (!targetDomain) {
+    targetDomain = path.basename(currentDir);
+  }
+  targetDomain = targetDomain.replace(/\.sp$/, '') + '.sp';
+
+  // Config Paths
+  const caddyDir = path.join(os.homedir(), '.stagepass');
+  const caddyFilePath = path.join(caddyDir, 'Caddyfile');
+
+  const spinner = ora(`Unlinking ${chalk.bold(targetDomain)}...`).start();
+
+  // 1. Read Config
+  try {
+    if (!await fs.pathExists(caddyFilePath)) {
+      spinner.warn('No Caddyfile found. Nothing to unlink.');
+      return;
+    }
+
+    let content = await fs.readFile(caddyFilePath, 'utf-8');
+
+    const blockStart = `# START: ${targetDomain}`;
+    const blockEnd = `# END: ${targetDomain}`;
+    const regex = new RegExp(`${escapeRegExp(blockStart)}[\\s\\S]*?${escapeRegExp(blockEnd)}`, 'g');
+
+    if (!regex.test(content)) {
+      spinner.warn(`Domain ${chalk.bold(targetDomain)} is not linked.`);
+      return;
+    }
+
+    // Remove the block
+    content = content.replace(regex, '').trim();
+    
+    // Clean up multiple empty lines
+    content = content.replace(/\n{3,}/g, '\n\n');
+
+    await fs.writeFile(caddyFilePath, content);
+  } catch (e) {
+    spinner.fail('Failed to update config.');
+    if (options.verbose) console.error(e);
+    return;
+  }
+
+  // 2. Reload Caddy
+  try {
+    const stdioMode = options.verbose ? 'inherit' : 'ignore';
+    
+    await execa('caddy', ['reload', '--config', caddyFilePath], { stdio: stdioMode });
+    
+    spinner.succeed(`Unlinked: ${targetDomain}`);
+  } catch (error) {
+    spinner.warn('Config updated, but Caddy reload failed.');
+    console.log(chalk.dim('   Is Stagepass running? Try: stagepass start'));
+    if (options.verbose) console.error(error);
+  }
+}