bindler 1.0.2 → 1.1.0

package/dist/cli.js

@@ -2,6 +2,7 @@
 
 // src/cli.ts
 import { Command } from "commander";
+import chalk26 from "chalk";
 
 // src/commands/new.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
@@ -161,28 +162,28 @@ function execCommandSafe(command, options) {
   }
 }
 function spawnInteractive(command, args, options) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const child = spawn(command, args, {
       stdio: "inherit",
       ...options
     });
     child.on("close", (code) => {
-      resolve(code);
+      resolve2(code);
     });
   });
 }
 function isPortListening(port, host = "127.0.0.1") {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const socket = createConnection({ port, host }, () => {
       socket.destroy();
-      resolve(true);
+      resolve2(true);
     });
     socket.on("error", () => {
-      resolve(false);
+      resolve2(false);
     });
     socket.setTimeout(1e3, () => {
       socket.destroy();
-      resolve(false);
+      resolve2(false);
     });
   });
 }
@@ -1757,7 +1758,7 @@ async function infoCommand() {
   `));
   console.log(chalk14.white("  Manage multiple projects behind Cloudflare Tunnel"));
   console.log(chalk14.white("  with Nginx and PM2\n"));
-  console.log(chalk14.dim("  Version:  ") + chalk14.white("1.0.2"));
+  console.log(chalk14.dim("  Version:  ") + chalk14.white("1.1.0"));
   console.log(chalk14.dim("  Author:   ") + chalk14.white("alfaoz"));
   console.log(chalk14.dim("  License:  ") + chalk14.white("MIT"));
   console.log(chalk14.dim("  GitHub:   ") + chalk14.cyan("https://github.com/alfaoz/bindler"));
@@ -2190,6 +2191,909 @@ async function setupCommand(options = {}) {
   console.log(chalk16.dim("\nRun `bindler new` to create your first project."));
 }
 
+// src/commands/init.ts
+import chalk17 from "chalk";
+import inquirer4 from "inquirer";
+async function initCommand() {
+  console.log(chalk17.bold.cyan(`
+   _   _       _ _
+  | |_|_|___ _| | |___ ___
+  | . | |   | . | | -_|  _|
+  |___|_|_|_|___|_|___|_|
+  `));
+  console.log(chalk17.white("  Welcome to bindler!\n"));
+  if (configExists()) {
+    const config2 = readConfig();
+    console.log(chalk17.yellow("Bindler is already initialized."));
+    console.log(chalk17.dim(`  Config: ~/.config/bindler/config.json`));
+    console.log(chalk17.dim(`  Mode: ${config2.defaults.mode || "tunnel"}`));
+    console.log(chalk17.dim(`  Projects: ${config2.projects.length}`));
+    console.log("");
+    const { reinit } = await inquirer4.prompt([
+      {
+        type: "confirm",
+        name: "reinit",
+        message: "Reconfigure bindler?",
+        default: false
+      }
+    ]);
+    if (!reinit) {
+      console.log(chalk17.dim("\nRun `bindler new` to add a project."));
+      return;
+    }
+  }
+  console.log(chalk17.bold("\n1. Choose your setup:\n"));
+  const { mode } = await inquirer4.prompt([
+    {
+      type: "list",
+      name: "mode",
+      message: "How will you expose your projects?",
+      choices: [
+        {
+          name: "Cloudflare Tunnel (recommended for home servers)",
+          value: "tunnel"
+        },
+        {
+          name: "Direct (VPS with public IP, port 80/443)",
+          value: "direct"
+        },
+        {
+          name: "Local only (development, no internet access)",
+          value: "local"
+        }
+      ]
+    }
+  ]);
+  console.log(chalk17.bold("\n2. Checking dependencies...\n"));
+  const deps = {
+    nginx: isNginxInstalled(),
+    pm2: isPm2Installed(),
+    cloudflared: isCloudflaredInstalled()
+  };
+  const nginxRunning = deps.nginx && isNginxRunning();
+  console.log(deps.nginx ? chalk17.green("  \u2713 nginx") : chalk17.red("  \u2717 nginx"));
+  console.log(deps.pm2 ? chalk17.green("  \u2713 pm2") : chalk17.red("  \u2717 pm2"));
+  if (mode === "tunnel") {
+    console.log(deps.cloudflared ? chalk17.green("  \u2713 cloudflared") : chalk17.red("  \u2717 cloudflared"));
+  } else if (mode === "direct") {
+    console.log(chalk17.dim("  - cloudflared (not needed for direct mode)"));
+  }
+  const missingDeps = !deps.nginx || !deps.pm2 || mode === "tunnel" && !deps.cloudflared;
+  if (missingDeps) {
+    console.log("");
+    const { install } = await inquirer4.prompt([
+      {
+        type: "confirm",
+        name: "install",
+        message: "Install missing dependencies?",
+        default: true
+      }
+    ]);
+    if (install) {
+      await setupCommand({ direct: mode === "direct" });
+    }
+  }
+  console.log(chalk17.bold("\n3. Configuration:\n"));
+  let tunnelName = "homelab";
+  let sslEmail = "";
+  if (mode === "tunnel") {
+    const answers = await inquirer4.prompt([
+      {
+        type: "input",
+        name: "tunnelName",
+        message: "Cloudflare tunnel name:",
+        default: "homelab"
+      }
+    ]);
+    tunnelName = answers.tunnelName;
+  }
+  if (mode === "direct") {
+    const answers = await inquirer4.prompt([
+      {
+        type: "confirm",
+        name: "enableSsl",
+        message: "Enable SSL with Let's Encrypt?",
+        default: true
+      }
+    ]);
+    if (answers.enableSsl) {
+      const emailAnswer = await inquirer4.prompt([
+        {
+          type: "input",
+          name: "email",
+          message: "Email for SSL certificates:",
+          validate: (input) => input.includes("@") || "Enter a valid email"
+        }
+      ]);
+      sslEmail = emailAnswer.email;
+    }
+  }
+  const config = configExists() ? readConfig() : initConfig();
+  config.defaults.mode = mode === "local" ? "tunnel" : mode;
+  config.defaults.tunnelName = tunnelName;
+  config.defaults.applyCloudflareDnsRoutes = mode === "tunnel";
+  if (mode === "direct") {
+    config.defaults.nginxListen = "80";
+    if (sslEmail) {
+      config.defaults.sslEnabled = true;
+      config.defaults.sslEmail = sslEmail;
+    }
+  } else if (mode === "local") {
+    config.defaults.nginxListen = "127.0.0.1:8080";
+    config.defaults.applyCloudflareDnsRoutes = false;
+  } else {
+    config.defaults.nginxListen = "127.0.0.1:8080";
+  }
+  writeConfig(config);
+  console.log(chalk17.green("\n\u2713 Bindler initialized!\n"));
+  console.log(chalk17.dim("  Mode:    ") + chalk17.white(mode));
+  console.log(chalk17.dim("  Listen:  ") + chalk17.white(config.defaults.nginxListen));
+  if (mode === "tunnel") {
+    console.log(chalk17.dim("  Tunnel:  ") + chalk17.white(tunnelName));
+  }
+  if (sslEmail) {
+    console.log(chalk17.dim("  SSL:     ") + chalk17.white(sslEmail));
+  }
+  console.log(chalk17.bold("\nNext steps:\n"));
+  console.log(chalk17.dim("  1. ") + chalk17.white("bindler new") + chalk17.dim("        # add your first project"));
+  console.log(chalk17.dim("  2. ") + chalk17.white("bindler apply") + chalk17.dim("      # apply nginx config"));
+  if (mode === "tunnel") {
+    console.log(chalk17.dim("  3. ") + chalk17.white(`cloudflared tunnel run ${tunnelName}`) + chalk17.dim("  # start tunnel"));
+  }
+  console.log("");
+}
+
+// src/commands/deploy.ts
+import chalk18 from "chalk";
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import { join as join5 } from "path";
+function runInDir(command, cwd) {
+  try {
+    const output = execSync3(command, { cwd, encoding: "utf-8", stdio: "pipe" });
+    return { success: true, output: output.trim() };
+  } catch (error) {
+    const err = error;
+    return { success: false, output: err.stderr || err.message || "Unknown error" };
+  }
+}
+async function deployCommand(name, options) {
+  if (!name) {
+    console.log(chalk18.red("Usage: bindler deploy <name>"));
+    console.log(chalk18.dim("\nDeploys a project: git pull + npm install + restart"));
+    console.log(chalk18.dim("\nExamples:"));
+    console.log(chalk18.dim("  bindler deploy myapp"));
+    console.log(chalk18.dim("  bindler deploy myapp --skip-install"));
+    console.log(chalk18.dim("  bindler deploy myapp --skip-pull"));
+    process.exit(1);
+  }
+  const project = getProject(name);
+  if (!project) {
+    console.log(chalk18.red(`Project "${name}" not found.`));
+    console.log(chalk18.dim("\nAvailable projects:"));
+    const projects = listProjects();
+    for (const p of projects) {
+      console.log(chalk18.dim(`  - ${p.name}`));
+    }
+    process.exit(1);
+  }
+  if (!existsSync7(project.path)) {
+    console.log(chalk18.red(`Project path does not exist: ${project.path}`));
+    process.exit(1);
+  }
+  console.log(chalk18.blue(`
+Deploying ${project.name}...
+`));
+  if (!options.skipPull) {
+    const isGitRepo = existsSync7(join5(project.path, ".git"));
+    if (isGitRepo) {
+      console.log(chalk18.dim("Pulling latest changes..."));
+      const result = runInDir("git pull", project.path);
+      if (result.success) {
+        if (result.output.includes("Already up to date")) {
+          console.log(chalk18.green("  \u2713 Already up to date"));
+        } else {
+          console.log(chalk18.green("  \u2713 Pulled latest changes"));
+          if (result.output) {
+            console.log(chalk18.dim(`    ${result.output.split("\n")[0]}`));
+          }
+        }
+      } else {
+        console.log(chalk18.yellow("  ! Git pull failed"));
+        console.log(chalk18.dim(`    ${result.output}`));
+      }
+    } else {
+      console.log(chalk18.dim("  - Not a git repository, skipping pull"));
+    }
+  } else {
+    console.log(chalk18.dim("  - Skipped git pull (--skip-pull)"));
+  }
+  if (project.type === "npm" && !options.skipInstall) {
+    const hasPackageJson = existsSync7(join5(project.path, "package.json"));
+    if (hasPackageJson) {
+      console.log(chalk18.dim("Installing dependencies..."));
+      const result = runInDir("npm install", project.path);
+      if (result.success) {
+        console.log(chalk18.green("  \u2713 Dependencies installed"));
+      } else {
+        console.log(chalk18.yellow("  ! npm install failed"));
+        console.log(chalk18.dim(`    ${result.output.split("\n")[0]}`));
+      }
+    }
+  } else if (options.skipInstall) {
+    console.log(chalk18.dim("  - Skipped npm install (--skip-install)"));
+  }
+  if (project.type === "npm" && !options.skipRestart) {
+    console.log(chalk18.dim("Restarting application..."));
+    const result = restartProject(name);
+    if (result.success) {
+      console.log(chalk18.green("  \u2713 Application restarted"));
+    } else {
+      console.log(chalk18.yellow(`  ! Restart failed: ${result.error}`));
+      console.log(chalk18.dim(`    Try: bindler start ${name}`));
+    }
+  } else if (project.type === "static") {
+    console.log(chalk18.dim("  - Static project, no restart needed"));
+  } else if (options.skipRestart) {
+    console.log(chalk18.dim("  - Skipped restart (--skip-restart)"));
+  }
+  console.log(chalk18.green(`
+\u2713 Deploy complete for ${project.name}
+`));
+}
+
+// src/commands/backup.ts
+import chalk19 from "chalk";
+import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname3, resolve } from "path";
+import { homedir as homedir2 } from "os";
+async function backupCommand(options) {
+  const config = readConfig();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const defaultPath = resolve(homedir2(), `bindler-backup-${timestamp}.json`);
+  const outputPath = options.output || defaultPath;
+  const dir = dirname3(outputPath);
+  if (!existsSync8(dir)) {
+    mkdirSync4(dir, { recursive: true });
+  }
+  const backup = {
+    version: 1,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    config
+  };
+  writeFileSync4(outputPath, JSON.stringify(backup, null, 2) + "\n");
+  console.log(chalk19.green(`
+\u2713 Backup saved to ${outputPath}
+`));
+  console.log(chalk19.dim(`  Projects: ${config.projects.length}`));
+  console.log(chalk19.dim(`  Mode: ${config.defaults.mode || "tunnel"}`));
+  console.log("");
+  console.log(chalk19.dim("Restore with:"));
+  console.log(chalk19.cyan(`  bindler restore ${outputPath}`));
+  console.log("");
+}
+async function restoreCommand(file, options) {
+  if (!file) {
+    console.log(chalk19.red("Usage: bindler restore <file>"));
+    console.log(chalk19.dim("\nExamples:"));
+    console.log(chalk19.dim("  bindler restore ~/bindler-backup.json"));
+    console.log(chalk19.dim("  bindler restore backup.json --force"));
+    process.exit(1);
+  }
+  const filePath = resolve(file);
+  if (!existsSync8(filePath)) {
+    console.log(chalk19.red(`File not found: ${filePath}`));
+    process.exit(1);
+  }
+  let backup;
+  try {
+    const content = readFileSync5(filePath, "utf-8");
+    backup = JSON.parse(content);
+  } catch (error) {
+    console.log(chalk19.red("Invalid backup file. Must be valid JSON."));
+    process.exit(1);
+  }
+  if (!backup.config || !backup.config.defaults || !Array.isArray(backup.config.projects)) {
+    console.log(chalk19.red("Invalid backup format. Missing config data."));
+    process.exit(1);
+  }
+  console.log(chalk19.blue("\nBackup info:\n"));
+  console.log(chalk19.dim("  Exported: ") + chalk19.white(backup.exportedAt || "unknown"));
+  console.log(chalk19.dim("  Projects: ") + chalk19.white(backup.config.projects.length));
+  console.log(chalk19.dim("  Mode:     ") + chalk19.white(backup.config.defaults.mode || "tunnel"));
+  console.log("");
+  const currentConfig = readConfig();
+  if (currentConfig.projects.length > 0 && !options.force) {
+    console.log(chalk19.yellow(`Warning: You have ${currentConfig.projects.length} existing project(s).`));
+    console.log(chalk19.dim("Use --force to overwrite.\n"));
+    process.exit(1);
+  }
+  writeConfig(backup.config);
+  console.log(chalk19.green("\u2713 Config restored!\n"));
+  console.log(chalk19.dim("Run `bindler apply` to apply nginx configuration."));
+  console.log("");
+}
+
+// src/commands/ssl.ts
+import chalk20 from "chalk";
+async function sslCommand(hostname, options) {
+  if (!hostname) {
+    console.log(chalk20.red("Usage: bindler ssl <hostname>"));
+    console.log(chalk20.dim("\nRequest SSL certificate for a hostname"));
+    console.log(chalk20.dim("\nExamples:"));
+    console.log(chalk20.dim("  bindler ssl myapp.example.com"));
+    console.log(chalk20.dim("  bindler ssl myapp              # uses project hostname"));
+    console.log(chalk20.dim("  bindler ssl myapp --email me@example.com"));
+    process.exit(1);
+  }
+  const project = getProject(hostname);
+  const targetHostname = project ? project.hostname : hostname;
+  const certbotCheck = execCommandSafe("which certbot");
+  if (!certbotCheck.success) {
+    console.log(chalk20.red("certbot is not installed."));
+    console.log(chalk20.dim("\nInstall with:"));
+    console.log(chalk20.dim("  macOS: brew install certbot"));
+    console.log(chalk20.dim("  Linux: apt install certbot python3-certbot-nginx"));
+    process.exit(1);
+  }
+  const defaults = getDefaults();
+  const email = options.email || defaults.sslEmail || `admin@${targetHostname.split(".").slice(-2).join(".")}`;
+  console.log(chalk20.blue(`
+Requesting SSL certificate for ${targetHostname}...
+`));
+  let cmd = `sudo certbot --nginx -d ${targetHostname} --non-interactive --agree-tos --email ${email}`;
+  if (options.staging) {
+    cmd += " --staging";
+    console.log(chalk20.yellow("Using staging server (test certificate)\n"));
+  }
+  console.log(chalk20.dim(`Running: ${cmd}
+`));
+  const result = execCommandSafe(cmd + " 2>&1");
+  if (result.success) {
+    console.log(chalk20.green(`
+\u2713 SSL certificate installed for ${targetHostname}
+`));
+    console.log(chalk20.dim("Certificate will auto-renew via certbot timer."));
+  } else if (result.output?.includes("Certificate not yet due for renewal")) {
+    console.log(chalk20.green(`
+\u2713 Certificate already exists and is valid
+`));
+    console.log(chalk20.dim("Use --force with certbot to renew early if needed."));
+  } else if (result.output?.includes("too many certificates")) {
+    console.log(chalk20.red("\n\u2717 Rate limit reached"));
+    console.log(chalk20.dim("Let's Encrypt limits certificates per domain."));
+    console.log(chalk20.dim("Try again later or use --staging for testing."));
+  } else if (result.output?.includes("Could not bind")) {
+    console.log(chalk20.red("\n\u2717 Port 80 is in use"));
+    console.log(chalk20.dim("Stop nginx temporarily or use webroot method."));
+  } else {
+    console.log(chalk20.red("\n\u2717 Certificate request failed\n"));
+    if (result.output) {
+      const lines = result.output.split("\n").filter(
+        (l) => l.includes("Error") || l.includes("error") || l.includes("failed") || l.includes("Challenge")
+      );
+      for (const line of lines.slice(0, 5)) {
+        console.log(chalk20.dim(`  ${line.trim()}`));
+      }
+    }
+    console.log(chalk20.dim("\nCommon issues:"));
+    console.log(chalk20.dim("  - DNS not pointing to this server"));
+    console.log(chalk20.dim("  - Port 80 not accessible from internet"));
+    console.log(chalk20.dim("  - Firewall blocking HTTP validation"));
+  }
+  console.log("");
+}
+
+// src/commands/tunnel.ts
+import chalk21 from "chalk";
+import { execSync as execSync4, spawn as spawn2 } from "child_process";
+async function tunnelCommand(action, options) {
+  if (!action) {
+    console.log(chalk21.red("Usage: bindler tunnel <action>"));
+    console.log(chalk21.dim("\nActions:"));
+    console.log(chalk21.dim("  status    Show tunnel status"));
+    console.log(chalk21.dim("  start     Start the tunnel"));
+    console.log(chalk21.dim("  stop      Stop the tunnel"));
+    console.log(chalk21.dim("  login     Authenticate with Cloudflare"));
+    console.log(chalk21.dim("  create    Create a new tunnel"));
+    console.log(chalk21.dim("  list      List all tunnels"));
+    console.log(chalk21.dim("\nExamples:"));
+    console.log(chalk21.dim("  bindler tunnel status"));
+    console.log(chalk21.dim("  bindler tunnel start"));
+    console.log(chalk21.dim("  bindler tunnel create --name mytunnel"));
+    process.exit(1);
+  }
+  if (!isCloudflaredInstalled()) {
+    console.log(chalk21.red("cloudflared is not installed."));
+    console.log(chalk21.dim("\nInstall with: bindler setup"));
+    process.exit(1);
+  }
+  const defaults = getDefaults();
+  const tunnelName = options.name || defaults.tunnelName;
+  switch (action) {
+    case "status": {
+      console.log(chalk21.blue("\nTunnel Status\n"));
+      const info = getTunnelInfo(tunnelName);
+      if (!info.exists) {
+        console.log(chalk21.yellow(`Tunnel "${tunnelName}" does not exist.`));
+        console.log(chalk21.dim(`
+Create with: bindler tunnel create --name ${tunnelName}`));
+      } else {
+        console.log(chalk21.dim("  Name:    ") + chalk21.white(tunnelName));
+        console.log(chalk21.dim("  ID:      ") + chalk21.white(info.id || "unknown"));
+        console.log(chalk21.dim("  Running: ") + (info.running ? chalk21.green("yes") : chalk21.red("no")));
+        if (!info.running) {
+          console.log(chalk21.dim(`
+Start with: bindler tunnel start`));
+        }
+      }
+      console.log("");
+      break;
+    }
+    case "start": {
+      const info = getTunnelInfo(tunnelName);
+      if (!info.exists) {
+        console.log(chalk21.red(`Tunnel "${tunnelName}" does not exist.`));
+        console.log(chalk21.dim(`Create with: bindler tunnel create`));
+        process.exit(1);
+      }
+      if (info.running) {
+        console.log(chalk21.yellow(`Tunnel "${tunnelName}" is already running.`));
+        process.exit(0);
+      }
+      console.log(chalk21.blue(`Starting tunnel "${tunnelName}"...
+`));
+      console.log(chalk21.dim("Running in foreground. Press Ctrl+C to stop.\n"));
+      const child = spawn2("cloudflared", ["tunnel", "run", tunnelName], {
+        stdio: "inherit"
+      });
+      child.on("error", (err) => {
+        console.log(chalk21.red(`Failed to start tunnel: ${err.message}`));
+        process.exit(1);
+      });
+      child.on("exit", (code) => {
+        console.log(chalk21.dim(`
+Tunnel exited with code ${code}`));
+        process.exit(code || 0);
+      });
+      break;
+    }
+    case "stop": {
+      console.log(chalk21.blue("Stopping tunnel...\n"));
+      const result = execCommandSafe(`pkill -f "cloudflared.*tunnel.*run.*${tunnelName}"`);
+      if (result.success) {
+        console.log(chalk21.green(`\u2713 Tunnel "${tunnelName}" stopped`));
+      } else {
+        console.log(chalk21.yellow(`Tunnel "${tunnelName}" was not running.`));
+      }
+      console.log("");
+      break;
+    }
+    case "login": {
+      console.log(chalk21.blue("Authenticating with Cloudflare...\n"));
+      console.log(chalk21.dim("A browser window will open. Follow the instructions.\n"));
+      try {
+        execSync4("cloudflared tunnel login", { stdio: "inherit" });
+        console.log(chalk21.green("\n\u2713 Authentication successful!"));
+      } catch {
+        console.log(chalk21.red("\n\u2717 Authentication failed or cancelled."));
+      }
+      console.log("");
+      break;
+    }
+    case "create": {
+      const existingTunnels = listTunnels();
+      const exists = existingTunnels.some((t) => t.name === tunnelName);
+      if (exists) {
+        console.log(chalk21.yellow(`Tunnel "${tunnelName}" already exists.`));
+        console.log(chalk21.dim("\nUse a different name with --name"));
+        process.exit(1);
+      }
+      console.log(chalk21.blue(`Creating tunnel "${tunnelName}"...
+`));
+      try {
+        execSync4(`cloudflared tunnel create ${tunnelName}`, { stdio: "inherit" });
+        console.log(chalk21.green(`
+\u2713 Tunnel "${tunnelName}" created!`));
+        console.log(chalk21.dim("\nNext steps:"));
+        console.log(chalk21.dim("  1. Create ~/.cloudflared/config.yml"));
+        console.log(chalk21.dim("  2. Run: bindler tunnel start"));
+      } catch {
+        console.log(chalk21.red("\n\u2717 Failed to create tunnel."));
+        console.log(chalk21.dim("Make sure you're logged in: bindler tunnel login"));
+      }
+      console.log("");
+      break;
+    }
+    case "list": {
+      console.log(chalk21.blue("\nCloudflare Tunnels\n"));
+      const tunnels = listTunnels();
+      if (tunnels.length === 0) {
+        console.log(chalk21.dim("No tunnels found."));
+        console.log(chalk21.dim("\nCreate one with: bindler tunnel create"));
+      } else {
+        for (const tunnel of tunnels) {
+          const isDefault = tunnel.name === tunnelName;
+          const prefix = isDefault ? chalk21.cyan("\u2192 ") : "  ";
+          console.log(prefix + chalk21.white(tunnel.name) + chalk21.dim(` (${tunnel.id.slice(0, 8)}...)`));
+        }
+        console.log(chalk21.dim(`
+${tunnels.length} tunnel(s)`));
+      }
+      console.log("");
+      break;
+    }
+    default:
+      console.log(chalk21.red(`Unknown action: ${action}`));
+      console.log(chalk21.dim("Run `bindler tunnel` for usage."));
+      process.exit(1);
+  }
+}
+
+// src/commands/open.ts
+import chalk22 from "chalk";
+import { exec } from "child_process";
+async function openCommand(name) {
+  if (!name) {
+    console.log(chalk22.red("Usage: bindler open <name>"));
+    console.log(chalk22.dim("\nOpen a project in your browser"));
+    console.log(chalk22.dim("\nExamples:"));
+    console.log(chalk22.dim("  bindler open myapp"));
+    process.exit(1);
+  }
+  const project = getProject(name);
+  if (!project) {
+    console.log(chalk22.red(`Project "${name}" not found.`));
+    console.log(chalk22.dim("\nAvailable projects:"));
+    const projects = listProjects();
+    for (const p of projects) {
+      console.log(chalk22.dim(`  - ${p.name}`));
+    }
+    process.exit(1);
+  }
+  const defaults = getDefaults();
+  const isLocal = project.local || project.hostname.endsWith(".local");
+  const isDirect = defaults.mode === "direct";
+  let url;
+  if (isLocal) {
+    const port = defaults.nginxListen.includes(":") ? defaults.nginxListen.split(":")[1] : defaults.nginxListen;
+    url = `http://${project.hostname}:${port}`;
+  } else if (isDirect && defaults.sslEnabled) {
+    url = `https://${project.hostname}`;
+  } else if (isDirect) {
+    url = `http://${project.hostname}`;
+  } else {
+    url = `https://${project.hostname}`;
+  }
+  if (project.basePath && project.basePath !== "/") {
+    url += project.basePath;
+  }
+  console.log(chalk22.dim(`Opening ${url}...`));
+  const platform = process.platform;
+  let cmd;
+  if (platform === "darwin") {
+    cmd = `open "${url}"`;
+  } else if (platform === "win32") {
+    cmd = `start "${url}"`;
+  } else {
+    cmd = `xdg-open "${url}"`;
+  }
+  exec(cmd, (error) => {
+    if (error) {
+      console.log(chalk22.yellow(`Could not open browser automatically.`));
+      console.log(chalk22.dim(`
+Open manually: ${chalk22.cyan(url)}`));
+    }
+  });
+}
+
+// src/commands/health.ts
+import chalk23 from "chalk";
+async function pingUrl(url, timeout = 5e3) {
+  const start = Date.now();
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const response = await fetch(url, {
+      method: "HEAD",
+      redirect: "follow",
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    return {
+      ok: response.ok,
+      status: response.status,
+      time: Date.now() - start
+    };
+  } catch (error) {
+    const err = error;
+    return {
+      ok: false,
+      error: err.name === "AbortError" ? "timeout" : err.message,
+      time: Date.now() - start
+    };
+  }
+}
+async function healthCommand() {
+  const projects = listProjects();
+  const defaults = getDefaults();
+  if (projects.length === 0) {
+    console.log(chalk23.yellow("\nNo projects registered."));
+    console.log(chalk23.dim("Run `bindler new` to add a project.\n"));
+    return;
+  }
+  console.log(chalk23.blue("\nHealth Check\n"));
+  const results = [];
+  for (const project of projects) {
+    if (project.enabled === false) {
+      console.log(chalk23.dim(`  - ${project.name} (disabled)`));
+      continue;
+    }
+    const isLocal = project.local || project.hostname.endsWith(".local");
+    const isDirect = defaults.mode === "direct";
+    let url;
+    if (isLocal) {
+      const port = defaults.nginxListen.includes(":") ? defaults.nginxListen.split(":")[1] : defaults.nginxListen;
+      url = `http://${project.hostname}:${port}`;
+    } else if (isDirect && defaults.sslEnabled) {
+      url = `https://${project.hostname}`;
+    } else if (isDirect) {
+      url = `http://${project.hostname}`;
+    } else {
+      url = `https://${project.hostname}`;
+    }
+    if (project.basePath && project.basePath !== "/") {
+      url += project.basePath;
+    }
+    process.stdout.write(chalk23.dim(`  Checking ${project.name}...`));
+    const result = await pingUrl(url);
+    results.push({ name: project.name, hostname: project.hostname, ...result });
+    process.stdout.write("\r\x1B[K");
+    if (result.ok) {
+      console.log(chalk23.green("  \u2713 ") + chalk23.white(project.name) + chalk23.dim(` (${result.time}ms)`));
+    } else if (result.status) {
+      console.log(chalk23.yellow("  ! ") + chalk23.white(project.name) + chalk23.dim(` (${result.status})`));
+    } else {
+      console.log(chalk23.red("  \u2717 ") + chalk23.white(project.name) + chalk23.dim(` (${result.error})`));
+    }
+  }
+  const healthy = results.filter((r) => r.ok).length;
+  const unhealthy = results.filter((r) => !r.ok).length;
+  console.log("");
+  if (unhealthy === 0) {
+    console.log(chalk23.green(`\u2713 All ${healthy} project(s) healthy`));
+  } else if (healthy === 0) {
+    console.log(chalk23.red(`\u2717 All ${unhealthy} project(s) down`));
+  } else {
+    console.log(chalk23.yellow(`! ${healthy} healthy, ${unhealthy} down`));
+  }
+  console.log("");
+}
+
+// src/commands/stats.ts
+import chalk24 from "chalk";
+function formatBytes2(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
+}
+function formatUptime2(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m`;
+  return `${seconds}s`;
+}
+async function statsCommand() {
+  const projects = listProjects();
+  const pm2Processes = getPm2List();
+  const npmProjects = projects.filter((p) => p.type === "npm");
+  if (npmProjects.length === 0) {
+    console.log(chalk24.yellow("\nNo npm projects registered."));
+    console.log(chalk24.dim("Stats are only available for npm projects.\n"));
+    return;
+  }
+  console.log(chalk24.blue("\nProject Stats\n"));
+  console.log(
+    chalk24.dim("  ") + chalk24.dim("NAME".padEnd(20)) + chalk24.dim("STATUS".padEnd(10)) + chalk24.dim("CPU".padEnd(8)) + chalk24.dim("MEM".padEnd(10)) + chalk24.dim("UPTIME".padEnd(10)) + chalk24.dim("RESTARTS")
+  );
+  console.log(chalk24.dim("  " + "-".repeat(70)));
+  let totalCpu = 0;
+  let totalMem = 0;
+  for (const project of npmProjects) {
+    const pm2Name = `bindler:${project.name}`;
+    const pm2Process = pm2Processes.find((p) => p.name === pm2Name);
+    const name = project.name.slice(0, 18).padEnd(20);
+    if (!pm2Process) {
+      console.log(
+        "  " + chalk24.white(name) + chalk24.dim("not managed".padEnd(10)) + chalk24.dim("-".padEnd(8)) + chalk24.dim("-".padEnd(10)) + chalk24.dim("-".padEnd(10)) + chalk24.dim("-")
+      );
+      continue;
+    }
+    const statusColor = pm2Process.status === "online" ? chalk24.green : chalk24.red;
+    const status = statusColor(pm2Process.status.padEnd(10));
+    const cpu = `${pm2Process.cpu.toFixed(1)}%`.padEnd(8);
+    const mem = formatBytes2(pm2Process.memory).padEnd(10);
+    const uptime = formatUptime2(pm2Process.uptime).padEnd(10);
+    const restarts = String(pm2Process.restarts);
+    totalCpu += pm2Process.cpu;
+    totalMem += pm2Process.memory;
+    console.log(
+      "  " + chalk24.white(name) + status + (pm2Process.cpu > 50 ? chalk24.yellow(cpu) : chalk24.dim(cpu)) + (pm2Process.memory > 500 * 1024 * 1024 ? chalk24.yellow(mem) : chalk24.dim(mem)) + chalk24.dim(uptime) + (pm2Process.restarts > 0 ? chalk24.yellow(restarts) : chalk24.dim(restarts))
+    );
+  }
+  const runningCount = pm2Processes.filter((p) => p.name.startsWith("bindler:") && p.status === "online").length;
+  console.log(chalk24.dim("  " + "-".repeat(70)));
+  console.log(
+    "  " + chalk24.bold("TOTAL".padEnd(20)) + chalk24.dim(`${runningCount}/${npmProjects.length}`.padEnd(10)) + chalk24.dim(`${totalCpu.toFixed(1)}%`.padEnd(8)) + chalk24.dim(formatBytes2(totalMem).padEnd(10))
+  );
+  console.log("");
+}
+
+// src/commands/completion.ts
+import chalk25 from "chalk";
+var BASH_COMPLETION = `
+# bindler bash completion
+_bindler_completions() {
+    local cur="\${COMP_WORDS[COMP_CWORD]}"
+    local prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+    local commands="new list ls status start stop restart logs update edit remove rm apply doctor ports info check setup init deploy backup restore ssl tunnel open health stats completion"
+
+    case "\${prev}" in
+        bindler)
+            COMPREPLY=($(compgen -W "\${commands}" -- "\${cur}"))
+            return 0
+            ;;
+        start|stop|restart|logs|update|edit|remove|rm|deploy|open|check)
+            local projects=$(bindler list --json 2>/dev/null | grep -o '"name":"[^"]*"' | cut -d'"' -f4)
+            COMPREPLY=($(compgen -W "\${projects}" -- "\${cur}"))
+            return 0
+            ;;
+        tunnel)
+            COMPREPLY=($(compgen -W "status start stop login create list" -- "\${cur}"))
+            return 0
+            ;;
+    esac
+
+    COMPREPLY=()
+}
+
+complete -F _bindler_completions bindler
+`;
+var ZSH_COMPLETION = `
+#compdef bindler
+
+_bindler() {
+    local -a commands
+    commands=(
+        'new:Create and register a new project'
+        'list:List all registered projects'
+        'ls:List all registered projects'
+        'status:Show detailed status of all projects'
+        'start:Start an npm project with PM2'
+        'stop:Stop an npm project'
+        'restart:Restart an npm project'
+        'logs:Show logs for an npm project'
+        'update:Update project configuration'
+        'edit:Edit project configuration in \\$EDITOR'
+        'remove:Remove a project from registry'
+        'rm:Remove a project from registry'
+        'apply:Generate and apply nginx configuration'
+        'doctor:Run system diagnostics'
+        'ports:Show allocated ports'
+        'info:Show bindler information'
+        'check:Check DNS and HTTP for a hostname'
+        'setup:Install missing dependencies'
+        'init:Initialize bindler'
+        'deploy:Deploy a project (git pull + install + restart)'
+        'backup:Backup configuration'
+        'restore:Restore configuration'
+        'ssl:Request SSL certificate'
+        'tunnel:Manage Cloudflare tunnel'
+        'open:Open project in browser'
+        'health:Check health of all projects'
+        'stats:Show CPU and memory stats'
+        'completion:Generate shell completions'
+    )
+
+    local -a project_commands
+    project_commands=(start stop restart logs update edit remove rm deploy open check)
+
+    _arguments -C \\
+        '1: :->command' \\
+        '*: :->args'
+
+    case "$state" in
+        command)
+            _describe -t commands 'bindler command' commands
+            ;;
+        args)
+            case "$words[2]" in
+                start|stop|restart|logs|update|edit|remove|rm|deploy|open|check)
+                    local -a projects
+                    projects=(\${(f)"$(bindler list --json 2>/dev/null | grep -o '"name":"[^"]*"' | cut -d'"' -f4)"})
+                    _describe -t projects 'project' projects
+                    ;;
+                tunnel)
+                    local -a tunnel_actions
+                    tunnel_actions=(status start stop login create list)
+                    _describe -t actions 'action' tunnel_actions
+                    ;;
+            esac
+            ;;
+    esac
+}
+
+_bindler
+`;
+var FISH_COMPLETION = `
+# bindler fish completion
+complete -c bindler -f
+
+# Commands
+complete -c bindler -n '__fish_use_subcommand' -a 'new' -d 'Create and register a new project'
+complete -c bindler -n '__fish_use_subcommand' -a 'list ls' -d 'List all registered projects'
+complete -c bindler -n '__fish_use_subcommand' -a 'status' -d 'Show detailed status'
+complete -c bindler -n '__fish_use_subcommand' -a 'start' -d 'Start an npm project'
+complete -c bindler -n '__fish_use_subcommand' -a 'stop' -d 'Stop an npm project'
+complete -c bindler -n '__fish_use_subcommand' -a 'restart' -d 'Restart an npm project'
+complete -c bindler -n '__fish_use_subcommand' -a 'logs' -d 'Show logs'
+complete -c bindler -n '__fish_use_subcommand' -a 'update' -d 'Update project configuration'
+complete -c bindler -n '__fish_use_subcommand' -a 'edit' -d 'Edit project in $EDITOR'
+complete -c bindler -n '__fish_use_subcommand' -a 'remove rm' -d 'Remove a project'
+complete -c bindler -n '__fish_use_subcommand' -a 'apply' -d 'Apply nginx configuration'
+complete -c bindler -n '__fish_use_subcommand' -a 'doctor' -d 'Run diagnostics'
+complete -c bindler -n '__fish_use_subcommand' -a 'ports' -d 'Show allocated ports'
+complete -c bindler -n '__fish_use_subcommand' -a 'info' -d 'Show bindler info'
+complete -c bindler -n '__fish_use_subcommand' -a 'check' -d 'Check DNS and HTTP'
+complete -c bindler -n '__fish_use_subcommand' -a 'setup' -d 'Install dependencies'
+complete -c bindler -n '__fish_use_subcommand' -a 'init' -d 'Initialize bindler'
+complete -c bindler -n '__fish_use_subcommand' -a 'deploy' -d 'Deploy a project'
+complete -c bindler -n '__fish_use_subcommand' -a 'backup' -d 'Backup configuration'
+complete -c bindler -n '__fish_use_subcommand' -a 'restore' -d 'Restore configuration'
+complete -c bindler -n '__fish_use_subcommand' -a 'ssl' -d 'Request SSL certificate'
+complete -c bindler -n '__fish_use_subcommand' -a 'tunnel' -d 'Manage Cloudflare tunnel'
+complete -c bindler -n '__fish_use_subcommand' -a 'open' -d 'Open in browser'
+complete -c bindler -n '__fish_use_subcommand' -a 'health' -d 'Check health'
+complete -c bindler -n '__fish_use_subcommand' -a 'stats' -d 'Show stats'
+complete -c bindler -n '__fish_use_subcommand' -a 'completion' -d 'Generate completions'
+
+# Tunnel subcommands
+complete -c bindler -n '__fish_seen_subcommand_from tunnel' -a 'status start stop login create list'
+`;
+async function completionCommand(shell) {
+  if (!shell) {
+    console.log(chalk25.red("Usage: bindler completion <shell>"));
+    console.log(chalk25.dim("\nSupported shells: bash, zsh, fish"));
+    console.log(chalk25.dim("\nSetup:"));
+    console.log(chalk25.dim("  bash: bindler completion bash >> ~/.bashrc"));
+    console.log(chalk25.dim("  zsh:  bindler completion zsh >> ~/.zshrc"));
+    console.log(chalk25.dim("  fish: bindler completion fish > ~/.config/fish/completions/bindler.fish"));
+    process.exit(1);
+  }
+  switch (shell) {
+    case "bash":
+      console.log(BASH_COMPLETION.trim());
+      break;
+    case "zsh":
+      console.log(ZSH_COMPLETION.trim());
+      break;
+    case "fish":
+      console.log(FISH_COMPLETION.trim());
+      break;
+    default:
+      console.log(chalk25.red(`Unknown shell: ${shell}`));
+      console.log(chalk25.dim("Supported: bash, zsh, fish"));
+      process.exit(1);
+  }
+}
+
 // src/cli.ts
 var program = new Command();
 program.name("bindler").description("Manage multiple projects behind Cloudflare Tunnel with Nginx and PM2").version("1.0.0");
@@ -2209,24 +3113,76 @@ program.command("status").description("Show detailed status of all projects").ac
   await statusCommand();
 });
 program.command("start [name]").description("Start an npm project with PM2").option("-a, --all", "Start all npm projects").action(async (name, options) => {
+  if (!name && !options.all) {
+    console.log(chalk26.red("Usage: bindler start <name> or bindler start --all"));
+    console.log(chalk26.dim("\nExamples:"));
+    console.log(chalk26.dim("  bindler start myapp"));
+    console.log(chalk26.dim("  bindler start --all    # start all npm projects"));
+    process.exit(1);
+  }
   await startCommand(name, options);
 });
 program.command("stop [name]").description("Stop an npm project").option("-a, --all", "Stop all npm projects").action(async (name, options) => {
+  if (!name && !options.all) {
+    console.log(chalk26.red("Usage: bindler stop <name> or bindler stop --all"));
+    console.log(chalk26.dim("\nExamples:"));
+    console.log(chalk26.dim("  bindler stop myapp"));
+    console.log(chalk26.dim("  bindler stop --all    # stop all npm projects"));
+    process.exit(1);
+  }
   await stopCommand(name, options);
 });
 program.command("restart [name]").description("Restart an npm project").option("-a, --all", "Restart all npm projects").action(async (name, options) => {
+  if (!name && !options.all) {
+    console.log(chalk26.red("Usage: bindler restart <name> or bindler restart --all"));
+    console.log(chalk26.dim("\nExamples:"));
+    console.log(chalk26.dim("  bindler restart myapp"));
+    console.log(chalk26.dim("  bindler restart --all    # restart all npm projects"));
+    process.exit(1);
+  }
   await restartCommand(name, options);
 });
-program.command("logs <name>").description("Show logs for an npm project").option("-f, --follow", "Follow log output").option("-l, --lines <n>", "Number of lines to show", "200").action(async (name, options) => {
+program.command("logs [name]").description("Show logs for an npm project").option("-f, --follow", "Follow log output").option("-l, --lines <n>", "Number of lines to show", "200").action(async (name, options) => {
+  if (!name) {
+    console.log(chalk26.red("Usage: bindler logs <name>"));
+    console.log(chalk26.dim("\nExamples:"));
+    console.log(chalk26.dim("  bindler logs myapp"));
+    console.log(chalk26.dim("  bindler logs myapp --follow"));
+    console.log(chalk26.dim("  bindler logs myapp --lines 500"));
+    process.exit(1);
+  }
   await logsCommand(name, { ...options, lines: parseInt(options.lines, 10) });
 });
-program.command("update <name>").description("Update project configuration").option("-h, --hostname <hostname>", "New hostname").option("--port <port>", "New port number").option("-s, --start <command>", "New start command").option("-p, --path <path>", "New project path").option("-e, --env <vars...>", "Environment variables (KEY=value)").option("--enable", "Enable the project").option("--disable", "Disable the project").action(async (name, options) => {
+program.command("update [name]").description("Update project configuration").option("-h, --hostname <hostname>", "New hostname").option("--port <port>", "New port number").option("-s, --start <command>", "New start command").option("-p, --path <path>", "New project path").option("-e, --env <vars...>", "Environment variables (KEY=value)").option("--enable", "Enable the project").option("--disable", "Disable the project").action(async (name, options) => {
+  if (!name) {
+    console.log(chalk26.red("Usage: bindler update <name> [options]"));
+    console.log(chalk26.dim("\nExamples:"));
+    console.log(chalk26.dim("  bindler update myapp --hostname newapp.example.com"));
+    console.log(chalk26.dim("  bindler update myapp --port 4000"));
+    console.log(chalk26.dim("  bindler update myapp --disable"));
+    process.exit(1);
+  }
   await updateCommand(name, options);
 });
-program.command("edit <name>").description("Edit project configuration in $EDITOR").action(async (name) => {
+program.command("edit [name]").description("Edit project configuration in $EDITOR").action(async (name) => {
+  if (!name) {
+    console.log(chalk26.red("Usage: bindler edit <name>"));
+    console.log(chalk26.dim("\nOpens the project config in your $EDITOR"));
+    console.log(chalk26.dim("\nExample:"));
+    console.log(chalk26.dim("  bindler edit myapp"));
+    process.exit(1);
+  }
   await editCommand(name);
 });
-program.command("remove <name>").alias("rm").description("Remove a project from registry").option("-f, --force", "Skip confirmation").option("--apply", "Apply nginx config after removing").action(async (name, options) => {
+program.command("remove [name]").alias("rm").description("Remove a project from registry").option("-f, --force", "Skip confirmation").option("--apply", "Apply nginx config after removing").action(async (name, options) => {
+  if (!name) {
+    console.log(chalk26.red("Usage: bindler remove <name>"));
+    console.log(chalk26.dim("\nExamples:"));
+    console.log(chalk26.dim("  bindler remove myapp"));
+    console.log(chalk26.dim("  bindler remove myapp --force    # skip confirmation"));
+    console.log(chalk26.dim("  bindler rm myapp                # alias"));
+    process.exit(1);
+  }
   await removeCommand(name, options);
 });
 program.command("apply").description("Generate and apply nginx configuration + Cloudflare DNS routes").option("-d, --dry-run", "Print config without applying").option("--no-reload", "Write config but do not reload nginx").option("--no-cloudflare", "Skip Cloudflare DNS route configuration").option("--no-ssl", "Skip SSL certificate setup (direct mode)").action(async (options) => {
@@ -2241,11 +3197,48 @@ program.command("ports").description("Show allocated ports").action(async () =>
 program.command("info").description("Show bindler information and stats").action(async () => {
   await infoCommand();
 });
-program.command("check <hostname>").description("Check DNS propagation and HTTP accessibility for a hostname").option("-v, --verbose", "Show verbose output").action(async (hostname, options) => {
+program.command("check [hostname]").description("Check DNS propagation and HTTP accessibility for a hostname").option("-v, --verbose", "Show verbose output").action(async (hostname, options) => {
+  if (!hostname) {
+    console.log(chalk26.red("Usage: bindler check <hostname>"));
+    console.log(chalk26.dim("\nExamples:"));
+    console.log(chalk26.dim("  bindler check myapp.example.com"));
+    console.log(chalk26.dim("  bindler check myapp          # uses project name"));
+    process.exit(1);
+  }
   await checkCommand(hostname, options);
 });
 program.command("setup").description("Install missing dependencies (nginx, PM2, cloudflared)").option("--direct", "Direct mode for VPS (no Cloudflare Tunnel, use port 80/443)").action(async (options) => {
   await setupCommand(options);
 });
+program.command("init").description("Initialize bindler with interactive setup wizard").action(async () => {
+  await initCommand();
+});
+program.command("deploy [name]").description("Deploy a project (git pull + npm install + restart)").option("--skip-pull", "Skip git pull").option("--skip-install", "Skip npm install").option("--skip-restart", "Skip restart").action(async (name, options) => {
+  await deployCommand(name, options);
+});
+program.command("backup").description("Backup bindler configuration").option("-o, --output <file>", "Output file path").action(async (options) => {
+  await backupCommand(options);
+});
+program.command("restore [file]").description("Restore bindler configuration from backup").option("-f, --force", "Overwrite existing config").action(async (file, options) => {
+  await restoreCommand(file, options);
+});
+program.command("ssl [hostname]").description("Request SSL certificate for a hostname").option("-e, --email <email>", "Email for Let's Encrypt").option("--staging", "Use staging server (for testing)").action(async (hostname, options) => {
+  await sslCommand(hostname, options);
+});
+program.command("tunnel [action]").description("Manage Cloudflare tunnel (status, start, stop, login, create, list)").option("-n, --name <name>", "Tunnel name").action(async (action, options) => {
+  await tunnelCommand(action, options);
+});
+program.command("open [name]").description("Open a project in your browser").action(async (name) => {
+  await openCommand(name);
+});
+program.command("health").description("Check health of all projects").action(async () => {
+  await healthCommand();
+});
+program.command("stats").description("Show CPU and memory stats for npm projects").action(async () => {
+  await statsCommand();
+});
+program.command("completion [shell]").description("Generate shell completion script (bash, zsh, fish)").action(async (shell) => {
+  await completionCommand(shell);
+});
 program.parse();
 //# sourceMappingURL=cli.js.map