bindler 1.0.0

package/dist/cli.js

@@ -0,0 +1,2211 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/new.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import { basename } from "path";
+import inquirer from "inquirer";
+import chalk from "chalk";
+
+// src/lib/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join(homedir(), ".config", "bindler");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+var GENERATED_DIR = join(CONFIG_DIR, "generated");
+var BACKUP_DIR = join(CONFIG_DIR, "backups");
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+function getGeneratedDir() {
+  return GENERATED_DIR;
+}
+function getNginxConfigPath() {
+  const isMac = process.platform === "darwin";
+  if (isMac) {
+    if (existsSync("/opt/homebrew/etc/nginx/servers")) {
+      return "/opt/homebrew/etc/nginx/servers/bindler.conf";
+    }
+    if (existsSync("/usr/local/etc/nginx/servers")) {
+      return "/usr/local/etc/nginx/servers/bindler.conf";
+    }
+  }
+  return "/etc/nginx/conf.d/bindler.conf";
+}
+function getDefaultConfig() {
+  return {
+    version: 1,
+    defaults: {
+      projectsRoot: join(homedir(), "projects"),
+      nginxManagedPath: getNginxConfigPath(),
+      nginxListen: "127.0.0.1:8080",
+      tunnelName: "homelab",
+      applyCloudflareDnsRoutes: true,
+      mode: "tunnel"
+    },
+    projects: []
+  };
+}
+function ensureConfigDirs() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  if (!existsSync(GENERATED_DIR)) {
+    mkdirSync(GENERATED_DIR, { recursive: true });
+  }
+  if (!existsSync(BACKUP_DIR)) {
+    mkdirSync(BACKUP_DIR, { recursive: true });
+  }
+}
+function configExists() {
+  return existsSync(CONFIG_PATH);
+}
+function readConfig() {
+  if (!configExists()) {
+    return getDefaultConfig();
+  }
+  try {
+    const content = readFileSync(CONFIG_PATH, "utf-8");
+    const config = JSON.parse(content);
+    return config;
+  } catch (error) {
+    throw new Error(`Failed to read config: ${error instanceof Error ? error.message : error}`);
+  }
+}
+function writeConfig(config) {
+  ensureConfigDirs();
+  if (configExists()) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const backupPath = join(BACKUP_DIR, `config-${timestamp}.json`);
+    copyFileSync(CONFIG_PATH, backupPath);
+  }
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+}
+function initConfig() {
+  if (configExists()) {
+    return readConfig();
+  }
+  const config = getDefaultConfig();
+  writeConfig(config);
+  return config;
+}
+function getProject(name) {
+  const config = readConfig();
+  return config.projects.find((p) => p.name === name);
+}
+function addProject(project) {
+  const config = readConfig();
+  if (config.projects.some((p) => p.name === project.name)) {
+    throw new Error(`Project "${project.name}" already exists`);
+  }
+  if (config.projects.some((p) => p.hostname === project.hostname)) {
+    throw new Error(`Hostname "${project.hostname}" is already in use`);
+  }
+  config.projects.push(project);
+  writeConfig(config);
+}
+function updateProject(name, updates) {
+  const config = readConfig();
+  const index = config.projects.findIndex((p) => p.name === name);
+  if (index === -1) {
+    throw new Error(`Project "${name}" not found`);
+  }
+  if (updates.hostname && updates.hostname !== config.projects[index].hostname) {
+    if (config.projects.some((p) => p.hostname === updates.hostname)) {
+      throw new Error(`Hostname "${updates.hostname}" is already in use`);
+    }
+  }
+  config.projects[index] = { ...config.projects[index], ...updates };
+  writeConfig(config);
+}
+function removeProject(name) {
+  const config = readConfig();
+  const index = config.projects.findIndex((p) => p.name === name);
+  if (index === -1) {
+    throw new Error(`Project "${name}" not found`);
+  }
+  const [removed] = config.projects.splice(index, 1);
+  writeConfig(config);
+  return removed;
+}
+function listProjects() {
+  const config = readConfig();
+  return config.projects;
+}
+function getDefaults() {
+  const config = readConfig();
+  return config.defaults;
+}
+
+// src/lib/utils.ts
+import { execSync, spawn } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { createConnection } from "net";
+function execCommandSafe(command, options) {
+  try {
+    const output = execSync(command, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      ...options
+    }).trim();
+    return { success: true, output };
+  } catch (error) {
+    if (error instanceof Error && "stderr" in error) {
+      return { success: false, output: "", error: error.stderr || error.message };
+    }
+    return { success: false, output: "", error: String(error) };
+  }
+}
+function spawnInteractive(command, args, options) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      stdio: "inherit",
+      ...options
+    });
+    child.on("close", (code) => {
+      resolve(code);
+    });
+  });
+}
+function isPortListening(port, host = "127.0.0.1") {
+  return new Promise((resolve) => {
+    const socket = createConnection({ port, host }, () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => {
+      resolve(false);
+    });
+    socket.setTimeout(1e3, () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}
+function detectProjectType(path) {
+  const packageJsonPath = join2(path, "package.json");
+  return existsSync2(packageJsonPath) ? "npm" : "static";
+}
+function getPackageJsonScripts(path) {
+  const packageJsonPath = join2(path, "package.json");
+  if (!existsSync2(packageJsonPath)) {
+    return [];
+  }
+  try {
+    const content = readFileSync2(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    return Object.keys(pkg.scripts || {});
+  } catch {
+    return [];
+  }
+}
+function validateHostname(hostname) {
+  const hostnameRegex = /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?)*$/;
+  return hostnameRegex.test(hostname) && hostname.length <= 253;
+}
+function validateProjectName(name) {
+  const nameRegex = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
+  return nameRegex.test(name) && name.length <= 64;
+}
+function validatePort(port) {
+  return Number.isInteger(port) && port >= 1024 && port <= 65535;
+}
+function formatUptime(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 ${seconds % 60}s`;
+  }
+  return `${seconds}s`;
+}
+function formatBytes(bytes) {
+  const units = ["B", "KB", "MB", "GB"];
+  let value = bytes;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+  return `${value.toFixed(1)}${units[unitIndex]}`;
+}
+function getPm2ProcessName(projectName) {
+  return `bindler:${projectName}`;
+}
+
+// src/lib/ports.ts
+var PORT_RANGE_START = 3e3;
+var PORT_RANGE_END = 9e3;
+function getUsedPorts() {
+  const config = readConfig();
+  return config.projects.filter((p) => p.type === "npm" && p.port).map((p) => p.port);
+}
+function findAvailablePort(startFrom = PORT_RANGE_START) {
+  const usedPorts = new Set(getUsedPorts());
+  for (let port = startFrom; port <= PORT_RANGE_END; port++) {
+    if (!usedPorts.has(port)) {
+      return port;
+    }
+  }
+  throw new Error(`No available ports in range ${PORT_RANGE_START}-${PORT_RANGE_END}`);
+}
+function isPortAvailable(port) {
+  const usedPorts = new Set(getUsedPorts());
+  return !usedPorts.has(port);
+}
+function getPortsTable() {
+  const config = readConfig();
+  return config.projects.filter((p) => p.type === "npm" && p.port).map((p) => ({
+    port: p.port,
+    project: p.name,
+    hostname: p.hostname
+  })).sort((a, b) => a.port - b.port);
+}
+
+// src/lib/nginx.ts
+import { existsSync as existsSync3, writeFileSync as writeFileSync2, copyFileSync as copyFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+function generateLocationBlock(project, indent = "    ") {
+  const lines = [];
+  const locationPath = project.basePath || "/";
+  const isRootLocation = locationPath === "/";
+  if (project.type === "static") {
+    lines.push(`${indent}location ${locationPath} {`);
+    if (isRootLocation) {
+      lines.push(`${indent}    root ${project.path};`);
+    } else {
+      lines.push(`${indent}    alias ${project.path}/;`);
+    }
+    lines.push(`${indent}    index index.html index.htm;`);
+    lines.push(`${indent}    try_files $uri $uri/ =404;`);
+    lines.push(`${indent}}`);
+  } else if (project.type === "npm") {
+    lines.push(`${indent}location ${locationPath} {`);
+    lines.push(`${indent}    proxy_pass http://127.0.0.1:${project.port};`);
+    lines.push(`${indent}    proxy_http_version 1.1;`);
+    lines.push(`${indent}    proxy_set_header Upgrade $http_upgrade;`);
+    lines.push(`${indent}    proxy_set_header Connection 'upgrade';`);
+    lines.push(`${indent}    proxy_set_header Host $host;`);
+    lines.push(`${indent}    proxy_set_header X-Real-IP $remote_addr;`);
+    lines.push(`${indent}    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;`);
+    lines.push(`${indent}    proxy_set_header X-Forwarded-Proto $scheme;`);
+    lines.push(`${indent}    proxy_cache_bypass $http_upgrade;`);
+    lines.push(`${indent}}`);
+  }
+  return lines;
+}
+function generateNginxConfig(config) {
+  const { defaults, projects } = config;
+  const listen = defaults.nginxListen;
+  const lines = [
+    "# Generated by bindler - DO NOT EDIT MANUALLY",
+    `# Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    ""
+  ];
+  const hostGroups = /* @__PURE__ */ new Map();
+  for (const project of projects) {
+    if (project.enabled === false) {
+      lines.push(`# Project "${project.name}" is disabled`);
+      lines.push("");
+      continue;
+    }
+    const existing = hostGroups.get(project.hostname) || [];
+    existing.push(project);
+    hostGroups.set(project.hostname, existing);
+  }
+  for (const [hostname, hostProjects] of hostGroups) {
+    const projectNames = hostProjects.map((p) => p.name).join(", ");
+    lines.push(`# Hostname: ${hostname} (${projectNames})`);
+    lines.push("server {");
+    lines.push(`    listen ${listen};`);
+    lines.push(`    server_name ${hostname};`);
+    lines.push("");
+    const sortedProjects = [...hostProjects].sort((a, b) => {
+      const pathA = a.basePath || "/";
+      const pathB = b.basePath || "/";
+      return pathB.length - pathA.length;
+    });
+    for (const project of sortedProjects) {
+      lines.push(`    # Project: ${project.name} (${project.type})`);
+      lines.push(...generateLocationBlock(project));
+      lines.push("");
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function writeNginxConfig(config, dryRun = false) {
+  const nginxConfig = generateNginxConfig(config);
+  const targetPath = config.defaults.nginxManagedPath;
+  if (dryRun) {
+    return { path: targetPath, content: nginxConfig };
+  }
+  const targetDir = dirname2(targetPath);
+  if (!existsSync3(targetDir)) {
+    mkdirSync2(targetDir, { recursive: true });
+  }
+  if (existsSync3(targetPath)) {
+    const backupDir = join3(getGeneratedDir(), "backups");
+    if (!existsSync3(backupDir)) {
+      mkdirSync2(backupDir, { recursive: true });
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const backupPath = join3(backupDir, `nginx-${timestamp}.conf`);
+    copyFileSync2(targetPath, backupPath);
+  }
+  const generatedPath = join3(getGeneratedDir(), "nginx.conf");
+  writeFileSync2(generatedPath, nginxConfig);
+  writeFileSync2(targetPath, nginxConfig);
+  return { path: targetPath, content: nginxConfig };
+}
+function testNginxConfig() {
+  const result = execCommandSafe("nginx -t 2>&1");
+  return {
+    success: result.success || result.output.includes("syntax is ok"),
+    output: result.output || result.error || ""
+  };
+}
+function reloadNginx() {
+  const isMac = process.platform === "darwin";
+  if (isMac) {
+    let result2 = execCommandSafe("brew services reload nginx");
+    if (result2.success) {
+      return { success: true };
+    }
+    result2 = execCommandSafe("nginx -s reload");
+    if (result2.success) {
+      return { success: true };
+    }
+    return { success: false, error: result2.error || "Failed to reload nginx. Try: brew services restart nginx" };
+  }
+  let result = execCommandSafe("sudo systemctl reload nginx");
+  if (result.success) {
+    return { success: true };
+  }
+  result = execCommandSafe("sudo service nginx reload");
+  if (result.success) {
+    return { success: true };
+  }
+  result = execCommandSafe("sudo nginx -s reload");
+  if (result.success) {
+    return { success: true };
+  }
+  return { success: false, error: result.error || "Failed to reload nginx" };
+}
+function isNginxInstalled() {
+  const result = execCommandSafe("which nginx");
+  return result.success;
+}
+function isNginxRunning() {
+  const isMac = process.platform === "darwin";
+  if (isMac) {
+    let result2 = execCommandSafe("brew services list | grep nginx");
+    if (result2.success && result2.output.includes("started")) {
+      return true;
+    }
+  } else {
+    let result2 = execCommandSafe("systemctl is-active nginx");
+    if (result2.success && result2.output === "active") {
+      return true;
+    }
+  }
+  const result = execCommandSafe("pgrep nginx");
+  return result.success;
+}
+function getNginxVersion() {
+  const result = execCommandSafe("nginx -v 2>&1");
+  if (result.success || result.output) {
+    const match = (result.output || result.error || "").match(/nginx\/(\S+)/);
+    return match ? match[1] : null;
+  }
+  return null;
+}
+
+// src/lib/pm2.ts
+function isPm2Installed() {
+  const result = execCommandSafe("which pm2");
+  return result.success;
+}
+function getPm2List() {
+  const result = execCommandSafe("pm2 jlist");
+  if (!result.success) {
+    return [];
+  }
+  try {
+    const processes = JSON.parse(result.output);
+    return processes.map((p) => ({
+      name: p.name,
+      pm_id: p.pm_id,
+      status: p.pm2_env?.status,
+      cpu: p.monit ? p.monit.cpu : 0,
+      memory: p.monit ? p.monit.memory : 0,
+      uptime: p.pm2_env?.pm_uptime ? Date.now() - p.pm2_env.pm_uptime : 0,
+      restarts: p.pm2_env?.restart_time || 0
+    }));
+  } catch {
+    return [];
+  }
+}
+function getProcessByName(name) {
+  const pm2Name = getPm2ProcessName(name);
+  const processes = getPm2List();
+  return processes.find((p) => p.name === pm2Name);
+}
+function startProject(project) {
+  if (project.type !== "npm") {
+    return { success: false, error: "Only npm projects can be started with PM2" };
+  }
+  if (!project.start) {
+    return { success: false, error: "No start command configured" };
+  }
+  const pm2Name = getPm2ProcessName(project.name);
+  const existingProcess = getProcessByName(project.name);
+  const envVars = [];
+  if (project.env) {
+    for (const [key, value] of Object.entries(project.env)) {
+      envVars.push(`${key}=${value}`);
+    }
+  }
+  let command;
+  if (existingProcess) {
+    command = `pm2 restart "${pm2Name}"`;
+  } else {
+    const envFlags = envVars.length > 0 ? envVars.map((e) => `--env ${e}`).join(" ") : "";
+    command = `pm2 start --name "${pm2Name}" --cwd "${project.path}" ${envFlags} -- bash -lc "${project.start}"`;
+  }
+  const result = execCommandSafe(command);
+  if (!result.success) {
+    return { success: false, error: result.error };
+  }
+  execCommandSafe("pm2 save");
+  return { success: true };
+}
+function stopProject(name) {
+  const pm2Name = getPm2ProcessName(name);
+  const result = execCommandSafe(`pm2 stop "${pm2Name}"`);
+  if (!result.success) {
+    return { success: false, error: result.error };
+  }
+  execCommandSafe("pm2 save");
+  return { success: true };
+}
+function restartProject(name) {
+  const pm2Name = getPm2ProcessName(name);
+  const result = execCommandSafe(`pm2 restart "${pm2Name}"`);
+  if (!result.success) {
+    return { success: false, error: result.error };
+  }
+  execCommandSafe("pm2 save");
+  return { success: true };
+}
+function deleteProject(name) {
+  const pm2Name = getPm2ProcessName(name);
+  const result = execCommandSafe(`pm2 delete "${pm2Name}"`);
+  if (!result.success) {
+    if (result.error?.includes("not found")) {
+      return { success: true };
+    }
+    return { success: false, error: result.error };
+  }
+  execCommandSafe("pm2 save");
+  return { success: true };
+}
+async function showLogs(name, follow = false, lines = 200) {
+  const pm2Name = getPm2ProcessName(name);
+  const args = ["logs", pm2Name, "--lines", String(lines)];
+  if (!follow) {
+    args.push("--nostream");
+  }
+  return spawnInteractive("pm2", args);
+}
+function startAllProjects(projects) {
+  return projects.filter((p) => p.type === "npm").map((project) => ({
+    name: project.name,
+    ...startProject(project)
+  }));
+}
+function stopAllProjects(projects) {
+  return projects.filter((p) => p.type === "npm").map((project) => ({
+    name: project.name,
+    ...stopProject(project.name)
+  }));
+}
+function restartAllProjects(projects) {
+  return projects.filter((p) => p.type === "npm").map((project) => ({
+    name: project.name,
+    ...restartProject(project.name)
+  }));
+}
+
+// src/commands/new.ts
+async function newCommand(options) {
+  console.log(chalk.dim("Checking prerequisites...\n"));
+  const issues = [];
+  if (!isNginxInstalled()) {
+    issues.push("nginx is not installed. Install: brew install nginx (macOS) or apt install nginx (Linux)");
+  }
+  if (!isPm2Installed()) {
+    issues.push("PM2 is not installed. Install: npm install -g pm2");
+  }
+  if (issues.length > 0) {
+    console.log(chalk.red("Missing prerequisites:\n"));
+    for (const issue of issues) {
+      console.log(chalk.red(`  \u2717 ${issue}`));
+    }
+    console.log(chalk.dim("\nRun `bindler doctor` for full diagnostics."));
+    const { proceed } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "proceed",
+        message: "Continue anyway?",
+        default: false
+      }
+    ]);
+    if (!proceed) {
+      process.exit(1);
+    }
+    console.log("");
+  } else {
+    console.log(chalk.green("\u2713 Prerequisites OK\n"));
+  }
+  const defaults = getDefaults();
+  let project = {};
+  const cwd = process.cwd();
+  const cwdName = basename(cwd);
+  if (!options.name) {
+    const answers = await inquirer.prompt([
+      {
+        type: "input",
+        name: "path",
+        message: "Project path:",
+        default: cwd,
+        validate: (input) => {
+          if (!input) {
+            return "Path is required";
+          }
+          return true;
+        }
+      },
+      {
+        type: "input",
+        name: "name",
+        message: "Project name:",
+        default: cwdName,
+        validate: (input) => {
+          if (!validateProjectName(input)) {
+            return "Invalid project name. Use alphanumeric characters, dashes, and underscores.";
+          }
+          return true;
+        }
+      },
+      {
+        type: "list",
+        name: "type",
+        message: "Project type:",
+        choices: (answers2) => {
+          const detected = existsSync4(answers2.path) ? detectProjectType(answers2.path) : "static";
+          return [
+            { name: `npm (Node.js app)${detected === "npm" ? " - detected" : ""}`, value: "npm" },
+            { name: `static (HTML/CSS/JS)${detected === "static" ? " - detected" : ""}`, value: "static" }
+          ];
+        },
+        default: (answers2) => {
+          return existsSync4(answers2.path) ? detectProjectType(answers2.path) : "static";
+        }
+      },
+      {
+        type: "input",
+        name: "hostname",
+        message: options.local ? "Hostname (e.g., myapp.local):" : "Hostname (e.g., mysite.example.com or example.com):",
+        default: options.local ? `${cwdName}.local` : void 0,
+        validate: (input) => {
+          if (!validateHostname(input)) {
+            return "Invalid hostname format";
+          }
+          return true;
+        }
+      },
+      {
+        type: "input",
+        name: "basePath",
+        message: "Base path (leave empty for root, or e.g., /api):",
+        filter: (input) => {
+          if (!input || input.trim() === "") return "";
+          const trimmed = input.trim();
+          return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+        }
+      }
+    ]);
+    project = { ...answers };
+    if (!project.basePath) delete project.basePath;
+    if (options.local) project.local = true;
+    if (answers.type === "npm") {
+      const scripts = existsSync4(answers.path) ? getPackageJsonScripts(answers.path) : [];
+      const suggestedPort = findAvailablePort();
+      const npmAnswers = await inquirer.prompt([
+        {
+          type: "input",
+          name: "port",
+          message: "Port number:",
+          default: suggestedPort,
+          validate: (input) => {
+            const port = parseInt(input, 10);
+            if (!validatePort(port)) {
+              return "Invalid port. Use a number between 1024 and 65535.";
+            }
+            return true;
+          },
+          filter: (input) => parseInt(input, 10)
+        },
+        {
+          type: scripts.length > 0 ? "list" : "input",
+          name: "start",
+          message: "Start command:",
+          choices: scripts.length > 0 ? [
+            ...scripts.map((s) => ({ name: `npm run ${s}`, value: `npm run ${s}` })),
+            { name: "Custom command...", value: "__custom__" }
+          ] : void 0,
+          default: scripts.includes("start") ? "npm run start" : "npm start"
+        }
+      ]);
+      if (npmAnswers.start === "__custom__") {
+        const customAnswer = await inquirer.prompt([
+          {
+            type: "input",
+            name: "start",
+            message: "Enter custom start command:"
+          }
+        ]);
+        npmAnswers.start = customAnswer.start;
+      }
+      project.port = npmAnswers.port;
+      project.start = npmAnswers.start;
+      const envAnswer = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "setPortEnv",
+          message: `Set PORT=${npmAnswers.port} environment variable?`,
+          default: true
+        }
+      ]);
+      if (envAnswer.setPortEnv) {
+        project.env = { PORT: String(npmAnswers.port) };
+      }
+    }
+  } else {
+    if (!options.hostname) {
+      console.error(chalk.red("Error: --hostname is required"));
+      process.exit(1);
+    }
+    project.name = options.name;
+    project.type = options.type || "static";
+    project.path = options.path || cwd;
+    project.hostname = options.hostname;
+    if (options.basePath) {
+      project.basePath = options.basePath.startsWith("/") ? options.basePath : `/${options.basePath}`;
+    }
+    if (options.local) {
+      project.local = true;
+    }
+    if (project.type === "npm") {
+      project.port = options.port || findAvailablePort();
+      project.start = options.start || "npm start";
+      project.env = { PORT: String(project.port) };
+    }
+  }
+  if (!validateProjectName(project.name)) {
+    console.error(chalk.red("Error: Invalid project name"));
+    process.exit(1);
+  }
+  if (!validateHostname(project.hostname)) {
+    console.error(chalk.red("Error: Invalid hostname"));
+    process.exit(1);
+  }
+  if (!existsSync4(project.path)) {
+    const createDir = options.name ? true : (await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "create",
+        message: `Directory ${project.path} does not exist. Create it?`,
+        default: true
+      }
+    ])).create;
+    if (createDir) {
+      mkdirSync3(project.path, { recursive: true });
+      console.log(chalk.green(`Created directory: ${project.path}`));
+    }
+  }
+  try {
+    addProject(project);
+    console.log(chalk.green(`
+Project "${project.name}" added successfully!`));
+    if (project.local) {
+      console.log(chalk.yellow(`
+Local project - add to /etc/hosts:`));
+      console.log(chalk.cyan(`  echo "127.0.0.1  ${project.hostname}" | sudo tee -a /etc/hosts`));
+      console.log(chalk.dim(`
+Run ${chalk.cyan("sudo bindler apply")} to update nginx.`));
+      console.log(chalk.dim(`Then access at: ${chalk.cyan(`http://${project.hostname}:8080`)}`));
+    } else {
+      console.log(chalk.dim(`
+Configuration saved. Run ${chalk.cyan("sudo bindler apply")} to update nginx and cloudflare.`));
+    }
+    if (project.type === "npm") {
+      console.log(chalk.dim(`Run ${chalk.cyan(`bindler start ${project.name}`)} to start the application.`));
+    }
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/list.ts
+import chalk2 from "chalk";
+import Table from "cli-table3";
+async function listCommand() {
+  const projects = listProjects();
+  if (projects.length === 0) {
+    console.log(chalk2.yellow("No projects registered."));
+    console.log(chalk2.dim(`Run ${chalk2.cyan("bindler new")} to create one.`));
+    return;
+  }
+  const table = new Table({
+    head: [
+      chalk2.cyan("Name"),
+      chalk2.cyan("Type"),
+      chalk2.cyan("Hostname"),
+      chalk2.cyan("Port"),
+      chalk2.cyan("Path"),
+      chalk2.cyan("Status")
+    ],
+    style: {
+      head: [],
+      border: []
+    }
+  });
+  for (const project of projects) {
+    let status = "-";
+    if (project.type === "npm") {
+      const process2 = getProcessByName(project.name);
+      if (process2) {
+        status = process2.status === "online" ? chalk2.green("online") : process2.status === "stopped" ? chalk2.yellow("stopped") : chalk2.red(process2.status);
+      } else {
+        status = chalk2.dim("not started");
+      }
+    } else {
+      status = project.enabled !== false ? chalk2.green("serving") : chalk2.yellow("disabled");
+    }
+    if (project.enabled === false) {
+      status = chalk2.yellow("disabled");
+    }
+    table.push([
+      project.name,
+      project.type,
+      project.hostname,
+      project.port?.toString() || "-",
+      project.path,
+      status
+    ]);
+  }
+  console.log(table.toString());
+  console.log(chalk2.dim(`
+${projects.length} project(s) registered`));
+}
+
+// src/commands/status.ts
+import chalk3 from "chalk";
+import Table2 from "cli-table3";
+async function statusCommand() {
+  const projects = listProjects();
+  if (projects.length === 0) {
+    console.log(chalk3.yellow("No projects registered."));
+    return;
+  }
+  const statuses = [];
+  for (const project of projects) {
+    const status = { ...project };
+    if (project.type === "npm") {
+      const process2 = getProcessByName(project.name);
+      status.pm2Name = getPm2ProcessName(project.name);
+      if (process2) {
+        status.pm2Status = process2.status;
+      } else {
+        status.pm2Status = "not_managed";
+      }
+      if (project.port) {
+        status.portListening = await isPortListening(project.port);
+      }
+    } else {
+      status.pm2Status = "n/a";
+    }
+    statuses.push(status);
+  }
+  const table = new Table2({
+    head: [
+      chalk3.cyan("Name"),
+      chalk3.cyan("Type"),
+      chalk3.cyan("Hostname"),
+      chalk3.cyan("Port"),
+      chalk3.cyan("PM2 Status"),
+      chalk3.cyan("Port Check")
+    ],
+    style: {
+      head: [],
+      border: []
+    }
+  });
+  for (const status of statuses) {
+    let pm2StatusStr = "-";
+    let portCheckStr = "-";
+    if (status.type === "npm") {
+      switch (status.pm2Status) {
+        case "online":
+          pm2StatusStr = chalk3.green("online");
+          break;
+        case "stopped":
+          pm2StatusStr = chalk3.yellow("stopped");
+          break;
+        case "errored":
+          pm2StatusStr = chalk3.red("errored");
+          break;
+        case "not_managed":
+          pm2StatusStr = chalk3.dim("not started");
+          break;
+        default:
+          pm2StatusStr = chalk3.dim(status.pm2Status || "-");
+      }
+      portCheckStr = status.portListening ? chalk3.green("listening") : chalk3.red("not listening");
+    }
+    if (status.enabled === false) {
+      pm2StatusStr = chalk3.yellow("disabled");
+      portCheckStr = chalk3.dim("-");
+    }
+    table.push([
+      status.name,
+      status.type,
+      status.hostname,
+      status.port?.toString() || "-",
+      pm2StatusStr,
+      portCheckStr
+    ]);
+  }
+  console.log(table.toString());
+  const runningProcesses = getPm2List().filter((p) => p.name.startsWith("bindler:"));
+  if (runningProcesses.length > 0) {
+    console.log(chalk3.bold("\nPM2 Process Details:"));
+    const detailTable = new Table2({
+      head: [
+        chalk3.cyan("Process"),
+        chalk3.cyan("CPU"),
+        chalk3.cyan("Memory"),
+        chalk3.cyan("Uptime"),
+        chalk3.cyan("Restarts")
+      ],
+      style: {
+        head: [],
+        border: []
+      }
+    });
+    for (const proc of runningProcesses) {
+      detailTable.push([
+        proc.name.replace("bindler:", ""),
+        `${proc.cpu}%`,
+        formatBytes(proc.memory),
+        formatUptime(proc.uptime),
+        String(proc.restarts)
+      ]);
+    }
+    console.log(detailTable.toString());
+  }
+}
+
+// src/commands/start.ts
+import chalk4 from "chalk";
+async function startCommand(name, options) {
+  if (options.all) {
+    const projects = listProjects();
+    const npmProjects = projects.filter((p) => p.type === "npm");
+    if (npmProjects.length === 0) {
+      console.log(chalk4.yellow("No npm projects to start."));
+      return;
+    }
+    console.log(chalk4.blue(`Starting ${npmProjects.length} npm project(s)...`));
+    const results = startAllProjects(npmProjects);
+    for (const result2 of results) {
+      if (result2.success) {
+        console.log(chalk4.green(`  \u2713 ${result2.name}`));
+      } else {
+        console.log(chalk4.red(`  \u2717 ${result2.name}: ${result2.error}`));
+      }
+    }
+    const succeeded = results.filter((r) => r.success).length;
+    console.log(chalk4.dim(`
+${succeeded}/${results.length} started successfully`));
+    return;
+  }
+  if (!name) {
+    console.error(chalk4.red("Error: Project name is required. Use --all to start all projects."));
+    process.exit(1);
+  }
+  const project = getProject(name);
+  if (!project) {
+    console.error(chalk4.red(`Error: Project "${name}" not found`));
+    process.exit(1);
+  }
+  if (project.type !== "npm") {
+    console.log(chalk4.blue(`Project "${name}" is a static site - no process to start.`));
+    console.log(chalk4.dim("Static sites are served directly by nginx."));
+    return;
+  }
+  console.log(chalk4.blue(`Starting ${name}...`));
+  const result = startProject(project);
+  if (result.success) {
+    console.log(chalk4.green(`\u2713 ${name} started successfully`));
+    console.log(chalk4.dim(`  Port: ${project.port}`));
+    console.log(chalk4.dim(`  URL: https://${project.hostname}`));
+  } else {
+    console.error(chalk4.red(`\u2717 Failed to start ${name}: ${result.error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/stop.ts
+import chalk5 from "chalk";
+async function stopCommand(name, options) {
+  if (options.all) {
+    const projects = listProjects();
+    const npmProjects = projects.filter((p) => p.type === "npm");
+    if (npmProjects.length === 0) {
+      console.log(chalk5.yellow("No npm projects to stop."));
+      return;
+    }
+    console.log(chalk5.blue(`Stopping ${npmProjects.length} npm project(s)...`));
+    const results = stopAllProjects(npmProjects);
+    for (const result2 of results) {
+      if (result2.success) {
+        console.log(chalk5.green(`  \u2713 ${result2.name}`));
+      } else {
+        console.log(chalk5.red(`  \u2717 ${result2.name}: ${result2.error}`));
+      }
+    }
+    const succeeded = results.filter((r) => r.success).length;
+    console.log(chalk5.dim(`
+${succeeded}/${results.length} stopped successfully`));
+    return;
+  }
+  if (!name) {
+    console.error(chalk5.red("Error: Project name is required. Use --all to stop all projects."));
+    process.exit(1);
+  }
+  const project = getProject(name);
+  if (!project) {
+    console.error(chalk5.red(`Error: Project "${name}" not found`));
+    process.exit(1);
+  }
+  if (project.type !== "npm") {
+    console.log(chalk5.yellow(`Project "${name}" is a static site - no process to stop.`));
+    return;
+  }
+  console.log(chalk5.blue(`Stopping ${name}...`));
+  const result = stopProject(name);
+  if (result.success) {
+    console.log(chalk5.green(`\u2713 ${name} stopped successfully`));
+  } else {
+    console.error(chalk5.red(`\u2717 Failed to stop ${name}: ${result.error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/restart.ts
+import chalk6 from "chalk";
+async function restartCommand(name, options) {
+  if (options.all) {
+    const projects = listProjects();
+    const npmProjects = projects.filter((p) => p.type === "npm");
+    if (npmProjects.length === 0) {
+      console.log(chalk6.yellow("No npm projects to restart."));
+      return;
+    }
+    console.log(chalk6.blue(`Restarting ${npmProjects.length} npm project(s)...`));
+    const results = restartAllProjects(npmProjects);
+    for (const result2 of results) {
+      if (result2.success) {
+        console.log(chalk6.green(`  \u2713 ${result2.name}`));
+      } else {
+        console.log(chalk6.red(`  \u2717 ${result2.name}: ${result2.error}`));
+      }
+    }
+    const succeeded = results.filter((r) => r.success).length;
+    console.log(chalk6.dim(`
+${succeeded}/${results.length} restarted successfully`));
+    return;
+  }
+  if (!name) {
+    console.error(chalk6.red("Error: Project name is required. Use --all to restart all projects."));
+    process2.exit(1);
+  }
+  const project = getProject(name);
+  if (!project) {
+    console.error(chalk6.red(`Error: Project "${name}" not found`));
+    process2.exit(1);
+  }
+  if (project.type !== "npm") {
+    console.log(chalk6.yellow(`Project "${name}" is a static site - no process to restart.`));
+    return;
+  }
+  console.log(chalk6.blue(`Restarting ${name}...`));
+  const process2 = getProcessByName(name);
+  let result;
+  if (process2) {
+    result = restartProject(name);
+  } else {
+    console.log(chalk6.dim("Process not running, starting..."));
+    result = startProject(project);
+  }
+  if (result.success) {
+    console.log(chalk6.green(`\u2713 ${name} restarted successfully`));
+  } else {
+    console.error(chalk6.red(`\u2717 Failed to restart ${name}: ${result.error}`));
+    process2.exit(1);
+  }
+}
+
+// src/commands/logs.ts
+import chalk7 from "chalk";
+async function logsCommand(name, options) {
+  const project = getProject(name);
+  if (!project) {
+    console.error(chalk7.red(`Error: Project "${name}" not found`));
+    process2.exit(1);
+  }
+  if (project.type !== "npm") {
+    console.log(chalk7.yellow(`Project "${name}" is a static site - no logs available.`));
+    console.log(chalk7.dim("Check nginx access/error logs instead:"));
+    console.log(chalk7.dim("  /var/log/nginx/access.log"));
+    console.log(chalk7.dim("  /var/log/nginx/error.log"));
+    return;
+  }
+  const process2 = getProcessByName(name);
+  if (!process2) {
+    console.log(chalk7.yellow(`Project "${name}" has not been started yet.`));
+    console.log(chalk7.dim(`Run ${chalk7.cyan(`bindler start ${name}`)} first.`));
+    return;
+  }
+  const lines = options.lines || 200;
+  const follow = options.follow || false;
+  if (follow) {
+    console.log(chalk7.dim(`Following logs for ${name}... (Ctrl+C to exit)`));
+  }
+  await showLogs(name, follow, lines);
+}
+
+// src/commands/update.ts
+import chalk8 from "chalk";
+async function updateCommand(name, options) {
+  const project = getProject(name);
+  if (!project) {
+    console.error(chalk8.red(`Error: Project "${name}" not found`));
+    process.exit(1);
+  }
+  const updates = {};
+  if (options.hostname) {
+    if (!validateHostname(options.hostname)) {
+      console.error(chalk8.red("Error: Invalid hostname format"));
+      process.exit(1);
+    }
+    updates.hostname = options.hostname;
+  }
+  if (options.port) {
+    const port = parseInt(options.port, 10);
+    if (!validatePort(port)) {
+      console.error(chalk8.red("Error: Invalid port. Use a number between 1024 and 65535."));
+      process.exit(1);
+    }
+    if (!isPortAvailable(port) && port !== project.port) {
+      console.error(chalk8.red(`Error: Port ${port} is already in use by another project.`));
+      process.exit(1);
+    }
+    updates.port = port;
+    if (project.env?.PORT) {
+      updates.env = { ...project.env, PORT: String(port) };
+    }
+  }
+  if (options.start) {
+    if (project.type !== "npm") {
+      console.error(chalk8.red("Error: Start command only applies to npm projects"));
+      process.exit(1);
+    }
+    updates.start = options.start;
+  }
+  if (options.path) {
+    updates.path = options.path;
+  }
+  if (options.env && options.env.length > 0) {
+    const env = { ...project.env || {} };
+    for (const envStr of options.env) {
+      const [key, ...valueParts] = envStr.split("=");
+      if (!key) {
+        console.error(chalk8.red(`Error: Invalid env format: ${envStr}. Use KEY=value`));
+        process.exit(1);
+      }
+      env[key] = valueParts.join("=");
+    }
+    updates.env = env;
+  }
+  if (options.enable) {
+    updates.enabled = true;
+  } else if (options.disable) {
+    updates.enabled = false;
+  }
+  if (Object.keys(updates).length === 0) {
+    console.log(chalk8.yellow("No updates specified."));
+    console.log(chalk8.dim("Available options: --hostname, --port, --start, --path, --env, --enable, --disable"));
+    return;
+  }
+  try {
+    updateProject(name, updates);
+    console.log(chalk8.green(`\u2713 Project "${name}" updated successfully`));
+    for (const [key, value] of Object.entries(updates)) {
+      console.log(chalk8.dim(`  ${key}: ${typeof value === "object" ? JSON.stringify(value) : value}`));
+    }
+    console.log(chalk8.dim(`
+Run ${chalk8.cyan("sudo bindler apply")} to apply changes to nginx.`));
+    if (project.type === "npm" && (updates.port || updates.start || updates.env)) {
+      console.log(chalk8.dim(`Run ${chalk8.cyan(`bindler restart ${name}`)} to apply changes to the running process.`));
+    }
+  } catch (error) {
+    console.error(chalk8.red(`Error: ${error instanceof Error ? error.message : error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/edit.ts
+import { writeFileSync as writeFileSync3, readFileSync as readFileSync3, unlinkSync } from "fs";
+import { tmpdir } from "os";
+import { join as join4 } from "path";
+import chalk9 from "chalk";
+async function editCommand(name) {
+  const project = getProject(name);
+  if (!project) {
+    console.error(chalk9.red(`Error: Project "${name}" not found`));
+    process.exit(1);
+  }
+  const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+  const tmpFile = join4(tmpdir(), `bindler-${name}-${Date.now()}.json`);
+  writeFileSync3(tmpFile, JSON.stringify(project, null, 2) + "\n");
+  console.log(chalk9.dim(`Opening ${name} config in ${editor}...`));
+  const exitCode = await spawnInteractive(editor, [tmpFile]);
+  if (exitCode !== 0) {
+    console.error(chalk9.red("Editor exited with error"));
+    unlinkSync(tmpFile);
+    process.exit(1);
+  }
+  let editedContent;
+  try {
+    editedContent = readFileSync3(tmpFile, "utf-8");
+  } catch (error) {
+    console.error(chalk9.red("Failed to read edited file"));
+    process.exit(1);
+  } finally {
+    unlinkSync(tmpFile);
+  }
+  let editedProject;
+  try {
+    editedProject = JSON.parse(editedContent);
+  } catch (error) {
+    console.error(chalk9.red("Error: Invalid JSON in edited file"));
+    process.exit(1);
+  }
+  if (editedProject.name !== project.name) {
+    console.error(chalk9.red("Error: Cannot change project name via edit. Use a new project instead."));
+    process.exit(1);
+  }
+  const originalStr = JSON.stringify(project);
+  const editedStr = JSON.stringify(editedProject);
+  if (originalStr === editedStr) {
+    console.log(chalk9.yellow("No changes made."));
+    return;
+  }
+  try {
+    const config = readConfig();
+    const index = config.projects.findIndex((p) => p.name === name);
+    if (index === -1) {
+      console.error(chalk9.red("Error: Project not found"));
+      process.exit(1);
+    }
+    config.projects[index] = editedProject;
+    writeConfig(config);
+    console.log(chalk9.green(`\u2713 Project "${name}" updated successfully`));
+    console.log(chalk9.dim(`
+Run ${chalk9.cyan("sudo bindler apply")} to apply changes to nginx.`));
+  } catch (error) {
+    console.error(chalk9.red(`Error: ${error instanceof Error ? error.message : error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/remove.ts
+import inquirer2 from "inquirer";
+import chalk10 from "chalk";
+async function removeCommand(name, options) {
+  const project = getProject(name);
+  if (!project) {
+    console.error(chalk10.red(`Error: Project "${name}" not found`));
+    process.exit(1);
+  }
+  if (!options.force) {
+    const { confirm } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: `Are you sure you want to remove project "${name}" (${project.hostname})?`,
+        default: false
+      }
+    ]);
+    if (!confirm) {
+      console.log(chalk10.yellow("Cancelled."));
+      return;
+    }
+  }
+  if (project.type === "npm") {
+    const process2 = getProcessByName(name);
+    if (process2) {
+      console.log(chalk10.dim("Stopping PM2 process..."));
+      deleteProject(name);
+    }
+  }
+  try {
+    removeProject(name);
+    console.log(chalk10.green(`\u2713 Project "${name}" removed from registry`));
+    console.log(chalk10.dim(`
+Run ${chalk10.cyan("sudo bindler apply")} to update nginx configuration.`));
+    console.log(chalk10.yellow("\nNote: The project files and Cloudflare DNS routes were not removed."));
+    console.log(chalk10.dim(`  Project path: ${project.path}`));
+    console.log(chalk10.dim(`  To remove DNS route manually: cloudflared tunnel route dns --remove ${project.hostname}`));
+  } catch (error) {
+    console.error(chalk10.red(`Error: ${error instanceof Error ? error.message : error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/apply.ts
+import chalk11 from "chalk";
+
+// src/lib/cloudflare.ts
+function isCloudflaredInstalled() {
+  const result = execCommandSafe("which cloudflared");
+  return result.success;
+}
+function getCloudflaredVersion() {
+  const result = execCommandSafe("cloudflared --version");
+  if (result.success) {
+    const match = result.output.match(/cloudflared version (\S+)/);
+    return match ? match[1] : result.output;
+  }
+  return null;
+}
+function listTunnels() {
+  const result = execCommandSafe("cloudflared tunnel list --output json");
+  if (!result.success) {
+    return [];
+  }
+  try {
+    const tunnels = JSON.parse(result.output);
+    return tunnels.map((t) => ({
+      id: t.id,
+      name: t.name,
+      createdAt: t.created_at
+    }));
+  } catch {
+    return [];
+  }
+}
+function getTunnelByName(name) {
+  const tunnels = listTunnels();
+  const tunnel = tunnels.find((t) => t.name === name);
+  return tunnel ? { id: tunnel.id, name: tunnel.name } : null;
+}
+function routeDns(tunnelName, hostname) {
+  const result = execCommandSafe(`cloudflared tunnel route dns "${tunnelName}" "${hostname}"`);
+  if (!result.success) {
+    if (result.error?.includes("already exists") || result.output?.includes("already exists")) {
+      return { success: true, output: "DNS route already exists" };
+    }
+    return { success: false, error: result.error };
+  }
+  return { success: true, output: result.output };
+}
+function routeDnsForAllProjects() {
+  const config = readConfig();
+  const { tunnelName, applyCloudflareDnsRoutes } = config.defaults;
+  if (!applyCloudflareDnsRoutes) {
+    return [];
+  }
+  const results = [];
+  for (const project of config.projects) {
+    if (project.enabled === false) {
+      continue;
+    }
+    if (project.local) {
+      results.push({
+        hostname: project.hostname,
+        success: true,
+        skipped: true,
+        output: "Local project - skipped"
+      });
+      continue;
+    }
+    const result = routeDns(tunnelName, project.hostname);
+    results.push({
+      hostname: project.hostname,
+      ...result
+    });
+  }
+  return results;
+}
+function isTunnelRunning(tunnelName) {
+  const result = execCommandSafe(`pgrep -f "cloudflared.*tunnel.*run.*${tunnelName}"`);
+  return result.success;
+}
+function getTunnelInfo(tunnelName) {
+  const tunnel = getTunnelByName(tunnelName);
+  if (!tunnel) {
+    return { exists: false, running: false };
+  }
+  return {
+    exists: true,
+    running: isTunnelRunning(tunnelName),
+    id: tunnel.id
+  };
+}
+
+// src/commands/apply.ts
+async function applyCommand(options) {
+  const config = readConfig();
+  const defaults = getDefaults();
+  if (config.projects.length === 0) {
+    console.log(chalk11.yellow("No projects registered. Nothing to apply."));
+    return;
+  }
+  console.log(chalk11.blue("Applying configuration...\n"));
+  console.log(chalk11.dim("Generating nginx configuration..."));
+  if (options.dryRun) {
+    const nginxConfig = generateNginxConfig(config);
+    console.log(chalk11.cyan("\n--- Generated nginx config (dry-run) ---\n"));
+    console.log(nginxConfig);
+    console.log(chalk11.cyan("--- End of config ---\n"));
+    console.log(chalk11.yellow("Dry run mode - no changes were made."));
+    return;
+  }
+  try {
+    const { path, content } = writeNginxConfig(config);
+    console.log(chalk11.green(`  \u2713 Wrote nginx config to ${path}`));
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    console.error(chalk11.red(`  \u2717 Failed to write nginx config: ${errMsg}`));
+    if (errMsg.includes("EACCES") || errMsg.includes("permission denied")) {
+      console.log(chalk11.yellow(`
+Try running with sudo: ${chalk11.cyan("sudo bindler apply")}`));
+    }
+    process.exit(1);
+  }
+  console.log(chalk11.dim("Testing nginx configuration..."));
+  const testResult = testNginxConfig();
+  if (!testResult.success) {
+    console.error(chalk11.red("  \u2717 Nginx configuration test failed:"));
+    console.error(chalk11.red(testResult.output));
+    console.log(chalk11.yellow("\nConfiguration was written but nginx was NOT reloaded."));
+    console.log(chalk11.dim("Fix the configuration and run `sudo bindler apply` again."));
+    process.exit(1);
+  }
+  console.log(chalk11.green("  \u2713 Nginx configuration test passed"));
+  if (!options.noReload) {
+    console.log(chalk11.dim("Reloading nginx..."));
+    const reloadResult = reloadNginx();
+    if (!reloadResult.success) {
+      console.error(chalk11.red(`  \u2717 Failed to reload nginx: ${reloadResult.error}`));
+      console.log(chalk11.dim("You may need to reload nginx manually: sudo systemctl reload nginx"));
+      process.exit(1);
+    }
+    console.log(chalk11.green("  \u2713 Nginx reloaded successfully"));
+  } else {
+    console.log(chalk11.yellow("  - Skipped nginx reload (--no-reload)"));
+  }
+  const isDirectMode = defaults.mode === "direct";
+  if (isDirectMode) {
+    console.log(chalk11.dim("\n  - Direct mode: skipping Cloudflare DNS routes"));
+  } else if (!options.noCloudflare && defaults.applyCloudflareDnsRoutes) {
+    console.log(chalk11.dim("\nConfiguring Cloudflare DNS routes..."));
+    if (!isCloudflaredInstalled()) {
+      console.log(chalk11.yellow("  - cloudflared not installed, skipping DNS routes"));
+    } else {
+      const dnsResults = routeDnsForAllProjects();
+      if (dnsResults.length === 0) {
+        console.log(chalk11.dim("  No hostnames to route"));
+      } else {
+        for (const result of dnsResults) {
+          if (result.skipped) {
+            console.log(chalk11.dim(`  - ${result.hostname} (local - skipped)`));
+          } else if (result.success) {
+            const msg = result.output?.includes("already exists") ? "exists" : "routed";
+            console.log(chalk11.green(`  \u2713 ${result.hostname} (${msg})`));
+          } else {
+            console.log(chalk11.red(`  \u2717 ${result.hostname}: ${result.error}`));
+          }
+        }
+      }
+    }
+  } else if (options.noCloudflare) {
+    console.log(chalk11.dim("\n  - Skipped Cloudflare DNS routes (--no-cloudflare)"));
+  }
+  if (isDirectMode && defaults.sslEnabled && options.ssl !== false) {
+    console.log(chalk11.dim("\nSetting up SSL certificates..."));
+    const hostnames = config.projects.filter((p) => p.enabled !== false && !p.local).map((p) => p.hostname);
+    if (hostnames.length === 0) {
+      console.log(chalk11.dim("  No hostnames to secure"));
+    } else {
+      const certbotResult = execCommandSafe("which certbot");
+      if (!certbotResult.success) {
+        console.log(chalk11.yellow("  - certbot not installed, skipping SSL"));
+        console.log(chalk11.dim("    Run: bindler setup --direct"));
+      } else {
+        for (const hostname of hostnames) {
+          console.log(chalk11.dim(`  Requesting certificate for ${hostname}...`));
+          const email = defaults.sslEmail || "admin@" + hostname.split(".").slice(-2).join(".");
+          const result = execCommandSafe(
+            `sudo certbot --nginx -d ${hostname} --non-interactive --agree-tos --email ${email} 2>&1`
+          );
+          if (result.success || result.output?.includes("Certificate not yet due for renewal")) {
+            console.log(chalk11.green(`  \u2713 ${hostname} (secured)`));
+          } else if (result.output?.includes("already exists")) {
+            console.log(chalk11.green(`  \u2713 ${hostname} (exists)`));
+          } else {
+            console.log(chalk11.yellow(`  ! ${hostname}: ${result.error || "failed"}`));
+            console.log(chalk11.dim("    Run manually: sudo certbot --nginx -d " + hostname));
+          }
+        }
+      }
+    }
+  }
+  console.log(chalk11.green("\n\u2713 Configuration applied successfully!"));
+  console.log(chalk11.dim(`
+${config.projects.length} project(s) configured:`));
+  for (const project of config.projects) {
+    const status = project.enabled !== false ? chalk11.green("enabled") : chalk11.yellow("disabled");
+    console.log(chalk11.dim(`  - ${project.name} \u2192 ${project.hostname} (${status})`));
+  }
+}
+
+// src/commands/doctor.ts
+import chalk12 from "chalk";
+import { existsSync as existsSync5 } from "fs";
+async function doctorCommand() {
+  console.log(chalk12.blue("Running diagnostics...\n"));
+  const checks = [];
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.slice(1).split(".")[0], 10);
+  checks.push({
+    name: "Node.js",
+    status: nodeMajor >= 18 ? "ok" : "warning",
+    message: `Version ${nodeVersion}`,
+    fix: nodeMajor < 18 ? "Upgrade to Node.js 18 or later" : void 0
+  });
+  if (isNginxInstalled()) {
+    const version = getNginxVersion();
+    if (isNginxRunning()) {
+      checks.push({
+        name: "nginx",
+        status: "ok",
+        message: `Installed (${version || "version unknown"}) and running`
+      });
+      const isMac = process.platform === "darwin";
+      if (isMac) {
+        const currentUser = process.env.USER || "";
+        const psResult = execCommandSafe('ps aux | grep "nginx: worker" | grep -v grep | head -1');
+        if (psResult.success && psResult.output) {
+          const nginxUser = psResult.output.split(/\s+/)[0];
+          if (nginxUser && nginxUser !== currentUser && (nginxUser === "nobody" || nginxUser === "root")) {
+            checks.push({
+              name: "nginx user",
+              status: "warning",
+              message: `nginx running as "${nginxUser}" (should be "${currentUser}")`,
+              fix: `Fix permissions: sudo chown -R ${currentUser}:staff /opt/homebrew/var/log/nginx /opt/homebrew/var/run && sudo killall nginx && brew services start nginx`
+            });
+          } else {
+            checks.push({
+              name: "nginx user",
+              status: "ok",
+              message: `Running as "${nginxUser}"`
+            });
+          }
+        }
+      }
+    } else {
+      const isMac = process.platform === "darwin";
+      checks.push({
+        name: "nginx",
+        status: "warning",
+        message: `Installed (${version || "version unknown"}) but not running`,
+        fix: isMac ? "Start nginx: brew services start nginx" : "Start nginx: sudo systemctl start nginx"
+      });
+    }
+  } else {
+    checks.push({
+      name: "nginx",
+      status: "error",
+      message: "Not installed",
+      fix: "Run `bindler setup` to install"
+    });
+  }
+  if (isPm2Installed()) {
+    const processes = getPm2List();
+    const bindlerProcesses = processes.filter((p) => p.name.startsWith("bindler:"));
+    checks.push({
+      name: "PM2",
+      status: "ok",
+      message: `Installed, ${bindlerProcesses.length} bindler process(es) managed`
+    });
+  } else {
+    checks.push({
+      name: "PM2",
+      status: "error",
+      message: "Not installed",
+      fix: "Run `bindler setup` to install"
+    });
+  }
+  if (isCloudflaredInstalled()) {
+    const version = getCloudflaredVersion();
+    checks.push({
+      name: "cloudflared",
+      status: "ok",
+      message: `Installed (${version || "version unknown"})`
+    });
+    if (configExists()) {
+      const defaults = getDefaults();
+      const tunnelInfo = getTunnelInfo(defaults.tunnelName);
+      if (tunnelInfo.exists) {
+        checks.push({
+          name: "Cloudflare Tunnel",
+          status: tunnelInfo.running ? "ok" : "warning",
+          message: tunnelInfo.running ? `Tunnel "${defaults.tunnelName}" exists and running` : `Tunnel "${defaults.tunnelName}" exists but not running`,
+          fix: !tunnelInfo.running ? `Start tunnel: cloudflared tunnel run ${defaults.tunnelName}` : void 0
+        });
+      } else {
+        checks.push({
+          name: "Cloudflare Tunnel",
+          status: "warning",
+          message: `Tunnel "${defaults.tunnelName}" not found`,
+          fix: `Create tunnel: cloudflared tunnel create ${defaults.tunnelName}`
+        });
+      }
+    }
+  } else {
+    checks.push({
+      name: "cloudflared",
+      status: "warning",
+      message: "Not installed (optional, for Cloudflare Tunnel)",
+      fix: "Run `bindler setup` or visit https://pkg.cloudflare.com/index.html"
+    });
+  }
+  if (configExists()) {
+    const config = readConfig();
+    checks.push({
+      name: "Bindler config",
+      status: "ok",
+      message: `${config.projects.length} project(s) registered`
+    });
+    const isMac = process.platform === "darwin";
+    if (isMac && config.projects.length > 0) {
+      const homeDir = process.env.HOME || "";
+      const protectedPaths = ["/Desktop/", "/Documents/", "/Downloads/"];
+      const protectedProjects = config.projects.filter(
+        (p) => protectedPaths.some((pp) => p.path.startsWith(homeDir + pp))
+      );
+      if (protectedProjects.length > 0) {
+        const currentUser = process.env.USER || "";
+        const psResult = execCommandSafe('ps aux | grep "nginx: worker" | grep -v grep | head -1');
+        const nginxUser = psResult.success && psResult.output ? psResult.output.split(/\s+/)[0] : "";
+        if (nginxUser && nginxUser !== currentUser) {
+          checks.push({
+            name: "Protected folders",
+            status: "warning",
+            message: `${protectedProjects.length} project(s) in ~/Desktop, ~/Documents, or ~/Downloads`,
+            fix: `nginx must run as "${currentUser}" to access these folders. Run: sudo chown -R ${currentUser}:staff /opt/homebrew/var/log/nginx /opt/homebrew/var/run && sudo killall nginx && brew services start nginx`
+          });
+        }
+      }
+    }
+    const defaults = getDefaults();
+    if (existsSync5(defaults.nginxManagedPath)) {
+      checks.push({
+        name: "Nginx config file",
+        status: "ok",
+        message: `Exists at ${defaults.nginxManagedPath}`
+      });
+    } else {
+      checks.push({
+        name: "Nginx config file",
+        status: "warning",
+        message: `Not found at ${defaults.nginxManagedPath}`,
+        fix: "Run: sudo bindler apply"
+      });
+    }
+    if (existsSync5(defaults.projectsRoot)) {
+      checks.push({
+        name: "Projects root",
+        status: "ok",
+        message: `Exists at ${defaults.projectsRoot}`
+      });
+    } else {
+      checks.push({
+        name: "Projects root",
+        status: "warning",
+        message: `Not found at ${defaults.projectsRoot}`,
+        fix: `Create directory: sudo mkdir -p ${defaults.projectsRoot}`
+      });
+    }
+  } else {
+    checks.push({
+      name: "Bindler config",
+      status: "warning",
+      message: "Not initialized",
+      fix: "Run: bindler new (to create first project)"
+    });
+  }
+  let hasErrors = false;
+  let hasWarnings = false;
+  for (const check of checks) {
+    let icon;
+    let color;
+    switch (check.status) {
+      case "ok":
+        icon = "\u2713";
+        color = chalk12.green;
+        break;
+      case "warning":
+        icon = "!";
+        color = chalk12.yellow;
+        hasWarnings = true;
+        break;
+      case "error":
+        icon = "\u2717";
+        color = chalk12.red;
+        hasErrors = true;
+        break;
+    }
+    console.log(`${color(icon)} ${chalk12.bold(check.name)}: ${check.message}`);
+    if (check.fix) {
+      console.log(chalk12.dim(`  Fix: ${check.fix}`));
+    }
+  }
+  console.log("");
+  if (hasErrors) {
+    console.log(chalk12.red("Some checks failed. Please fix the issues above."));
+    process.exit(1);
+  } else if (hasWarnings) {
+    console.log(chalk12.yellow("Some warnings detected. Review the suggestions above."));
+  } else {
+    console.log(chalk12.green("All checks passed!"));
+  }
+}
+
+// src/commands/ports.ts
+import chalk13 from "chalk";
+import Table3 from "cli-table3";
+async function portsCommand() {
+  const ports = getPortsTable();
+  if (ports.length === 0) {
+    console.log(chalk13.yellow("No ports allocated."));
+    console.log(chalk13.dim("npm projects will have ports allocated when created."));
+    return;
+  }
+  const table = new Table3({
+    head: [chalk13.cyan("Port"), chalk13.cyan("Project"), chalk13.cyan("Hostname")],
+    style: {
+      head: [],
+      border: []
+    }
+  });
+  for (const entry of ports) {
+    table.push([String(entry.port), entry.project, entry.hostname]);
+  }
+  console.log(table.toString());
+  console.log(chalk13.dim(`
+${ports.length} port(s) allocated`));
+}
+
+// src/commands/info.ts
+import chalk14 from "chalk";
+async function infoCommand() {
+  console.log(chalk14.bold.cyan(String.raw`
+   _   _       _ _
+  | |_|_|___ _| | |___ ___
+  | . | |   | . | | -_|  _|
+  |___|_|_|_|___|_|___|_|
+  `));
+  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.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"));
+  console.log("");
+  if (configExists()) {
+    const config = readConfig();
+    const pm2Processes = getPm2List().filter((p) => p.name.startsWith("bindler:"));
+    const runningCount = pm2Processes.filter((p) => p.status === "online").length;
+    const npmProjects = config.projects.filter((p) => p.type === "npm").length;
+    const staticProjects = config.projects.filter((p) => p.type === "static").length;
+    console.log(chalk14.dim("  Config:   ") + chalk14.white(getConfigPath()));
+    console.log(chalk14.dim("  Nginx:    ") + chalk14.white(config.defaults.nginxManagedPath));
+    console.log(chalk14.dim("  Tunnel:   ") + chalk14.white(config.defaults.tunnelName));
+    console.log("");
+    console.log(chalk14.dim("  Projects: ") + chalk14.white(`${config.projects.length} total (${staticProjects} static, ${npmProjects} npm)`));
+    if (npmProjects > 0) {
+      console.log(chalk14.dim("  Running:  ") + chalk14.green(`${runningCount}/${npmProjects} npm apps online`));
+    }
+  } else {
+    console.log(chalk14.dim("  Config:   ") + chalk14.yellow("Not initialized"));
+    console.log(chalk14.dim("            ") + chalk14.dim("Run `bindler new` to get started"));
+  }
+  console.log("");
+}
+
+// src/commands/check.ts
+import chalk15 from "chalk";
+import { resolve4, resolve6, resolveCname } from "dns/promises";
+async function checkDns(hostname) {
+  const result = {
+    resolved: false,
+    ipv4: [],
+    ipv6: [],
+    cname: [],
+    isCloudflare: false
+  };
+  try {
+    result.ipv4 = await resolve4(hostname);
+    result.resolved = true;
+  } catch {
+  }
+  try {
+    result.ipv6 = await resolve6(hostname);
+    result.resolved = true;
+  } catch {
+  }
+  try {
+    result.cname = await resolveCname(hostname);
+    result.resolved = true;
+    result.isCloudflare = result.cname.some(
+      (c) => c.includes("cfargotunnel.com") || c.includes("cloudflare")
+    );
+  } catch {
+  }
+  return result;
+}
+async function checkHttp(hostname, path = "/") {
+  const url = `https://${hostname}${path}`;
+  const startTime = Date.now();
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1e4);
+    const response = await fetch(url, {
+      method: "HEAD",
+      redirect: "manual",
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    const responseTime = Date.now() - startTime;
+    return {
+      reachable: true,
+      statusCode: response.status,
+      redirectUrl: response.headers.get("location") || void 0,
+      responseTime
+    };
+  } catch (error) {
+    return {
+      reachable: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function checkCommand(hostnameOrName, options) {
+  const project = getProject(hostnameOrName);
+  const hostname = project ? project.hostname : hostnameOrName;
+  const basePath = project?.basePath || "/";
+  console.log(chalk15.blue(`
+Checking ${hostname}...
+`));
+  console.log(chalk15.bold("DNS Resolution:"));
+  const dns = await checkDns(hostname);
+  if (!dns.resolved) {
+    console.log(chalk15.red("  \u2717 DNS not resolving"));
+    console.log(chalk15.dim("    The hostname does not have any DNS records."));
+    console.log(chalk15.dim("    Run: cloudflared tunnel route dns <tunnel> " + hostname));
+    console.log("");
+    return;
+  }
+  if (dns.cname.length > 0) {
+    console.log(chalk15.green("  \u2713 CNAME: ") + dns.cname.join(", "));
+    if (dns.isCloudflare) {
+      console.log(chalk15.green("  \u2713 Points to Cloudflare Tunnel"));
+    }
+  }
+  if (dns.ipv4.length > 0) {
+    console.log(chalk15.green("  \u2713 A (IPv4): ") + dns.ipv4.join(", "));
+  }
+  if (dns.ipv6.length > 0) {
+    console.log(chalk15.green("  \u2713 AAAA (IPv6): ") + dns.ipv6.join(", "));
+  }
+  console.log("");
+  console.log(chalk15.bold("HTTP Check:"));
+  const http = await checkHttp(hostname, basePath);
+  if (!http.reachable) {
+    console.log(chalk15.red("  \u2717 Not reachable"));
+    console.log(chalk15.dim(`    Error: ${http.error}`));
+    console.log("");
+    console.log(chalk15.yellow("Possible issues:"));
+    console.log(chalk15.dim("  - Cloudflare tunnel not running"));
+    console.log(chalk15.dim("  - Nginx not running or misconfigured"));
+    console.log(chalk15.dim("  - Project not started (if npm app)"));
+    return;
+  }
+  const statusColor = http.statusCode < 400 ? chalk15.green : chalk15.red;
+  console.log(statusColor(`  \u2713 Status: ${http.statusCode}`));
+  console.log(chalk15.dim(`  Response time: ${http.responseTime}ms`));
+  if (http.redirectUrl) {
+    console.log(chalk15.dim(`  Redirects to: ${http.redirectUrl}`));
+  }
+  console.log("");
+  if (dns.resolved && http.reachable && http.statusCode < 400) {
+    console.log(chalk15.green("\u2713 All checks passed! Site is accessible."));
+  } else if (dns.resolved && http.reachable) {
+    console.log(chalk15.yellow("! Site is reachable but returned an error status."));
+  } else {
+    console.log(chalk15.red("\u2717 Some checks failed. See details above."));
+  }
+  if (project) {
+    console.log(chalk15.dim(`
+Project: ${project.name} (${project.type})`));
+    if (project.type === "npm") {
+      console.log(chalk15.dim(`Port: ${project.port}`));
+    }
+  }
+  console.log("");
+}
+
+// src/commands/setup.ts
+import chalk16 from "chalk";
+import inquirer3 from "inquirer";
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+function detectOs() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return { platform: "darwin", distro: "macOS", packageManager: "brew" };
+  }
+  if (platform === "win32") {
+    return { platform: "win32", distro: "Windows", packageManager: "winget" };
+  }
+  if (platform === "linux") {
+    try {
+      if (existsSync6("/etc/os-release")) {
+        const osRelease = readFileSync4("/etc/os-release", "utf-8");
+        const lines = osRelease.split("\n");
+        const info = {};
+        for (const line of lines) {
+          const [key, ...valueParts] = line.split("=");
+          if (key && valueParts.length > 0) {
+            info[key] = valueParts.join("=").replace(/"/g, "");
+          }
+        }
+        const distro = info["ID"] || "linux";
+        const version = info["VERSION_ID"];
+        const codename = info["VERSION_CODENAME"];
+        let packageManager;
+        if (["ubuntu", "debian", "pop", "mint", "elementary"].includes(distro)) {
+          packageManager = "apt";
+        } else if (["fedora", "rhel", "centos", "rocky", "alma"].includes(distro)) {
+          packageManager = existsSync6("/usr/bin/dnf") ? "dnf" : "yum";
+        } else if (["amzn"].includes(distro)) {
+          packageManager = "yum";
+        }
+        return { platform: "linux", distro, version, codename, packageManager };
+      }
+    } catch {
+    }
+    return { platform: "linux", distro: "unknown" };
+  }
+  return { platform: "unknown" };
+}
+function runCommand(command, description) {
+  console.log(chalk16.dim(`  \u2192 ${description}...`));
+  try {
+    execSync2(command, { stdio: "inherit" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installNginx(os) {
+  console.log(chalk16.blue("\nInstalling nginx...\n"));
+  if (os.platform === "darwin") {
+    return runCommand("brew install nginx", "Installing via Homebrew");
+  }
+  if (os.platform === "linux" && os.packageManager === "apt") {
+    runCommand("sudo apt-get update", "Updating package list");
+    return runCommand("sudo apt-get install -y nginx", "Installing nginx");
+  }
+  if (os.platform === "linux" && (os.packageManager === "yum" || os.packageManager === "dnf")) {
+    return runCommand(`sudo ${os.packageManager} install -y nginx`, "Installing nginx");
+  }
+  console.log(chalk16.yellow("  Automatic installation not supported for your OS."));
+  console.log(chalk16.dim("  Please install nginx manually."));
+  return false;
+}
+async function installPm2() {
+  console.log(chalk16.blue("\nInstalling PM2...\n"));
+  return runCommand("npm install -g pm2", "Installing via npm");
+}
+async function installCertbot(os) {
+  console.log(chalk16.blue("\nInstalling certbot (Let's Encrypt)...\n"));
+  if (os.platform === "darwin") {
+    return runCommand("brew install certbot", "Installing via Homebrew");
+  }
+  if (os.platform === "linux" && os.packageManager === "apt") {
+    runCommand("sudo apt-get update", "Updating package list");
+    return runCommand("sudo apt-get install -y certbot python3-certbot-nginx", "Installing certbot");
+  }
+  if (os.platform === "linux" && (os.packageManager === "yum" || os.packageManager === "dnf")) {
+    return runCommand(`sudo ${os.packageManager} install -y certbot python3-certbot-nginx`, "Installing certbot");
+  }
+  console.log(chalk16.yellow("  Automatic installation not supported for your OS."));
+  console.log(chalk16.dim("  Please install certbot manually."));
+  return false;
+}
+function isCertbotInstalled() {
+  const result = execCommandSafe("which certbot");
+  return result.success;
+}
+async function installCloudflared(os) {
+  console.log(chalk16.blue("\nInstalling cloudflared...\n"));
+  if (os.platform === "darwin") {
+    return runCommand("brew install cloudflared", "Installing via Homebrew");
+  }
+  if (os.platform === "win32") {
+    return runCommand("winget install --id Cloudflare.cloudflared", "Installing via winget");
+  }
+  if (os.platform === "linux" && os.packageManager === "apt") {
+    runCommand(
+      "sudo mkdir -p --mode=0755 /usr/share/keyrings",
+      "Creating keyrings directory"
+    );
+    runCommand(
+      "curl -fsSL https://pkg.cloudflare.com/cloudflare-main.gpg | sudo tee /usr/share/keyrings/cloudflare-main.gpg >/dev/null",
+      "Adding Cloudflare GPG key"
+    );
+    let repoLine = "deb [signed-by=/usr/share/keyrings/cloudflare-main.gpg] https://pkg.cloudflare.com/cloudflared any main";
+    if (os.codename) {
+      repoLine = `deb [signed-by=/usr/share/keyrings/cloudflare-main.gpg] https://pkg.cloudflare.com/cloudflared ${os.codename} main`;
+    }
+    runCommand(
+      `echo '${repoLine}' | sudo tee /etc/apt/sources.list.d/cloudflared.list`,
+      "Adding Cloudflare repository"
+    );
+    runCommand("sudo apt-get update", "Updating package list");
+    return runCommand("sudo apt-get install -y cloudflared", "Installing cloudflared");
+  }
+  if (os.platform === "linux" && (os.packageManager === "yum" || os.packageManager === "dnf")) {
+    runCommand(
+      "curl -fsSl https://pkg.cloudflare.com/cloudflared.repo | sudo tee /etc/yum.repos.d/cloudflared.repo",
+      "Adding Cloudflare repository"
+    );
+    return runCommand(`sudo ${os.packageManager} install -y cloudflared`, "Installing cloudflared");
+  }
+  console.log(chalk16.yellow("  Automatic installation not supported for your OS."));
+  console.log(chalk16.dim("  Visit: https://pkg.cloudflare.com/index.html"));
+  return false;
+}
+async function setupCommand(options = {}) {
+  console.log(chalk16.bold.cyan("\nBindler Setup\n"));
+  const os = detectOs();
+  console.log(chalk16.dim(`Detected: ${os.distro || os.platform}${os.version ? ` ${os.version}` : ""}${os.codename ? ` (${os.codename})` : ""}`));
+  const isDirect = options.direct;
+  if (isDirect) {
+    console.log(chalk16.cyan("\nDirect mode (VPS without Cloudflare Tunnel)"));
+    console.log(chalk16.dim("nginx will listen on port 80/443 directly\n"));
+  } else {
+    console.log(chalk16.cyan("\nTunnel mode (via Cloudflare Tunnel)"));
+    console.log(chalk16.dim("nginx will listen on 127.0.0.1:8080\n"));
+  }
+  const missing = [];
+  if (!isNginxInstalled()) {
+    missing.push({ name: "nginx", install: () => installNginx(os) });
+  }
+  if (!isPm2Installed()) {
+    missing.push({ name: "PM2", install: () => installPm2() });
+  }
+  if (isDirect) {
+    if (!isCertbotInstalled()) {
+      missing.push({ name: "certbot", install: () => installCertbot(os) });
+    }
+  } else {
+    if (!isCloudflaredInstalled()) {
+      missing.push({ name: "cloudflared", install: () => installCloudflared(os) });
+    }
+  }
+  if (missing.length === 0) {
+    console.log(chalk16.green("\u2713 All dependencies are already installed!\n"));
+  } else {
+    console.log(chalk16.yellow("Missing dependencies:\n"));
+    for (const dep of missing) {
+      console.log(chalk16.red(`  \u2717 ${dep.name}`));
+    }
+    console.log("");
+    const { toInstall } = await inquirer3.prompt([
+      {
+        type: "checkbox",
+        name: "toInstall",
+        message: "Select dependencies to install:",
+        choices: missing.map((dep) => ({
+          name: dep.name,
+          value: dep.name,
+          checked: true
+        }))
+      }
+    ]);
+    if (toInstall.length > 0) {
+      const results = [];
+      for (const depName of toInstall) {
+        const dep = missing.find((m) => m.name === depName);
+        if (dep) {
+          const success = await dep.install();
+          results.push({ name: depName, success });
+        }
+      }
+      console.log(chalk16.bold("\n\nInstallation Summary:\n"));
+      for (const result of results) {
+        if (result.success) {
+          console.log(chalk16.green(`  \u2713 ${result.name} installed`));
+        } else {
+          console.log(chalk16.red(`  \u2717 ${result.name} failed`));
+        }
+      }
+      console.log("");
+    }
+  }
+  const config = configExists() ? readConfig() : initConfig();
+  if (isDirect) {
+    config.defaults.mode = "direct";
+    config.defaults.nginxListen = "80";
+    config.defaults.applyCloudflareDnsRoutes = false;
+    const { enableSsl } = await inquirer3.prompt([
+      {
+        type: "confirm",
+        name: "enableSsl",
+        message: "Enable SSL with Let's Encrypt?",
+        default: true
+      }
+    ]);
+    if (enableSsl) {
+      const { email } = await inquirer3.prompt([
+        {
+          type: "input",
+          name: "email",
+          message: "Email for Let's Encrypt notifications:",
+          validate: (input) => {
+            if (!input || !input.includes("@")) {
+              return "Please enter a valid email address";
+            }
+            return true;
+          }
+        }
+      ]);
+      config.defaults.sslEnabled = true;
+      config.defaults.sslEmail = email;
+    }
+  } else {
+    config.defaults.mode = "tunnel";
+    config.defaults.nginxListen = "127.0.0.1:8080";
+    config.defaults.applyCloudflareDnsRoutes = true;
+  }
+  writeConfig(config);
+  console.log(chalk16.green("\n\u2713 Setup complete!\n"));
+  console.log(chalk16.dim(`Mode: ${config.defaults.mode}`));
+  console.log(chalk16.dim(`nginx listen: ${config.defaults.nginxListen}`));
+  if (config.defaults.sslEnabled) {
+    console.log(chalk16.dim(`SSL: enabled (${config.defaults.sslEmail})`));
+  }
+  console.log(chalk16.dim("\nRun `bindler new` to create your first project."));
+}
+
+// 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");
+program.hook("preAction", () => {
+  try {
+    initConfig();
+  } catch (error) {
+  }
+});
+program.command("new").description("Create and register a new project").option("-n, --name <name>", "Project name").option("-t, --type <type>", "Project type (static or npm)", "static").option("-p, --path <path>", "Project directory path").option("-h, --hostname <hostname>", "Hostname for the project").option("-b, --base-path <path>", "Base path for path-based routing (e.g., /api)").option("--port <port>", "Port number (npm projects only)").option("-s, --start <command>", "Start command (npm projects only)").option("-l, --local", "Local project (skip Cloudflare, use .local hostname)").option("--apply", "Apply nginx config after creating").action(async (options) => {
+  await newCommand(options);
+});
+program.command("list").alias("ls").description("List all registered projects").action(async () => {
+  await listCommand();
+});
+program.command("status").description("Show detailed status of all projects").action(async () => {
+  await statusCommand();
+});
+program.command("start [name]").description("Start an npm project with PM2").option("-a, --all", "Start all npm projects").action(async (name, options) => {
+  await startCommand(name, options);
+});
+program.command("stop [name]").description("Stop an npm project").option("-a, --all", "Stop all npm projects").action(async (name, options) => {
+  await stopCommand(name, options);
+});
+program.command("restart [name]").description("Restart an npm project").option("-a, --all", "Restart all npm projects").action(async (name, options) => {
+  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) => {
+  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) => {
+  await updateCommand(name, options);
+});
+program.command("edit <name>").description("Edit project configuration in $EDITOR").action(async (name) => {
+  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) => {
+  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) => {
+  await applyCommand(options);
+});
+program.command("doctor").description("Run system diagnostics and check dependencies").action(async () => {
+  await doctorCommand();
+});
+program.command("ports").description("Show allocated ports").action(async () => {
+  await portsCommand();
+});
+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) => {
+  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.parse();
+//# sourceMappingURL=cli.js.map