tmex-cli 0.13.0 → 0.15.0

package/dist/cli-node.js

@@ -6,6 +6,7 @@ import { resolve as resolve4 } from "node:path";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 var MIN_BUN_VERSION = "1.3.0";
+var MIN_TMUX_VERSION = { major: 3, minor: 0 };
 var DEFAULT_SERVICE_NAME = "tmex";
 function defaultInstallDir(platform) {
   if (platform === "darwin") {
@@ -29,8 +30,8 @@ var MESSAGES = {
     "cli.help": `tmex CLI
 
 Usage:
-  tmex init [--no-interactive --install-dir <path> --host <host> --port <port> --db-path <path> --autostart <true|false> --bun-path <path>]
-  tmex doctor [--install-dir <path>] [--json] [--bun-path <path>]
+  tmex init [--no-interactive --install-dir <path> --host <host> --port <port> --db-path <path> --autostart <true|false> --bun-path <path> --install-deps --skip-dep-check]
+  tmex doctor [--install-dir <path>] [--json] [--bun-path <path>] [--fix]
   tmex upgrade [--version <version>] [--install-dir <path>] [--bun-path <path>]
   tmex uninstall [--install-dir <path>] [--yes] [--purge]
 
@@ -74,6 +75,7 @@ Global flags:
     "init.prompt.serviceName": "Service name (service-name)",
     "init.prompt.dirExistsConfirm": "Directory {{installDir}} already exists. Continue (will not delete existing config/db)?",
     "init.error.installDirNotEmpty": "Install directory is not empty: {{installDir}}. Use --force to overwrite.",
+    "init.error.noServiceManager": "No supported service manager found (platform: {{platform}}). tmex requires systemd (Linux) or launchd (macOS).",
     "init.warning.noServiceManager": "Service manager is not supported on platform {{platform}}. Files are deployed but autostart is not configured.",
     "init.done": "Initialization completed.",
     "init.summary.installDir": "Install dir",
@@ -87,8 +89,12 @@ Global flags:
     "doctor.platform.unsupported": "Platform {{platform}} is not officially supported (only macOS and common Linux distros are guaranteed).",
     "doctor.bun.ok": "Bun installed: {{version}}",
     "doctor.bun.fail": "Bun check failed: {{reason}}",
-    "doctor.tmux.ok": "tmux installed",
-    "doctor.tmux.fail": "tmux not found (tmex requires tmux).",
+    "doctor.tmux.ok": "tmux installed: {{version}}",
+    "doctor.tmux.fail": "tmux not found (tmex requires tmux >= 3.0).",
+    "doctor.tmux.versionLow": "tmux version too low: {{version}} (requires >= 3.0)",
+    "doctor.fix.header": "Attempting to fix issues...",
+    "doctor.fix.skip": "Skipping unfixable item: {{id}}",
+    "doctor.fix.hint": 'Run "tmex doctor --fix" to attempt automatic installation.',
     "doctor.ssh.ok": "ssh installed",
     "doctor.ssh.missing": "ssh not found; SSH devices will not work.",
     "doctor.installDir.exists": "Install directory exists: {{installDir}}",
@@ -119,6 +125,19 @@ Global flags:
     "uninstall.done": "Uninstall completed.",
     "uninstall.summary.installDir": "Install dir",
     "uninstall.summary.serviceName": "Service name",
+    "tmux.notFound": "tmux not found. tmex requires tmux >= 3.0 to operate.",
+    "tmux.versionTooLow": "tmux version too low: current {{version}}, required >= 3.0",
+    "deps.install.confirm": "Install {{dep}} now?",
+    "deps.install.running": "Installing {{dep}}...",
+    "deps.install.success": "{{dep}} installed successfully.",
+    "deps.install.failed": "Failed to install {{dep}}.",
+    "deps.install.manual": "Please install manually and retry.",
+    "deps.install.sudoRequired": "This operation requires sudo.",
+    "deps.install.sudoUnavailable": "sudo is not available. Please run as root or install sudo.",
+    "deps.install.nonInteractive": "Missing dependency: {{dep}}. Use --install-deps to install automatically.",
+    "deps.install.hint": "Suggested install command: {{command}}",
+    "deps.install.brewMissing": "Homebrew not found. Install Homebrew first: https://brew.sh",
+    "deps.install.unknownDistro": "Unable to detect Linux distribution. Please install {{dep}} manually.",
     "runtime.restartRequested": "Restart requested; exiting for service manager restart.",
     "runtime.started": "Service started on {{url}}",
     "runtime.frontendMissing": "Frontend assets not found.",
@@ -130,8 +149,8 @@ Global flags:
     "cli.help": `tmex CLI
 
 用法：
-  tmex init [--no-interactive --install-dir <path> --host <host> --port <port> --db-path <path> --autostart <true|false> --bun-path <path>]
-  tmex doctor [--install-dir <path>] [--json] [--bun-path <path>]
+  tmex init [--no-interactive --install-dir <path> --host <host> --port <port> --db-path <path> --autostart <true|false> --bun-path <path> --install-deps --skip-dep-check]
+  tmex doctor [--install-dir <path>] [--json] [--bun-path <path>] [--fix]
   tmex upgrade [--version <version>] [--install-dir <path>] [--bun-path <path>]
   tmex uninstall [--install-dir <path>] [--yes] [--purge]
 
@@ -175,6 +194,7 @@ Global flags:
     "init.prompt.serviceName": "服务名称（service-name）",
     "init.prompt.dirExistsConfirm": "目录 {{installDir}} 已存在，是否继续（不会删除现有配置与数据库）？",
     "init.error.installDirNotEmpty": "安装目录已存在且非空：{{installDir}}。如需覆盖请加 --force",
+    "init.error.noServiceManager": "未检测到可用的服务管理器（平台：{{platform}}）。tmex 需要 systemd（Linux）或 launchd（macOS）。",
     "init.warning.noServiceManager": "当前平台 {{platform}} 未实现自动服务安装，已完成文件部署。",
     "init.done": "初始化完成。",
     "init.summary.installDir": "安装目录",
@@ -188,8 +208,12 @@ Global flags:
     "doctor.platform.unsupported": "当前平台 {{platform}} 非官方支持范围（仅保证 macOS 与常见 Linux 发行版）。",
     "doctor.bun.ok": "Bun 已安装：{{version}}",
     "doctor.bun.fail": "Bun 检查失败：{{reason}}",
-    "doctor.tmux.ok": "tmux 已安装",
-    "doctor.tmux.fail": "未检测到 tmux（tmex 需要 tmux 才能工作）。",
+    "doctor.tmux.ok": "tmux 已安装：{{version}}",
+    "doctor.tmux.fail": "未检测到 tmux（tmex 需要 tmux >= 3.0 才能工作）。",
+    "doctor.tmux.versionLow": "tmux 版本过低：{{version}}（要求 >= 3.0）",
+    "doctor.fix.header": "正在尝试修复问题...",
+    "doctor.fix.skip": "跳过无法自动修复的项目：{{id}}",
+    "doctor.fix.hint": '运行 "tmex doctor --fix" 尝试自动安装缺失的依赖。',
     "doctor.ssh.ok": "ssh 已安装",
     "doctor.ssh.missing": "未检测到 ssh，远程设备将不可用。",
     "doctor.installDir.exists": "安装目录存在：{{installDir}}",
@@ -220,6 +244,19 @@ Global flags:
     "uninstall.done": "卸载完成。",
     "uninstall.summary.installDir": "安装目录",
     "uninstall.summary.serviceName": "服务名称",
+    "tmux.notFound": "未检测到 tmux。tmex 需要 tmux >= 3.0 才能工作。",
+    "tmux.versionTooLow": "tmux 版本过低：当前 {{version}}，要求 >= 3.0",
+    "deps.install.confirm": "是否现在安装 {{dep}}？",
+    "deps.install.running": "正在安装 {{dep}}...",
+    "deps.install.success": "{{dep}} 安装成功。",
+    "deps.install.failed": "安装 {{dep}} 失败。",
+    "deps.install.manual": "请手动安装后重试。",
+    "deps.install.sudoRequired": "此操作需要 sudo 权限。",
+    "deps.install.sudoUnavailable": "sudo 不可用，请以 root 身份执行或安装 sudo。",
+    "deps.install.nonInteractive": "缺少依赖：{{dep}}。使用 --install-deps 自动安装。",
+    "deps.install.hint": "建议安装命令：{{command}}",
+    "deps.install.brewMissing": "未检测到 Homebrew，请先安装 Homebrew：https://brew.sh",
+    "deps.install.unknownDistro": "无法检测 Linux 发行版，请手动安装 {{dep}}。",
     "runtime.restartRequested": "收到重启请求，退出并等待服务管理器拉起。",
     "runtime.started": "服务已启动：{{url}}",
     "runtime.frontendMissing": "未找到前端静态资源。",
@@ -574,8 +611,307 @@ async function checkBunVersion(minVersion = MIN_BUN_VERSION, opts = {}) {
   return firstFailure ?? { ok: false, reason: t("bun.notFound") };
 }
 
+// src/lib/linux-distro.ts
+import { readFile } from "node:fs/promises";
+function parseOsRelease(content) {
+  const lines = content.split(`
+`);
+  const fields = {};
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex < 0)
+      continue;
+    const key = trimmed.slice(0, eqIndex);
+    let value = trimmed.slice(eqIndex + 1);
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    fields[key] = value;
+  }
+  const id = fields.ID;
+  if (!id)
+    return null;
+  const idLikeRaw = fields.ID_LIKE;
+  const idLike = idLikeRaw ? idLikeRaw.split(/\s+/).filter(Boolean) : [];
+  return {
+    id,
+    idLike,
+    versionId: fields.VERSION_ID,
+    name: fields.NAME
+  };
+}
+async function detectLinuxDistro() {
+  try {
+    const content = await readFile("/etc/os-release", "utf-8");
+    return parseOsRelease(content);
+  } catch {
+    return null;
+  }
+}
+function detectPackageManager(distro, platform = process.platform) {
+  if (platform === "darwin")
+    return "brew";
+  if (platform !== "linux")
+    return "unknown";
+  if (!distro)
+    return "unknown";
+  const allIds = [distro.id, ...distro.idLike];
+  for (const id of allIds) {
+    const lower = id.toLowerCase();
+    if (lower === "debian" || lower === "ubuntu")
+      return "apt";
+    if (lower === "fedora" || lower === "rhel" || lower === "centos")
+      return "dnf";
+    if (lower === "arch" || lower === "manjaro")
+      return "pacman";
+    if (lower === "alpine")
+      return "apk";
+    if (lower.startsWith("opensuse") || lower === "suse")
+      return "zypper";
+  }
+  return "unknown";
+}
+
+// src/lib/prompt.ts
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+async function promptText(ctx, message, defaultValue) {
+  if (ctx.nonInteractive) {
+    return defaultValue ?? "";
+  }
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const suffix = defaultValue !== undefined ? ` (${defaultValue})` : "";
+    const answer = (await rl.question(`${message}${suffix}: `)).trim();
+    return answer || defaultValue || "";
+  } finally {
+    rl.close();
+  }
+}
+async function promptConfirm(ctx, message, defaultValue) {
+  if (ctx.nonInteractive) {
+    return defaultValue;
+  }
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const hint = defaultValue ? "Y/n" : "y/N";
+    const answer = (await rl.question(`${message} [${hint}]: `)).trim().toLowerCase();
+    if (!answer) {
+      return defaultValue;
+    }
+    if (answer === "y" || answer === "yes")
+      return true;
+    if (answer === "n" || answer === "no")
+      return false;
+    return defaultValue;
+  } finally {
+    rl.close();
+  }
+}
+
+// src/lib/tmux.ts
+function parseTmuxVersion(versionOutput) {
+  const match = versionOutput.match(/(\d+)\.(\d+)/);
+  if (!match)
+    return null;
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10)
+  };
+}
+function compareTmuxVersion(current, min) {
+  if (!current)
+    return true;
+  if (current.major !== min.major)
+    return current.major > min.major;
+  return current.minor >= min.minor;
+}
+async function checkTmuxVersion(minVersion = MIN_TMUX_VERSION) {
+  const result = await runCommand("tmux", ["-V"], {
+    stdio: "pipe",
+    timeoutMs: 5000
+  }).catch(() => null);
+  if (!result || result.code !== 0) {
+    return { ok: false, reason: "not-found" };
+  }
+  const raw = result.stdout.trim();
+  const version = parseTmuxVersion(raw);
+  if (!compareTmuxVersion(version, minVersion)) {
+    return {
+      ok: false,
+      version: version ?? undefined,
+      versionRaw: raw,
+      reason: "version-too-low"
+    };
+  }
+  return {
+    ok: true,
+    version: version ?? undefined,
+    versionRaw: raw
+  };
+}
+
+// src/lib/dep-install.ts
+var TMUX_INSTALL_COMMANDS = {
+  brew: { label: "Homebrew", command: "brew install tmux", requiresSudo: false, packageManager: "brew" },
+  apt: { label: "apt", command: "apt install -y tmux", requiresSudo: true, packageManager: "apt" },
+  dnf: { label: "dnf", command: "dnf install -y tmux", requiresSudo: true, packageManager: "dnf" },
+  pacman: { label: "pacman", command: "pacman -S --noconfirm tmux", requiresSudo: true, packageManager: "pacman" },
+  apk: { label: "apk", command: "apk add tmux", requiresSudo: true, packageManager: "apk" },
+  zypper: { label: "zypper", command: "zypper install -y tmux", requiresSudo: true, packageManager: "zypper" },
+  unknown: null
+};
+function planBunInstall() {
+  return [
+    {
+      label: "Official installer",
+      command: "curl -fsSL https://bun.sh/install | bash",
+      requiresSudo: false,
+      packageManager: "curl"
+    }
+  ];
+}
+async function planTmuxInstall(platform = process.platform) {
+  if (platform === "darwin") {
+    const brewAvailable = await isCommandAvailable("brew");
+    if (!brewAvailable)
+      return [];
+    return [TMUX_INSTALL_COMMANDS.brew];
+  }
+  if (platform === "linux") {
+    const distro = await detectLinuxDistro();
+    const pm = detectPackageManager(distro, platform);
+    const cmd = TMUX_INSTALL_COMMANDS[pm];
+    if (cmd)
+      return [cmd];
+    return [];
+  }
+  return [];
+}
+function getInstallHint(dep, platform = process.platform) {
+  if (dep === "bun") {
+    return "curl -fsSL https://bun.sh/install | bash";
+  }
+  if (platform === "darwin") {
+    return "brew install tmux";
+  }
+  return "apt/dnf/pacman/apk install tmux";
+}
+async function getInstallHintAsync(dep, platform = process.platform) {
+  if (dep === "bun") {
+    return "curl -fsSL https://bun.sh/install | bash";
+  }
+  if (platform === "darwin") {
+    return "brew install tmux";
+  }
+  if (platform === "linux") {
+    const distro = await detectLinuxDistro();
+    const pm = detectPackageManager(distro, platform);
+    const cmd = TMUX_INSTALL_COMMANDS[pm];
+    if (cmd) {
+      const prefix = cmd.requiresSudo ? "sudo " : "";
+      return `${prefix}${cmd.command}`;
+    }
+  }
+  return "apt/dnf/pacman/apk install tmux";
+}
+async function isCommandAvailable(command) {
+  const result = await runCommand(command, ["--version"], {
+    stdio: "pipe",
+    timeoutMs: 5000
+  }).catch(() => null);
+  return result !== null && result.code === 0;
+}
+function isRoot() {
+  return process.getuid?.() === 0;
+}
+async function isSudoAvailable() {
+  const result = await runCommand("sudo", ["-n", "true"], {
+    stdio: "pipe",
+    timeoutMs: 5000
+  }).catch(() => null);
+  return result !== null && result.code === 0;
+}
+function resolveCommand(cmd) {
+  if (!cmd.requiresSudo)
+    return cmd.command;
+  if (isRoot())
+    return cmd.command;
+  return `sudo ${cmd.command}`;
+}
+async function executeDependencyInstall(plan, options) {
+  if (plan.commands.length === 0) {
+    if (plan.dep === "tmux" && process.platform === "darwin") {
+      console.error(`[tmex] ${t("deps.install.brewMissing")}`);
+    } else {
+      console.error(`[tmex] ${t("deps.install.unknownDistro", { dep: plan.dep })}`);
+    }
+    console.error(`[tmex] ${t("deps.install.manual")}`);
+    return false;
+  }
+  const cmd = plan.commands[0];
+  const fullCommand = resolveCommand(cmd);
+  if (cmd.requiresSudo && !isRoot()) {
+    if (options.nonInteractive) {
+      const sudoOk = await isSudoAvailable();
+      if (!sudoOk) {
+        console.error(`[tmex] ${t("deps.install.sudoUnavailable")}`);
+        return false;
+      }
+    }
+  }
+  console.log(`[tmex] ${t("deps.install.hint", { command: fullCommand })}`);
+  if (!options.autoConfirm) {
+    if (options.nonInteractive) {
+      console.error(`[tmex] ${t("deps.install.nonInteractive", { dep: plan.dep })}`);
+      return false;
+    }
+    const confirmed = await promptConfirm({ nonInteractive: false }, t("deps.install.confirm", { dep: plan.dep }), true);
+    if (!confirmed)
+      return false;
+  }
+  console.log(`[tmex] ${t("deps.install.running", { dep: plan.dep })}`);
+  const parts = fullCommand.split(" ");
+  const bin = parts[0];
+  const args = parts.slice(1);
+  if (fullCommand.includes("|")) {
+    const result = await runCommand("sh", ["-c", fullCommand], { stdio: "inherit" }).catch(() => null);
+    if (!result || result.code !== 0) {
+      console.error(`[tmex] ${t("deps.install.failed", { dep: plan.dep })}`);
+      console.error(`[tmex] ${t("deps.install.manual")}`);
+      return false;
+    }
+  } else {
+    const result = await runCommand(bin, args, { stdio: "inherit" }).catch(() => null);
+    if (!result || result.code !== 0) {
+      console.error(`[tmex] ${t("deps.install.failed", { dep: plan.dep })}`);
+      console.error(`[tmex] ${t("deps.install.manual")}`);
+      return false;
+    }
+  }
+  if (plan.dep === "bun") {
+    const check = await checkBunVersion();
+    if (check.ok) {
+      console.log(`[tmex] ${t("deps.install.success", { dep: plan.dep })}`);
+      return true;
+    }
+  } else {
+    const check = await checkTmuxVersion();
+    if (check.ok) {
+      console.log(`[tmex] ${t("deps.install.success", { dep: plan.dep })}`);
+      return true;
+    }
+  }
+  console.error(`[tmex] ${t("deps.install.failed", { dep: plan.dep })}`);
+  console.error(`[tmex] ${t("deps.install.manual")}`);
+  return false;
+}
+
 // src/lib/env-file.ts
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile as readFile2, writeFile } from "node:fs/promises";
 function parseEnvContent(content) {
   const result = {};
   for (const rawLine of content.split(/\r?\n/)) {
@@ -598,7 +934,7 @@ function stringifyEnv(values) {
 `;
 }
 async function readEnvFile(filePath) {
-  const content = await readFile(filePath, "utf8");
+  const content = await readFile2(filePath, "utf8");
   return parseEnvContent(content);
 }
 async function writeEnvFile(filePath, values) {
@@ -607,7 +943,7 @@ async function writeEnvFile(filePath, values) {
 
 // src/lib/fs-utils.ts
 import { constants } from "node:fs";
-import { access, cp, mkdir, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { access, cp, mkdir, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname, resolve as resolve2 } from "node:path";
 async function pathExists(path) {
   try {
@@ -631,7 +967,7 @@ async function writeText(path, content, mode) {
   });
 }
 async function readText(path) {
-  return await readFile2(path, "utf8");
+  return await readFile3(path, "utf8");
 }
 function resolvePath(...parts) {
   return resolve2(...parts);
@@ -702,10 +1038,10 @@ function resolveInstallDir(input) {
 }
 
 // src/lib/json-file.ts
-import { readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
 import { dirname as dirname3 } from "node:path";
 async function readJsonFile(path) {
-  const content = await readFile3(path, "utf8");
+  const content = await readFile4(path, "utf8");
   return JSON.parse(content);
 }
 async function writeJsonFile(path, value, mode) {
@@ -715,11 +1051,18 @@ async function writeJsonFile(path, value, mode) {
 }
 
 // src/lib/platform.ts
-function detectServiceManager(platform = process.platform) {
-  if (platform === "linux")
-    return "systemd-user";
+async function detectServiceManager(platform = process.platform) {
   if (platform === "darwin")
     return "launchd";
+  if (platform === "linux") {
+    const result = await runCommand("systemctl", ["--version"], {
+      stdio: "pipe",
+      timeoutMs: 5000
+    }).catch(() => null);
+    if (result && result.code === 0)
+      return "systemd-user";
+    return "none";
+  }
   return "none";
 }
 function isSupportedPlatform(platform = process.platform) {
@@ -853,7 +1196,7 @@ async function installLaunchdService(options) {
   }
 }
 async function installService(options) {
-  const manager = detectServiceManager();
+  const manager = await detectServiceManager();
   if (manager === "systemd-user") {
     await installSystemdService(options);
     return;
@@ -868,7 +1211,7 @@ async function stopSystemd(serviceName) {
   await runCommand("systemctl", ["--user", "stop", serviceName]).catch(() => null);
 }
 async function stopService(serviceName, installDir) {
-  const manager = detectServiceManager();
+  const manager = await detectServiceManager();
   if (manager === "systemd-user") {
     await stopSystemd(serviceName);
     return;
@@ -892,7 +1235,7 @@ async function uninstallSystemdService(serviceName) {
   await runCommand("systemctl", ["--user", "daemon-reload"]).catch(() => null);
 }
 async function uninstallService(options) {
-  const manager = detectServiceManager();
+  const manager = await detectServiceManager();
   if (manager === "systemd-user") {
     await uninstallSystemdService(options.serviceName);
     return;
@@ -941,7 +1284,7 @@ async function queryLaunchdStatus(serviceName, installDir) {
   };
 }
 async function getServiceStatus(serviceName, installDir) {
-  const manager = detectServiceManager();
+  const manager = await detectServiceManager();
   if (manager === "systemd-user") {
     return await querySystemdStatus(serviceName);
   }
@@ -956,8 +1299,8 @@ async function getServiceStatus(serviceName, installDir) {
     detail: t("service.status.none", { platform: process.platform })
   };
 }
-function serviceHint(serviceName) {
-  const manager = detectServiceManager();
+async function serviceHint(serviceName) {
+  const manager = await detectServiceManager();
   if (manager === "systemd-user") {
     return t("service.hint.systemd", { serviceName });
   }
@@ -968,13 +1311,6 @@ function serviceHint(serviceName) {
 }
 
 // src/commands/doctor.ts
-async function checkCommandExists(bin, args, id, okMessage, failMessage) {
-  const result = await runCommand(bin, args, { stdio: "pipe" }).catch(() => null);
-  if (result?.code === 0) {
-    return { id, level: "pass", message: okMessage, detail: result.stdout.trim() };
-  }
-  return { id, level: "fail", message: failMessage, detail: result?.stderr || result?.stdout };
-}
 function printChecks(checks, json) {
   if (json) {
     console.log(JSON.stringify({ checks }, null, 2));
@@ -986,10 +1322,14 @@ function printChecks(checks, json) {
     if (check.detail) {
       console.log(`  ${check.detail.trim()}`);
     }
+    if (check.hint && check.level !== "pass") {
+      console.log(`  ${t("deps.install.hint", { command: check.hint })}`);
+    }
   }
 }
 async function runDoctor(parsed) {
   const json = asBoolean(parsed.flags.json) ?? false;
+  const fix = asBoolean(parsed.flags.fix) ?? false;
   const installDirFlag = asString(parsed.flags["install-dir"]);
   const installDir = resolveInstallDir(installDirFlag || defaultInstallDir(process.platform));
   const installLayout = createInstallLayout(installDir);
@@ -1025,10 +1365,36 @@ async function runDoctor(parsed) {
       id: "bun",
       level: "fail",
       message: t("doctor.bun.fail", { reason: bun.reason || t("bun.checkFailed") }),
-      detail: bun.path
+      detail: bun.path,
+      hint: await getInstallHintAsync("bun"),
+      fixable: true
+    });
+  }
+  const tmux = await checkTmuxVersion();
+  if (tmux.ok) {
+    checks.push({
+      id: "tmux",
+      level: "pass",
+      message: t("doctor.tmux.ok", { version: tmux.versionRaw || "unknown" }),
+      detail: tmux.versionRaw
+    });
+  } else if (tmux.reason === "version-too-low") {
+    checks.push({
+      id: "tmux",
+      level: "fail",
+      message: t("doctor.tmux.versionLow", { version: tmux.versionRaw || "" }),
+      hint: await getInstallHintAsync("tmux"),
+      fixable: true
+    });
+  } else {
+    checks.push({
+      id: "tmux",
+      level: "fail",
+      message: t("doctor.tmux.fail"),
+      hint: await getInstallHintAsync("tmux"),
+      fixable: true
     });
   }
-  checks.push(await checkCommandExists("tmux", ["-V"], "tmux", t("doctor.tmux.ok"), t("doctor.tmux.fail")));
   const ssh = await runCommand("ssh", ["-V"], { stdio: "pipe" }).catch(() => null);
   if (ssh?.code === 0) {
     checks.push({
@@ -1166,6 +1532,38 @@ async function runDoctor(parsed) {
     });
   }
   printChecks(checks, json);
+  const fixableFailures = checks.filter((c) => c.level === "fail" && c.fixable);
+  if (fix && fixableFailures.length > 0) {
+    console.log(`
+[tmex] ${t("doctor.fix.header")}`);
+    for (const check of fixableFailures) {
+      const dep = check.id;
+      if (dep !== "bun" && dep !== "tmux") {
+        console.log(`[tmex] ${t("doctor.fix.skip", { id: check.id })}`);
+        continue;
+      }
+      const commands = dep === "bun" ? planBunInstall() : await planTmuxInstall();
+      const plan = {
+        dep,
+        commands,
+        requiredVersion: dep === "tmux" ? ">= 3.0" : ">= 1.3.0",
+        issue: check.id === "tmux" && check.message.includes("version") ? "version-too-low" : "missing"
+      };
+      const nonInteractive = asBoolean(parsed.flags["no-interactive"]) ?? false;
+      await executeDependencyInstall(plan, {
+        nonInteractive,
+        autoConfirm: nonInteractive
+      });
+    }
+    console.log("");
+    const rerunParsed = { ...parsed, flags: { ...parsed.flags, fix: false } };
+    await runDoctor(rerunParsed);
+    return;
+  }
+  if (!fix && fixableFailures.length > 0 && !json) {
+    console.log(`
+[tmex] ${t("doctor.fix.hint")}`);
+  }
   const failed = checks.some((check) => check.level === "fail");
   if (failed) {
     process.exitCode = 1;
@@ -1298,43 +1696,6 @@ async function restoreInstallArtifacts(installLayout, backupDir) {
   }
 }
 
-// src/lib/prompt.ts
-import { stdin, stdout } from "node:process";
-import { createInterface } from "node:readline/promises";
-async function promptText(ctx, message, defaultValue) {
-  if (ctx.nonInteractive) {
-    return defaultValue ?? "";
-  }
-  const rl = createInterface({ input: stdin, output: stdout });
-  try {
-    const suffix = defaultValue !== undefined ? ` (${defaultValue})` : "";
-    const answer = (await rl.question(`${message}${suffix}: `)).trim();
-    return answer || defaultValue || "";
-  } finally {
-    rl.close();
-  }
-}
-async function promptConfirm(ctx, message, defaultValue) {
-  if (ctx.nonInteractive) {
-    return defaultValue;
-  }
-  const rl = createInterface({ input: stdin, output: stdout });
-  try {
-    const hint = defaultValue ? "Y/n" : "y/N";
-    const answer = (await rl.question(`${message} [${hint}]: `)).trim().toLowerCase();
-    if (!answer) {
-      return defaultValue;
-    }
-    if (answer === "y" || answer === "yes")
-      return true;
-    if (answer === "n" || answer === "no")
-      return false;
-    return defaultValue;
-  } finally {
-    rl.close();
-  }
-}
-
 // src/lib/version.ts
 import { join as join5 } from "node:path";
 async function readPackageVersion(packageRoot) {
@@ -1367,6 +1728,8 @@ async function directoryHasContent(path) {
 async function buildInitConfig(parsed) {
   const nonInteractive = parsed.flags["no-interactive"] === true;
   const force = asBoolean(parsed.flags.force) ?? false;
+  const installDeps = asBoolean(parsed.flags["install-deps"]) ?? false;
+  const skipDepCheck = asBoolean(parsed.flags["skip-dep-check"]) ?? false;
   if (nonInteractive) {
     const installDir2 = resolveInstallDir(assertNonEmpty(mustGetStringFlag(parsed.flags, "install-dir"), "install-dir"));
     const host2 = assertNonEmpty(mustGetStringFlag(parsed.flags, "host"), "host");
@@ -1382,7 +1745,9 @@ async function buildInitConfig(parsed) {
       autostart: autostart2,
       serviceName: serviceName2,
       force,
-      nonInteractive
+      nonInteractive,
+      installDeps,
+      skipDepCheck
     };
   }
   const fallbackInstallDir = defaultInstallDir(process.platform);
@@ -1405,15 +1770,59 @@ async function buildInitConfig(parsed) {
     autostart,
     serviceName,
     force,
-    nonInteractive
+    nonInteractive,
+    installDeps,
+    skipDepCheck
   };
 }
+async function handleDepFailure(dep, config, errorMessage) {
+  const hint = await getInstallHintAsync(dep);
+  const commands = dep === "bun" ? planBunInstall() : await planTmuxInstall();
+  const plan = {
+    dep,
+    commands,
+    requiredVersion: dep === "tmux" ? ">= 3.0" : ">= 1.3.0",
+    issue: "missing"
+  };
+  if (config.installDeps || !config.nonInteractive) {
+    const installed = await executeDependencyInstall(plan, {
+      nonInteractive: config.nonInteractive,
+      autoConfirm: config.installDeps && config.nonInteractive
+    });
+    if (installed)
+      return;
+    throw new Error(errorMessage);
+  }
+  throw new Error(`${errorMessage}
+${t("deps.install.hint", { command: hint })}`);
+}
 async function runInit(parsed) {
+  const manager = await detectServiceManager();
+  if (manager === "none") {
+    throw new Error(t("init.error.noServiceManager", { platform: process.platform }));
+  }
   const config = await buildInitConfig(parsed);
+  if (!config.skipDepCheck) {
+    const tmux = await checkTmuxVersion();
+    if (!tmux.ok) {
+      const reason = tmux.reason === "version-too-low" ? t("tmux.versionTooLow", { version: tmux.versionRaw || "" }) : t("tmux.notFound");
+      await handleDepFailure("tmux", config, reason);
+    }
+  }
   const explicitBunPath = readExplicitBunPath(parsed.flags);
   const bun = await checkBunVersion(undefined, { explicitPath: explicitBunPath });
   if (!bun.ok || !bun.path) {
-    throw new Error(bun.reason || t("bun.checkFailed"));
+    const reason = bun.reason || t("bun.checkFailed");
+    if (!config.skipDepCheck) {
+      await handleDepFailure("bun", config, reason);
+      const bunRetry = await checkBunVersion(undefined, { explicitPath: explicitBunPath });
+      if (!bunRetry.ok || !bunRetry.path) {
+        throw new Error(bunRetry.reason || t("bun.checkFailed"));
+      }
+      Object.assign(bun, bunRetry);
+    } else {
+      throw new Error(reason);
+    }
   }
   if (!config.force && await directoryHasContent(config.installDir)) {
     if (config.nonInteractive) {
@@ -1438,17 +1847,12 @@ async function runInit(parsed) {
   });
   await writeEnvFile(installLayout.envPath, envValues);
   await writeRunScript(installLayout, bun.path);
-  const manager = detectServiceManager();
-  if (manager === "none") {
-    console.warn(`[tmex] ${t("init.warning.noServiceManager", { platform: process.platform })}`);
-  } else {
-    await installService({
-      serviceName: config.serviceName,
-      installDir: config.installDir,
-      runScriptPath: installLayout.runScriptPath,
-      autostart: config.autostart
-    });
-  }
+  await installService({
+    serviceName: config.serviceName,
+    installDir: config.installDir,
+    runScriptPath: installLayout.runScriptPath,
+    autostart: config.autostart
+  });
   const cliVersion = await readPackageVersion(packageLayout.packageRoot);
   const meta = {
     serviceName: config.serviceName,
@@ -1465,9 +1869,7 @@ async function runInit(parsed) {
   console.log(`- ${t("init.summary.serviceName")}: ${config.serviceName}`);
   console.log(`- ${t("init.summary.bun")}: ${bun.version} (${bun.path})`);
   console.log(`- ${t("init.summary.autostart")}: ${config.autostart ? t("init.summary.autostart.on") : t("init.summary.autostart.off")}`);
-  if (manager !== "none") {
-    console.log(`- ${t("init.summary.serviceHint")}: ${serviceHint(config.serviceName)}`);
-  }
+  console.log(`- ${t("init.summary.serviceHint")}: ${await serviceHint(config.serviceName)}`);
 }
 
 // src/commands/uninstall.ts
@@ -1592,7 +1994,10 @@ async function runUpgrade(parsed) {
     metaBunPath: meta.bunPath
   });
   if (!bun.ok || !bun.path) {
-    throw new Error(bun.reason || t("bun.checkFailed"));
+    const hint = getInstallHint("bun");
+    const reason = bun.reason || t("bun.checkFailed");
+    throw new Error(`${reason}
+${t("deps.install.hint", { command: hint })}`);
   }
   const packageLayout = await resolvePackageLayout(import.meta.url);
   const backupDir = await mkdtemp(join6(tmpdir(), "tmex-upgrade-"));