tmex-cli 0.1.4

package/dist/cli-node.js

@@ -0,0 +1,1512 @@
+// src/commands/doctor.ts
+import { stat } from "node:fs/promises";
+import { resolve as resolve4 } from "node:path";
+
+// src/constants.ts
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+var MIN_BUN_VERSION = "1.3.0";
+var DEFAULT_SERVICE_NAME = "tmex";
+function defaultInstallDir(platform) {
+  if (platform === "darwin") {
+    return resolve(homedir(), "Library", "Application Support", "tmex");
+  }
+  return resolve(homedir(), ".local", "share", "tmex");
+}
+function defaultDatabasePath(installDir) {
+  return resolve(installDir, "data", "tmex.db");
+}
+function defaultHost() {
+  return "127.0.0.1";
+}
+function defaultPort() {
+  return 9883;
+}
+
+// src/i18n/index.ts
+var MESSAGES = {
+  en: {
+    "cli.help": `tmex CLI
+
+Usage:
+  tmex init [--no-interactive --install-dir <path> --host <host> --port <port> --db-path <path> --autostart <true|false>]
+  tmex doctor [--install-dir <path>] [--json]
+  tmex upgrade [--version <version>] [--install-dir <path>]
+  tmex uninstall [--install-dir <path>] [--yes] [--purge]
+
+Global flags:
+  --lang <en|zh-CN>`,
+    "cli.error.unknownCommand": "Unknown command: {{command}}",
+    "common.cancelled": "Cancelled by user.",
+    "common.done": "Done.",
+    "errors.args.missingFlag": "Missing required flag: --{{flag}}",
+    "errors.args.invalidFlag": "Invalid flag value: --{{flag}}={{value}}",
+    "errors.validate.invalidPort": "Invalid port: {{value}}",
+    "errors.validate.emptyField": "{{field}} cannot be empty.",
+    "errors.version.invalid": "Invalid version: {{input}}",
+    "errors.layout.packageRootNotFound": "Unable to locate tmex package root. Please ensure dist artifacts are complete.",
+    "errors.layout.runtimeMissing": "Runtime artifact not found: {{path}}",
+    "errors.layout.feMissing": "Frontend static assets not found: {{path}}",
+    "errors.layout.drizzleMissing": "Gateway migration assets not found: {{path}}",
+    "bun.notFound": "Bun not found. Please install Bun and ensure it is available in PATH.",
+    "bun.versionExecFailed": "Failed to execute bun --version. Please verify Bun installation.",
+    "bun.versionTooLow": "Bun version too low: current {{version}}, required >= {{minVersion}}",
+    "bun.checkFailed": "Bun check failed.",
+    "service.install.unsupportedPlatform": "Automatic service installation is not supported on this platform: {{platform}}",
+    "service.systemd.daemonReloadFailed": "systemctl daemon-reload failed: {{detail}}",
+    "service.systemd.enableFailed": "systemctl enable failed: {{detail}}",
+    "service.systemd.restartFailed": "systemctl restart failed: {{detail}}",
+    "service.systemd.startFailed": "systemctl start failed: {{detail}}",
+    "service.systemd.startRuntimeFailed": "systemctl start failed: {{detail}}",
+    "service.launchd.bootstrapFailed": "launchctl bootstrap failed: {{detail}}",
+    "service.status.none": "Service manager is not integrated for platform: {{platform}}",
+    "service.status.plistMissing": "launchd plist not found",
+    "service.hint.systemd": "systemctl --user status {{serviceName}}",
+    "service.hint.launchd": "launchctl print gui/$(id -u)/com.tmex.{{serviceName}}",
+    "service.hint.none": "No service manager command on this platform.",
+    "init.prompt.installDir": "Install directory (install-dir)",
+    "init.prompt.host": "Bind host",
+    "init.prompt.port": "Bind port",
+    "init.prompt.dbPath": "Database path (db-path)",
+    "init.prompt.autostart": "Enable autostart",
+    "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.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",
+    "init.summary.serviceName": "Service name",
+    "init.summary.bun": "Bun",
+    "init.summary.autostart": "Autostart",
+    "init.summary.autostart.on": "on",
+    "init.summary.autostart.off": "off",
+    "init.summary.serviceHint": "Service status command",
+    "doctor.platform.supported": "Platform: {{platform}}",
+    "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.ssh.ok": "ssh installed",
+    "doctor.ssh.missing": "ssh not found; SSH devices will not work.",
+    "doctor.installDir.exists": "Install directory exists: {{installDir}}",
+    "doctor.installDir.missing": "Install directory not found: {{installDir}}",
+    "doctor.env.exists": "Config file found: {{envPath}}",
+    "doctor.env.missing": "Config file not found: {{envPath}}",
+    "doctor.env.keyMissing": "Missing config key: {{key}}",
+    "doctor.db.missing": "Database file not found (may be normal before first start): {{path}}",
+    "doctor.db.exists": "Database file exists: {{path}}",
+    "doctor.port.invalid": "Invalid port in config: {{value}}",
+    "doctor.service.notInstalled": "Service not installed: {{serviceName}}",
+    "doctor.service.notRunning": "Service not running: {{serviceName}}",
+    "doctor.service.running": "Service running: {{serviceName}}",
+    "doctor.service.noManager": "{{detail}}",
+    "doctor.health.pass": "Health check OK: {{url}}",
+    "doctor.health.fail": "Health check failed or unreachable: {{url}}",
+    "upgrade.delegateFailed": "Upgrade delegation failed with exit code {{code}}",
+    "upgrade.missingMeta": "Install metadata not found: {{path}}. Please run init first.",
+    "upgrade.healthFailed": "Health check failed: HTTP {{status}}",
+    "upgrade.done": "Upgrade completed.",
+    "upgrade.failedRollingBack": "Upgrade failed; rolling back.",
+    "upgrade.summary.targetVersion": "Target version",
+    "upgrade.summary.installDir": "Install dir",
+    "uninstall.prompt.removeService": "Uninstall system service",
+    "uninstall.prompt.removeProgram": "Remove program files (runtime/resources/run.sh/meta)",
+    "uninstall.prompt.removeEnv": "Remove app.env",
+    "uninstall.prompt.removeDatabase": "Remove database file",
+    "uninstall.done": "Uninstall completed.",
+    "uninstall.summary.installDir": "Install dir",
+    "uninstall.summary.serviceName": "Service name",
+    "runtime.restartRequested": "Restart requested; exiting for service manager restart.",
+    "runtime.started": "Service started on {{url}}",
+    "runtime.frontendMissing": "Frontend assets not found.",
+    "runtime.methodNotAllowed": "Method Not Allowed",
+    "runtime.forbidden": "Forbidden"
+  },
+  "zh-CN": {
+    "cli.help": `tmex CLI
+
+用法：
+  tmex init [--no-interactive --install-dir <path> --host <host> --port <port> --db-path <path> --autostart <true|false>]
+  tmex doctor [--install-dir <path>] [--json]
+  tmex upgrade [--version <version>] [--install-dir <path>]
+  tmex uninstall [--install-dir <path>] [--yes] [--purge]
+
+全局参数：
+  --lang <en|zh-CN>`,
+    "cli.error.unknownCommand": "未知命令：{{command}}",
+    "common.cancelled": "已取消。",
+    "common.done": "完成。",
+    "errors.args.missingFlag": "缺少必要参数：--{{flag}}",
+    "errors.args.invalidFlag": "参数值非法：--{{flag}}={{value}}",
+    "errors.validate.invalidPort": "非法端口：{{value}}",
+    "errors.validate.emptyField": "{{field}} 不能为空。",
+    "errors.version.invalid": "非法版本号：{{input}}",
+    "errors.layout.packageRootNotFound": "无法定位 tmex 包根目录，请确认 dist 产物完整。",
+    "errors.layout.runtimeMissing": "未找到 runtime 产物：{{path}}",
+    "errors.layout.feMissing": "未找到前端静态资源：{{path}}",
+    "errors.layout.drizzleMissing": "未找到网关迁移资源：{{path}}",
+    "bun.notFound": "未检测到 Bun，请先安装 Bun 并确保在 PATH 中可用。",
+    "bun.versionExecFailed": "无法执行 bun --version，请检查 Bun 安装是否完整。",
+    "bun.versionTooLow": "Bun 版本过低：当前 {{version}}，要求 >= {{minVersion}}",
+    "bun.checkFailed": "Bun 检查失败。",
+    "service.install.unsupportedPlatform": "当前平台不支持自动安装服务：{{platform}}",
+    "service.systemd.daemonReloadFailed": "systemctl daemon-reload 失败：{{detail}}",
+    "service.systemd.enableFailed": "systemctl enable 失败：{{detail}}",
+    "service.systemd.restartFailed": "systemctl restart 失败：{{detail}}",
+    "service.systemd.startFailed": "systemctl start 失败：{{detail}}",
+    "service.systemd.startRuntimeFailed": "systemctl 启动失败：{{detail}}",
+    "service.launchd.bootstrapFailed": "launchctl bootstrap 失败：{{detail}}",
+    "service.status.none": "当前平台未集成服务管理：{{platform}}",
+    "service.status.plistMissing": "plist 不存在",
+    "service.hint.systemd": "systemctl --user status {{serviceName}}",
+    "service.hint.launchd": "launchctl print gui/$(id -u)/com.tmex.{{serviceName}}",
+    "service.hint.none": "当前平台无服务管理命令",
+    "init.prompt.installDir": "安装目录（install-dir）",
+    "init.prompt.host": "监听 host",
+    "init.prompt.port": "监听端口",
+    "init.prompt.dbPath": "数据库路径（db-path）",
+    "init.prompt.autostart": "是否启用开机启动",
+    "init.prompt.serviceName": "服务名称（service-name）",
+    "init.prompt.dirExistsConfirm": "目录 {{installDir}} 已存在，是否继续（不会删除现有配置与数据库）？",
+    "init.error.installDirNotEmpty": "安装目录已存在且非空：{{installDir}}。如需覆盖请加 --force",
+    "init.warning.noServiceManager": "当前平台 {{platform}} 未实现自动服务安装，已完成文件部署。",
+    "init.done": "初始化完成。",
+    "init.summary.installDir": "安装目录",
+    "init.summary.serviceName": "服务名称",
+    "init.summary.bun": "Bun",
+    "init.summary.autostart": "自启动",
+    "init.summary.autostart.on": "开启",
+    "init.summary.autostart.off": "关闭",
+    "init.summary.serviceHint": "服务状态命令",
+    "doctor.platform.supported": "平台：{{platform}}",
+    "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.ssh.ok": "ssh 已安装",
+    "doctor.ssh.missing": "未检测到 ssh，远程设备将不可用。",
+    "doctor.installDir.exists": "安装目录存在：{{installDir}}",
+    "doctor.installDir.missing": "未发现安装目录：{{installDir}}",
+    "doctor.env.exists": "发现配置文件：{{envPath}}",
+    "doctor.env.missing": "未发现配置文件：{{envPath}}",
+    "doctor.env.keyMissing": "配置缺失：{{key}}",
+    "doctor.db.missing": "数据库文件不存在（首次启动前可能正常）：{{path}}",
+    "doctor.db.exists": "数据库文件存在：{{path}}",
+    "doctor.port.invalid": "配置端口非法：{{value}}",
+    "doctor.service.notInstalled": "服务未安装：{{serviceName}}",
+    "doctor.service.notRunning": "服务未运行：{{serviceName}}",
+    "doctor.service.running": "服务运行中：{{serviceName}}",
+    "doctor.service.noManager": "{{detail}}",
+    "doctor.health.pass": "健康检查通过：{{url}}",
+    "doctor.health.fail": "健康检查失败或不可达：{{url}}",
+    "upgrade.delegateFailed": "委托升级失败，退出码 {{code}}",
+    "upgrade.missingMeta": "未找到安装元数据：{{path}}，请先执行 init",
+    "upgrade.healthFailed": "健康检查失败：HTTP {{status}}",
+    "upgrade.done": "升级完成。",
+    "upgrade.failedRollingBack": "升级失败，开始回滚。",
+    "upgrade.summary.targetVersion": "目标版本",
+    "upgrade.summary.installDir": "安装目录",
+    "uninstall.prompt.removeService": "是否卸载系统服务",
+    "uninstall.prompt.removeProgram": "是否删除程序文件（runtime/resources/run.sh/meta）",
+    "uninstall.prompt.removeEnv": "是否删除 app.env",
+    "uninstall.prompt.removeDatabase": "是否删除数据库文件",
+    "uninstall.done": "卸载完成。",
+    "uninstall.summary.installDir": "安装目录",
+    "uninstall.summary.serviceName": "服务名称",
+    "runtime.restartRequested": "收到重启请求，退出并等待服务管理器拉起。",
+    "runtime.started": "服务已启动：{{url}}",
+    "runtime.frontendMissing": "未找到前端静态资源。",
+    "runtime.methodNotAllowed": "方法不允许",
+    "runtime.forbidden": "禁止访问"
+  }
+};
+var currentLang = "en";
+function normalizeLang(input) {
+  if (!input)
+    return "en";
+  const raw = input.trim();
+  if (!raw)
+    return "en";
+  const lower = raw.toLowerCase();
+  if (lower === "en" || lower === "en-us" || lower === "en_us")
+    return "en";
+  if (lower === "zh" || lower === "zh-cn" || lower === "zh_cn" || lower === "cn")
+    return "zh-CN";
+  return "en";
+}
+function setLang(lang) {
+  currentLang = lang;
+}
+function interpolate(template, vars) {
+  if (!vars)
+    return template;
+  return template.replaceAll(/\{\{(\w+)\}\}/g, (_, key) => {
+    const value = vars[key];
+    return value === undefined ? "" : String(value);
+  });
+}
+function t(key, vars) {
+  const table = MESSAGES[currentLang] ?? MESSAGES.en;
+  const fallback = MESSAGES.en[key];
+  const template = table[key] ?? fallback ?? key;
+  return interpolate(template, vars);
+}
+
+// src/lib/bun.ts
+import { existsSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join } from "node:path";
+
+// src/lib/process.ts
+import { spawn } from "node:child_process";
+async function runCommand(command, args, options = {}) {
+  const stdio = options.stdio ?? "pipe";
+  return await new Promise((resolve2, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio
+    });
+    let stdout = "";
+    let stderr = "";
+    if (stdio === "pipe") {
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+    }
+    child.on("error", reject);
+    child.on("close", (code) => {
+      resolve2({
+        code: code ?? 1,
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+
+// src/lib/semver.ts
+function parseSemver(input) {
+  const match = input.trim().match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) {
+    throw new Error(t("errors.version.invalid", { input }));
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3])
+  };
+}
+function compareSemver(left, right) {
+  const a = parseSemver(left);
+  const b = parseSemver(right);
+  if (a.major !== b.major)
+    return a.major > b.major ? 1 : -1;
+  if (a.minor !== b.minor)
+    return a.minor > b.minor ? 1 : -1;
+  if (a.patch !== b.patch)
+    return a.patch > b.patch ? 1 : -1;
+  return 0;
+}
+
+// src/lib/bun.ts
+async function locateBunFromShell() {
+  const result = await runCommand("zsh", ["-lic", "command -v bun"], { stdio: "pipe" }).catch(() => null);
+  if (!result || result.code !== 0) {
+    return null;
+  }
+  const bin = result.stdout.trim();
+  if (!bin) {
+    return null;
+  }
+  return bin;
+}
+async function findBunBinary() {
+  const zshBin = await locateBunFromShell();
+  if (zshBin) {
+    return zshBin;
+  }
+  const fallback = join(homedir2(), ".bun", "bin", "bun");
+  if (existsSync(fallback)) {
+    return fallback;
+  }
+  const direct = await runCommand("bun", ["--version"], { stdio: "pipe" }).catch(() => null);
+  if (direct?.code === 0) {
+    return "bun";
+  }
+  return null;
+}
+async function checkBunVersion(minVersion = MIN_BUN_VERSION) {
+  const bunPath = await findBunBinary();
+  if (!bunPath) {
+    return {
+      ok: false,
+      reason: t("bun.notFound")
+    };
+  }
+  const versionResult = await runCommand(bunPath, ["--version"], { stdio: "pipe" }).catch(() => null);
+  if (!versionResult || versionResult.code !== 0) {
+    return {
+      ok: false,
+      reason: t("bun.versionExecFailed"),
+      path: bunPath
+    };
+  }
+  const version = versionResult.stdout.trim();
+  if (compareSemver(version, minVersion) < 0) {
+    return {
+      ok: false,
+      path: bunPath,
+      version,
+      reason: t("bun.versionTooLow", { version, minVersion })
+    };
+  }
+  return {
+    ok: true,
+    path: bunPath,
+    version
+  };
+}
+
+// src/lib/env-file.ts
+import { readFile, writeFile } from "node:fs/promises";
+function parseEnvContent(content) {
+  const result = {};
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const eqIndex = line.indexOf("=");
+    if (eqIndex <= 0)
+      continue;
+    const key = line.slice(0, eqIndex).trim();
+    const value = line.slice(eqIndex + 1).trim();
+    result[key] = value;
+  }
+  return result;
+}
+function stringifyEnv(values) {
+  const lines = Object.keys(values).sort((left, right) => left.localeCompare(right)).map((key) => `${key}=${values[key]}`);
+  return `${lines.join(`
+`)}
+`;
+}
+async function readEnvFile(filePath) {
+  const content = await readFile(filePath, "utf8");
+  return parseEnvContent(content);
+}
+async function writeEnvFile(filePath, values) {
+  await writeFile(filePath, stringifyEnv(values), { encoding: "utf8", mode: 384 });
+}
+
+// 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 { dirname, resolve as resolve2 } from "node:path";
+async function pathExists(path) {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(path) {
+  await mkdir(path, { recursive: true });
+}
+async function copyDirectory(from, to) {
+  await cp(from, to, { recursive: true, force: true });
+}
+async function writeText(path, content, mode) {
+  await ensureDir(dirname(path));
+  await writeFile2(path, content, {
+    encoding: "utf8",
+    mode
+  });
+}
+async function readText(path) {
+  return await readFile2(path, "utf8");
+}
+function resolvePath(...parts) {
+  return resolve2(...parts);
+}
+
+// src/lib/install-layout.ts
+import { dirname as dirname2, join as join2, resolve as resolve3 } from "node:path";
+import { fileURLToPath } from "node:url";
+function createInstallLayout(installDir) {
+  return {
+    installDir,
+    runtimeDir: join2(installDir, "runtime"),
+    runtimeServerPath: join2(installDir, "runtime", "server.js"),
+    resourcesDir: join2(installDir, "resources"),
+    feDir: join2(installDir, "resources", "fe-dist"),
+    drizzleDir: join2(installDir, "resources", "gateway-drizzle"),
+    envPath: join2(installDir, "app.env"),
+    runScriptPath: join2(installDir, "run.sh"),
+    metaPath: join2(installDir, "install-meta.json")
+  };
+}
+async function locatePackageRoot(startDir) {
+  let current = startDir;
+  while (true) {
+    const packageJsonPath = join2(current, "package.json");
+    if (await pathExists(packageJsonPath)) {
+      const parsed = await readText(packageJsonPath).then((content) => JSON.parse(content)).catch(() => null);
+      if (parsed) {
+        const name = typeof parsed.name === "string" ? parsed.name : "";
+        const bin = typeof parsed.bin === "object" && parsed.bin !== null ? parsed.bin : null;
+        const hasTmexBin = bin !== null && typeof bin.tmex === "string";
+        const hasTmexCliBin = bin !== null && typeof bin["tmex-cli"] === "string";
+        if ((name === "tmex-cli" || name === "tmex") && (hasTmexBin || hasTmexCliBin)) {
+          return current;
+        }
+      }
+    }
+    const parent = dirname2(current);
+    if (parent === current) {
+      throw new Error(t("errors.layout.packageRootNotFound"));
+    }
+    current = parent;
+  }
+}
+async function resolvePackageLayout(fromModuleUrl) {
+  const currentDir = dirname2(fileURLToPath(fromModuleUrl));
+  const packageRoot = await locatePackageRoot(currentDir);
+  const layout = {
+    packageRoot,
+    cliDistPath: join2(packageRoot, "dist", "cli-node.js"),
+    runtimeDirPath: join2(packageRoot, "dist", "runtime"),
+    resourceFePath: join2(packageRoot, "resources", "fe-dist"),
+    resourceDrizzlePath: join2(packageRoot, "resources", "gateway-drizzle")
+  };
+  if (!await pathExists(join2(layout.runtimeDirPath, "server.js"))) {
+    throw new Error(t("errors.layout.runtimeMissing", { path: join2(layout.runtimeDirPath, "server.js") }));
+  }
+  if (!await pathExists(layout.resourceFePath)) {
+    throw new Error(t("errors.layout.feMissing", { path: layout.resourceFePath }));
+  }
+  if (!await pathExists(layout.resourceDrizzlePath)) {
+    throw new Error(t("errors.layout.drizzleMissing", { path: layout.resourceDrizzlePath }));
+  }
+  return layout;
+}
+function resolveInstallDir(input) {
+  return resolve3(input);
+}
+
+// src/lib/json-file.ts
+import { readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+async function readJsonFile(path) {
+  const content = await readFile3(path, "utf8");
+  return JSON.parse(content);
+}
+async function writeJsonFile(path, value, mode) {
+  await ensureDir(dirname3(path));
+  await writeFile3(path, `${JSON.stringify(value, null, 2)}
+`, { encoding: "utf8", mode });
+}
+
+// src/lib/platform.ts
+function detectServiceManager(platform = process.platform) {
+  if (platform === "linux")
+    return "systemd-user";
+  if (platform === "darwin")
+    return "launchd";
+  return "none";
+}
+function isSupportedPlatform(platform = process.platform) {
+  return platform === "linux" || platform === "darwin";
+}
+
+// src/lib/service.ts
+import { rm } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+function systemdUnitPath(serviceName) {
+  return join3(homedir3(), ".config", "systemd", "user", `${serviceName}.service`);
+}
+function launchdLabel(serviceName) {
+  return `com.tmex.${serviceName}`;
+}
+function launchdLaunchAgentsPlistPath(serviceName) {
+  return join3(homedir3(), "Library", "LaunchAgents", `${launchdLabel(serviceName)}.plist`);
+}
+function launchdLocalPlistPath(serviceName, installDir) {
+  return join3(installDir, `${launchdLabel(serviceName)}.plist`);
+}
+function buildSystemdServiceContent({
+  serviceName,
+  runScriptPath,
+  installDir
+}) {
+  const escapedInstallDir = installDir.replaceAll("\\", "\\\\");
+  const escapedRunScriptPath = runScriptPath.replaceAll("\\", "\\\\").replaceAll('"', "\\\"");
+  return `[Unit]
+Description=tmex (${serviceName})
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory=${escapedInstallDir}
+SyslogIdentifier=tmex
+StandardOutput=journal
+StandardError=journal
+ExecStart=/usr/bin/env bash "${escapedRunScriptPath}"
+Restart=always
+RestartSec=3
+TimeoutStopSec=20
+
+[Install]
+WantedBy=default.target
+`;
+}
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function buildLaunchdPlist({
+  serviceName,
+  runScriptPath,
+  installDir
+}) {
+  const label = launchdLabel(serviceName);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${escapeXml(label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/bash</string>
+    <string>${escapeXml(runScriptPath)}</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(installDir)}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(join3(installDir, "tmex.log"))}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(join3(installDir, "tmex.err.log"))}</string>
+</dict>
+</plist>
+`;
+}
+async function installSystemdService(options) {
+  const unitPath = systemdUnitPath(options.serviceName);
+  await ensureDir(join3(homedir3(), ".config", "systemd", "user"));
+  await writeText(unitPath, buildSystemdServiceContent(options));
+  const daemonReload = await runCommand("systemctl", ["--user", "daemon-reload"]);
+  if (daemonReload.code !== 0) {
+    throw new Error(t("service.systemd.daemonReloadFailed", {
+      detail: daemonReload.stderr || daemonReload.stdout
+    }));
+  }
+  if (options.autostart) {
+    const enable = await runCommand("systemctl", ["--user", "enable", options.serviceName]);
+    if (enable.code !== 0) {
+      throw new Error(t("service.systemd.enableFailed", {
+        detail: enable.stderr || enable.stdout
+      }));
+    }
+  }
+  const restart = await runCommand("systemctl", ["--user", "restart", options.serviceName]);
+  if (restart.code !== 0) {
+    throw new Error(t("service.systemd.restartFailed", {
+      detail: restart.stderr || restart.stdout
+    }));
+  }
+}
+async function installLaunchdService(options) {
+  const launchAgentsPath = launchdLaunchAgentsPlistPath(options.serviceName);
+  const localPath = launchdLocalPlistPath(options.serviceName, options.installDir);
+  const targetPath = options.autostart ? launchAgentsPath : localPath;
+  if (options.autostart) {
+    await ensureDir(join3(homedir3(), "Library", "LaunchAgents"));
+  }
+  await writeText(targetPath, buildLaunchdPlist(options));
+  await runCommand("launchctl", [
+    "bootout",
+    `gui/${process.getuid?.() ?? 0}`,
+    launchAgentsPath
+  ]).catch(() => null);
+  await runCommand("launchctl", ["bootout", `gui/${process.getuid?.() ?? 0}`, localPath]).catch(() => null);
+  const uid = String(process.getuid?.() ?? 0);
+  const bootstrap = await runCommand("launchctl", ["bootstrap", `gui/${uid}`, targetPath]);
+  if (bootstrap.code !== 0) {
+    throw new Error(t("service.launchd.bootstrapFailed", {
+      detail: bootstrap.stderr || bootstrap.stdout
+    }));
+  }
+}
+async function installService(options) {
+  const manager = detectServiceManager();
+  if (manager === "systemd-user") {
+    await installSystemdService(options);
+    return;
+  }
+  if (manager === "launchd") {
+    await installLaunchdService(options);
+    return;
+  }
+  throw new Error(t("service.install.unsupportedPlatform", { platform: process.platform }));
+}
+async function stopSystemd(serviceName) {
+  await runCommand("systemctl", ["--user", "stop", serviceName]).catch(() => null);
+}
+async function stopService(serviceName, installDir) {
+  const manager = detectServiceManager();
+  if (manager === "systemd-user") {
+    await stopSystemd(serviceName);
+    return;
+  }
+  if (manager === "launchd") {
+    const uid = String(process.getuid?.() ?? 0);
+    const launchAgentsPath = launchdLaunchAgentsPlistPath(serviceName);
+    await runCommand("launchctl", ["bootout", `gui/${uid}`, launchAgentsPath]).catch(() => null);
+    if (installDir) {
+      const localPath = launchdLocalPlistPath(serviceName, installDir);
+      await runCommand("launchctl", ["bootout", `gui/${uid}`, localPath]).catch(() => null);
+    }
+  }
+}
+async function uninstallSystemdService(serviceName) {
+  await runCommand("systemctl", ["--user", "disable", "--now", serviceName]).catch(() => null);
+  const unitPath = systemdUnitPath(serviceName);
+  if (await pathExists(unitPath)) {
+    await rm(unitPath, { force: true });
+  }
+  await runCommand("systemctl", ["--user", "daemon-reload"]).catch(() => null);
+}
+async function uninstallService(options) {
+  const manager = detectServiceManager();
+  if (manager === "systemd-user") {
+    await uninstallSystemdService(options.serviceName);
+    return;
+  }
+  if (manager === "launchd") {
+    const uid = String(process.getuid?.() ?? 0);
+    const launchAgentsPath = launchdLaunchAgentsPlistPath(options.serviceName);
+    await runCommand("launchctl", ["bootout", `gui/${uid}`, launchAgentsPath]).catch(() => null);
+    await rm(launchAgentsPath, { force: true }).catch(() => null);
+    if (options.installDir) {
+      const localPath = launchdLocalPlistPath(options.serviceName, options.installDir);
+      await runCommand("launchctl", ["bootout", `gui/${uid}`, localPath]).catch(() => null);
+      await rm(localPath, { force: true }).catch(() => null);
+    }
+    return;
+  }
+}
+async function querySystemdStatus(serviceName) {
+  const unitPath = systemdUnitPath(serviceName);
+  const installed = await pathExists(unitPath);
+  const active = await runCommand("systemctl", ["--user", "is-active", serviceName]).catch(() => null);
+  const enabled = await runCommand("systemctl", ["--user", "is-enabled", serviceName]).catch(() => null);
+  return {
+    manager: "systemd-user",
+    installed,
+    running: active?.code === 0,
+    autostartEnabled: enabled?.code === 0,
+    detail: active?.stdout.trim() || enabled?.stdout.trim() || undefined
+  };
+}
+async function queryLaunchdStatus(serviceName, installDir) {
+  const launchAgentsPath = launchdLaunchAgentsPlistPath(serviceName);
+  const localPath = installDir ? launchdLocalPlistPath(serviceName, installDir) : null;
+  const hasLaunchAgents = await pathExists(launchAgentsPath);
+  const hasLocal = localPath ? await pathExists(localPath) : false;
+  const installed = hasLaunchAgents || hasLocal;
+  const uid = String(process.getuid?.() ?? 0);
+  const label = launchdLabel(serviceName);
+  const printed = await runCommand("launchctl", ["print", `gui/${uid}/${label}`]).catch(() => null);
+  return {
+    manager: "launchd",
+    installed,
+    running: printed?.code === 0,
+    autostartEnabled: hasLaunchAgents,
+    detail: installed ? printed?.code === 0 ? "loaded" : (printed?.stderr || printed?.stdout || "").trim() : t("service.status.plistMissing")
+  };
+}
+async function getServiceStatus(serviceName, installDir) {
+  const manager = detectServiceManager();
+  if (manager === "systemd-user") {
+    return await querySystemdStatus(serviceName);
+  }
+  if (manager === "launchd") {
+    return await queryLaunchdStatus(serviceName, installDir);
+  }
+  return {
+    manager: "none",
+    installed: false,
+    running: false,
+    autostartEnabled: false,
+    detail: t("service.status.none", { platform: process.platform })
+  };
+}
+function serviceHint(serviceName) {
+  const manager = detectServiceManager();
+  if (manager === "systemd-user") {
+    return t("service.hint.systemd", { serviceName });
+  }
+  if (manager === "launchd") {
+    return t("service.hint.launchd", { serviceName });
+  }
+  return t("service.hint.none");
+}
+
+// src/lib/validate.ts
+function asString(value) {
+  if (typeof value === "string")
+    return value;
+  return;
+}
+function asBoolean(value) {
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value !== "string")
+    return;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "y") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "n") {
+    return false;
+  }
+  return;
+}
+function parsePort(value) {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(t("errors.validate.invalidPort", { value }));
+  }
+  return port;
+}
+function assertNonEmpty(value, fieldName) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error(t("errors.validate.emptyField", { field: fieldName }));
+  }
+  return trimmed;
+}
+
+// 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));
+    return;
+  }
+  for (const check of checks) {
+    const prefix = check.level === "pass" ? "PASS" : check.level === "warn" ? "WARN" : "FAIL";
+    console.log(`[${prefix}] ${check.message}`);
+    if (check.detail) {
+      console.log(`  ${check.detail.trim()}`);
+    }
+  }
+}
+async function runDoctor(parsed) {
+  const json = asBoolean(parsed.flags.json) ?? false;
+  const installDirFlag = asString(parsed.flags["install-dir"]);
+  const installDir = resolveInstallDir(installDirFlag || defaultInstallDir(process.platform));
+  const installLayout = createInstallLayout(installDir);
+  const checks = [];
+  if (!isSupportedPlatform()) {
+    checks.push({
+      id: "platform",
+      level: "warn",
+      message: t("doctor.platform.unsupported", { platform: process.platform })
+    });
+  } else {
+    checks.push({
+      id: "platform",
+      level: "pass",
+      message: t("doctor.platform.supported", { platform: process.platform })
+    });
+  }
+  const bun = await checkBunVersion();
+  if (bun.ok) {
+    checks.push({
+      id: "bun",
+      level: "pass",
+      message: t("doctor.bun.ok", { version: bun.version }),
+      detail: bun.path
+    });
+  } else {
+    checks.push({
+      id: "bun",
+      level: "fail",
+      message: t("doctor.bun.fail", { reason: bun.reason || t("bun.checkFailed") }),
+      detail: bun.path
+    });
+  }
+  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({
+      id: "ssh",
+      level: "pass",
+      message: t("doctor.ssh.ok"),
+      detail: (ssh.stderr || ssh.stdout).trim()
+    });
+  } else {
+    checks.push({ id: "ssh", level: "warn", message: t("doctor.ssh.missing") });
+  }
+  let healthHost = "127.0.0.1";
+  let healthPort = "9883";
+  if (await pathExists(installDir)) {
+    checks.push({
+      id: "install-dir",
+      level: "pass",
+      message: t("doctor.installDir.exists", { installDir })
+    });
+  } else {
+    checks.push({
+      id: "install-dir",
+      level: "warn",
+      message: t("doctor.installDir.missing", { installDir })
+    });
+  }
+  if (await pathExists(installLayout.envPath)) {
+    checks.push({
+      id: "env",
+      level: "pass",
+      message: t("doctor.env.exists", { envPath: installLayout.envPath })
+    });
+    const env = await readEnvFile(installLayout.envPath);
+    const required = ["TMEX_MASTER_KEY", "DATABASE_URL", "GATEWAY_PORT", "TMEX_BIND_HOST"];
+    for (const key of required) {
+      if (!env[key]) {
+        checks.push({
+          id: `env.${key}`,
+          level: "fail",
+          message: t("doctor.env.keyMissing", { key })
+        });
+      }
+    }
+    const dbPath = env.DATABASE_URL;
+    if (dbPath) {
+      const resolved = resolve4(dbPath);
+      const exists = await pathExists(resolved);
+      if (!exists) {
+        checks.push({
+          id: "db",
+          level: "warn",
+          message: t("doctor.db.missing", { path: resolved })
+        });
+      } else {
+        const st = await stat(resolved);
+        checks.push({
+          id: "db",
+          level: "pass",
+          message: t("doctor.db.exists", { path: resolved }),
+          detail: `${st.size} bytes`
+        });
+      }
+    }
+    const port = env.GATEWAY_PORT;
+    if (port) {
+      healthPort = port;
+      const portNum = Number(port);
+      if (!Number.isInteger(portNum) || portNum < 1 || portNum > 65535) {
+        checks.push({
+          id: "port",
+          level: "fail",
+          message: t("doctor.port.invalid", { value: port })
+        });
+      }
+    }
+    if (env.TMEX_BIND_HOST) {
+      healthHost = env.TMEX_BIND_HOST;
+    }
+  } else {
+    checks.push({
+      id: "env",
+      level: "warn",
+      message: t("doctor.env.missing", { envPath: installLayout.envPath })
+    });
+  }
+  let serviceName = asString(parsed.flags["service-name"]) || "tmex";
+  if (await pathExists(installLayout.metaPath)) {
+    const meta = await readJsonFile(installLayout.metaPath).catch(() => null);
+    if (meta?.serviceName) {
+      serviceName = meta.serviceName;
+    }
+  }
+  const status = await getServiceStatus(serviceName, installDir);
+  if (status.manager === "none") {
+    checks.push({
+      id: "service",
+      level: "warn",
+      message: t("doctor.service.noManager", { detail: status.detail || "" })
+    });
+  } else if (!status.installed) {
+    checks.push({
+      id: "service",
+      level: "warn",
+      message: t("doctor.service.notInstalled", { serviceName }),
+      detail: status.detail
+    });
+  } else if (!status.running) {
+    checks.push({
+      id: "service",
+      level: "warn",
+      message: t("doctor.service.notRunning", { serviceName }),
+      detail: status.detail
+    });
+  } else {
+    checks.push({
+      id: "service",
+      level: "pass",
+      message: t("doctor.service.running", { serviceName }),
+      detail: status.detail
+    });
+  }
+  const healthUrl = `http://${healthHost}:${healthPort}/healthz`;
+  const normalizedHealthUrl = healthHost === "0.0.0.0" ? `http://127.0.0.1:${healthPort}/healthz` : healthUrl;
+  const healthResponse = await fetch(normalizedHealthUrl, {
+    signal: AbortSignal.timeout(3000)
+  }).catch(() => null);
+  if (healthResponse?.ok) {
+    checks.push({
+      id: "healthz",
+      level: "pass",
+      message: t("doctor.health.pass", { url: normalizedHealthUrl })
+    });
+  } else {
+    checks.push({
+      id: "healthz",
+      level: "warn",
+      message: t("doctor.health.fail", { url: normalizedHealthUrl })
+    });
+  }
+  printChecks(checks, json);
+  const failed = checks.some((check) => check.level === "fail");
+  if (failed) {
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/init.ts
+import { readdir } from "node:fs/promises";
+import { dirname as dirname4, resolve as resolve6 } from "node:path";
+
+// src/lib/install.ts
+import { randomBytes } from "node:crypto";
+import { chmod, copyFile, rm as rm2 } from "node:fs/promises";
+import { resolve as resolve5 } from "node:path";
+function generateMasterKey() {
+  return randomBytes(32).toString("base64");
+}
+function buildAppEnvValues(input) {
+  return {
+    NODE_ENV: "production",
+    TMEX_BIND_HOST: input.host,
+    GATEWAY_PORT: String(input.port),
+    DATABASE_URL: input.databasePath,
+    TMEX_MASTER_KEY: input.masterKey,
+    TMEX_BASE_URL: `http://${input.host}:${input.port}`,
+    TMEX_SITE_NAME: "tmex"
+  };
+}
+async function ensureInstallDir(installDir, force) {
+  if (!await pathExists(installDir)) {
+    await ensureDir(installDir);
+    return;
+  }
+  if (!force) {
+    return;
+  }
+  await rm2(installDir, { recursive: true, force: true });
+  await ensureDir(installDir);
+}
+async function deployRuntimeFiles(packageLayout, installLayout) {
+  await rm2(installLayout.runtimeDir, { recursive: true, force: true });
+  await rm2(installLayout.feDir, { recursive: true, force: true });
+  await rm2(installLayout.drizzleDir, { recursive: true, force: true });
+  await ensureDir(installLayout.runtimeDir);
+  await ensureDir(installLayout.resourcesDir);
+  await copyDirectory(packageLayout.runtimeDirPath, installLayout.runtimeDir);
+  await copyDirectory(packageLayout.resourceFePath, installLayout.feDir);
+  await copyDirectory(packageLayout.resourceDrizzlePath, installLayout.drizzleDir);
+}
+async function writeRunScript(installLayout, bunPath) {
+  const lines = [
+    "#!/usr/bin/env bash",
+    "set -euo pipefail",
+    "",
+    'SCRIPT_DIR="$(cd -- "$(dirname -- "$0")" && pwd)"',
+    'while IFS= read -r line || [[ -n "$line" ]]; do',
+    `  line="\${line%$'\\r'}"`,
+    '  [[ "$line" =~ ^[[:space:]]*$ ]] && continue',
+    '  [[ "$line" =~ ^[[:space:]]*# ]] && continue',
+    '  export "$line"',
+    `done < "${installLayout.envPath}"`,
+    "",
+    'if [[ -n "${HOME:-}" ]] && [[ -d "${HOME}/.bun/bin" ]]; then',
+    '  export PATH="${HOME}/.bun/bin:${PATH:-}"',
+    "fi",
+    "",
+    `export TMEX_FE_DIST_DIR="${installLayout.feDir}"`,
+    `export TMEX_MIGRATIONS_DIR="${installLayout.drizzleDir}"`,
+    "",
+    `exec "${bunPath}" "${installLayout.runtimeServerPath}"`,
+    ""
+  ];
+  const script = lines.join(`
+`);
+  await writeText(installLayout.runScriptPath, script, 493);
+  await chmod(installLayout.runScriptPath, 493);
+}
+async function writeInstallMeta(installLayout, meta) {
+  await writeJsonFile(installLayout.metaPath, meta, 384);
+}
+async function backupInstallArtifacts(installLayout, backupDir) {
+  await ensureDir(backupDir);
+  if (await pathExists(installLayout.runtimeDir)) {
+    await copyDirectory(installLayout.runtimeDir, resolve5(backupDir, "runtime"));
+  }
+  if (await pathExists(installLayout.resourcesDir)) {
+    await copyDirectory(installLayout.resourcesDir, resolve5(backupDir, "resources"));
+  }
+  if (await pathExists(installLayout.runScriptPath)) {
+    await copyFile(installLayout.runScriptPath, resolve5(backupDir, "run.sh"));
+  }
+  if (await pathExists(installLayout.metaPath)) {
+    await copyFile(installLayout.metaPath, resolve5(backupDir, "install-meta.json"));
+  }
+}
+async function restoreInstallArtifacts(installLayout, backupDir) {
+  const runtimeBackup = resolve5(backupDir, "runtime");
+  const resourcesBackup = resolve5(backupDir, "resources");
+  const runScriptBackup = resolve5(backupDir, "run.sh");
+  const metaBackup = resolve5(backupDir, "install-meta.json");
+  await rm2(installLayout.runtimeDir, { recursive: true, force: true });
+  await rm2(installLayout.resourcesDir, { recursive: true, force: true });
+  if (await pathExists(runtimeBackup)) {
+    await copyDirectory(runtimeBackup, installLayout.runtimeDir);
+  }
+  if (await pathExists(resourcesBackup)) {
+    await copyDirectory(resourcesBackup, installLayout.resourcesDir);
+  }
+  if (await pathExists(runScriptBackup)) {
+    await copyFile(runScriptBackup, installLayout.runScriptPath);
+  }
+  if (await pathExists(metaBackup)) {
+    await copyFile(metaBackup, installLayout.metaPath);
+  }
+}
+
+// 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 join4 } from "node:path";
+async function readPackageVersion(packageRoot) {
+  const pkg = await readJsonFile(join4(packageRoot, "package.json"));
+  return pkg.version || "0.0.0";
+}
+
+// src/commands/init.ts
+function mustGetStringFlag(flags, key) {
+  const value = asString(flags[key]);
+  if (!value) {
+    throw new Error(t("errors.args.missingFlag", { flag: key }));
+  }
+  return value;
+}
+function mustGetBooleanFlag(flags, key) {
+  const value = asBoolean(flags[key]);
+  if (value === undefined) {
+    throw new Error(t("errors.args.invalidFlag", { flag: key, value: String(flags[key]) }));
+  }
+  return value;
+}
+async function directoryHasContent(path) {
+  if (!await pathExists(path)) {
+    return false;
+  }
+  const items = await readdir(path);
+  return items.length > 0;
+}
+async function buildInitConfig(parsed) {
+  const nonInteractive = parsed.flags["no-interactive"] === true;
+  const force = asBoolean(parsed.flags.force) ?? false;
+  if (nonInteractive) {
+    const installDir2 = resolveInstallDir(assertNonEmpty(mustGetStringFlag(parsed.flags, "install-dir"), "install-dir"));
+    const host2 = assertNonEmpty(mustGetStringFlag(parsed.flags, "host"), "host");
+    const port2 = parsePort(assertNonEmpty(mustGetStringFlag(parsed.flags, "port"), "port"));
+    const databasePath2 = resolve6(assertNonEmpty(mustGetStringFlag(parsed.flags, "db-path"), "db-path"));
+    const autostart2 = mustGetBooleanFlag(parsed.flags, "autostart");
+    const serviceName2 = assertNonEmpty(asString(parsed.flags["service-name"]) || DEFAULT_SERVICE_NAME, "service-name");
+    return {
+      installDir: installDir2,
+      host: host2,
+      port: port2,
+      databasePath: databasePath2,
+      autostart: autostart2,
+      serviceName: serviceName2,
+      force,
+      nonInteractive
+    };
+  }
+  const fallbackInstallDir = defaultInstallDir(process.platform);
+  const installDirPrompt = await promptText({ nonInteractive: false }, t("init.prompt.installDir"), asString(parsed.flags["install-dir"]) || fallbackInstallDir);
+  const installDir = resolveInstallDir(assertNonEmpty(installDirPrompt, "install-dir"));
+  const hostPrompt = await promptText({ nonInteractive: false }, t("init.prompt.host"), asString(parsed.flags.host) || defaultHost());
+  const host = assertNonEmpty(hostPrompt, "host");
+  const portPrompt = await promptText({ nonInteractive: false }, t("init.prompt.port"), asString(parsed.flags.port) || String(defaultPort()));
+  const port = parsePort(assertNonEmpty(portPrompt, "port"));
+  const databasePathPrompt = await promptText({ nonInteractive: false }, t("init.prompt.dbPath"), asString(parsed.flags["db-path"]) || defaultDatabasePath(installDir));
+  const databasePath = resolve6(assertNonEmpty(databasePathPrompt, "db-path"));
+  const autostart = asBoolean(parsed.flags.autostart) ?? await promptConfirm({ nonInteractive: false }, t("init.prompt.autostart"), true);
+  const serviceNamePrompt = await promptText({ nonInteractive: false }, t("init.prompt.serviceName"), asString(parsed.flags["service-name"]) || DEFAULT_SERVICE_NAME);
+  const serviceName = assertNonEmpty(serviceNamePrompt, "service-name");
+  return {
+    installDir,
+    host,
+    port,
+    databasePath,
+    autostart,
+    serviceName,
+    force,
+    nonInteractive
+  };
+}
+async function runInit(parsed) {
+  const config = await buildInitConfig(parsed);
+  const bun = await checkBunVersion();
+  if (!bun.ok || !bun.path) {
+    throw new Error(bun.reason || t("bun.checkFailed"));
+  }
+  if (!config.force && await directoryHasContent(config.installDir)) {
+    if (config.nonInteractive) {
+      throw new Error(t("init.error.installDirNotEmpty", { installDir: config.installDir }));
+    }
+    const confirmed = await promptConfirm({ nonInteractive: false }, t("init.prompt.dirExistsConfirm", { installDir: config.installDir }), false);
+    if (!confirmed) {
+      throw new Error(t("common.cancelled"));
+    }
+  }
+  const packageLayout = await resolvePackageLayout(import.meta.url);
+  const installLayout = createInstallLayout(config.installDir);
+  await ensureInstallDir(config.installDir, config.force);
+  await ensureDir(dirname4(config.databasePath));
+  await deployRuntimeFiles(packageLayout, installLayout);
+  const masterKey = generateMasterKey();
+  const envValues = buildAppEnvValues({
+    host: config.host,
+    port: config.port,
+    databasePath: config.databasePath,
+    masterKey
+  });
+  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
+    });
+  }
+  const cliVersion = await readPackageVersion(packageLayout.packageRoot);
+  const meta = {
+    serviceName: config.serviceName,
+    platform: process.platform,
+    autostart: config.autostart,
+    installDir: config.installDir,
+    updatedAt: new Date().toISOString(),
+    cliVersion
+  };
+  await writeInstallMeta(installLayout, meta);
+  console.log(`[tmex] ${t("init.done")}`);
+  console.log(`- ${t("init.summary.installDir")}: ${config.installDir}`);
+  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)}`);
+  }
+}
+
+// src/commands/uninstall.ts
+import { rm as rm3 } from "node:fs/promises";
+async function removeIfExists(path) {
+  if (await pathExists(path)) {
+    await rm3(path, { recursive: true, force: true });
+  }
+}
+async function runUninstall(parsed) {
+  const installDir = resolveInstallDir(asString(parsed.flags["install-dir"]) || defaultInstallDir(process.platform));
+  const installLayout = createInstallLayout(installDir);
+  const yes = asBoolean(parsed.flags.yes) ?? false;
+  const purge = asBoolean(parsed.flags.purge) ?? false;
+  let serviceName = asString(parsed.flags["service-name"]) || "tmex";
+  if (await pathExists(installLayout.metaPath)) {
+    const meta = await readJsonFile(installLayout.metaPath);
+    serviceName = meta.serviceName;
+  }
+  const ask = async (message, defaultValue) => {
+    if (yes)
+      return defaultValue;
+    return await promptConfirm({ nonInteractive: false }, message, defaultValue);
+  };
+  const removeService = await ask(t("uninstall.prompt.removeService"), true);
+  const removeProgram = await ask(t("uninstall.prompt.removeProgram"), true);
+  const removeEnv = await ask(t("uninstall.prompt.removeEnv"), purge);
+  const removeDatabase = await ask(t("uninstall.prompt.removeDatabase"), purge);
+  let databasePath;
+  if (await pathExists(installLayout.envPath)) {
+    const env = await readEnvFile(installLayout.envPath).catch(() => ({}));
+    databasePath = env.DATABASE_URL;
+  }
+  if (removeService) {
+    await uninstallService({ serviceName, installDir });
+  }
+  if (removeProgram) {
+    await removeIfExists(installLayout.runtimeDir);
+    await removeIfExists(installLayout.resourcesDir);
+    await removeIfExists(installLayout.runScriptPath);
+    await removeIfExists(installLayout.metaPath);
+  }
+  if (removeEnv) {
+    await removeIfExists(installLayout.envPath);
+  }
+  if (removeDatabase) {
+    if (databasePath) {
+      await removeIfExists(resolvePath(databasePath));
+    }
+  }
+  if (purge) {
+    await removeIfExists(installLayout.installDir);
+  }
+  console.log(`[tmex] ${t("uninstall.done")}`);
+  console.log(`- ${t("uninstall.summary.installDir")}: ${installLayout.installDir}`);
+  console.log(`- ${t("uninstall.summary.serviceName")}: ${serviceName}`);
+}
+
+// src/commands/upgrade.ts
+import { mkdtemp, rm as rm4 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join5 } from "node:path";
+async function delegateUpgrade(parsed, targetVersion) {
+  const args = ["--yes", `tmex-cli@${targetVersion}`, "upgrade", "--apply-current-package"];
+  const passthrough = ["install-dir", "service-name", "yes", "lang"];
+  for (const key of passthrough) {
+    const value = parsed.flags[key];
+    if (value === undefined)
+      continue;
+    if (value === true) {
+      args.push(`--${key}`);
+    } else {
+      args.push(`--${key}`, String(value));
+    }
+  }
+  const result = await runCommand("npx", args, { stdio: "inherit" });
+  if (result.code !== 0) {
+    throw new Error(t("upgrade.delegateFailed", { code: result.code }));
+  }
+}
+async function verifyHealth(installLayout) {
+  if (!await pathExists(installLayout.envPath)) {
+    return;
+  }
+  const env = await readEnvFile(installLayout.envPath).catch(() => ({}));
+  const port = String(env.GATEWAY_PORT || "9883");
+  const hostFromEnv = String(env.TMEX_BIND_HOST || "127.0.0.1");
+  const host = hostFromEnv === "0.0.0.0" ? "127.0.0.1" : hostFromEnv;
+  const url = `http://${host}:${port}/healthz`;
+  const startedAt = Date.now();
+  let lastError = null;
+  while (Date.now() - startedAt < 30000) {
+    try {
+      const response = await fetch(url, { signal: AbortSignal.timeout(4000) });
+      if (response.ok) {
+        return;
+      }
+      lastError = new Error(t("upgrade.healthFailed", { status: response.status }));
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+    }
+    await new Promise((resolve7) => setTimeout(resolve7, 1000));
+  }
+  throw lastError || new Error(t("upgrade.healthFailed", { status: "timeout" }));
+}
+async function runUpgrade(parsed) {
+  const applyCurrent = asBoolean(parsed.flags["apply-current-package"]) ?? false;
+  const targetVersion = asString(parsed.flags.version) || "latest";
+  if (!applyCurrent) {
+    await delegateUpgrade(parsed, targetVersion);
+    return;
+  }
+  const installDir = resolveInstallDir(asString(parsed.flags["install-dir"]) || defaultInstallDir(process.platform));
+  const installLayout = createInstallLayout(installDir);
+  if (!await pathExists(installLayout.metaPath)) {
+    throw new Error(t("upgrade.missingMeta", { path: installLayout.metaPath }));
+  }
+  const bun = await checkBunVersion();
+  if (!bun.ok || !bun.path) {
+    throw new Error(bun.reason || t("bun.checkFailed"));
+  }
+  const meta = await readJsonFile(installLayout.metaPath);
+  const packageLayout = await resolvePackageLayout(import.meta.url);
+  const backupDir = await mkdtemp(join5(tmpdir(), "tmex-upgrade-"));
+  try {
+    await stopService(meta.serviceName, installDir);
+    await backupInstallArtifacts(installLayout, backupDir);
+    await deployRuntimeFiles(packageLayout, installLayout);
+    await writeRunScript(installLayout, bun.path);
+    const cliVersion = await readPackageVersion(packageLayout.packageRoot);
+    meta.updatedAt = new Date().toISOString();
+    meta.cliVersion = cliVersion;
+    await writeInstallMeta(installLayout, meta);
+    await installService({
+      serviceName: meta.serviceName,
+      runScriptPath: installLayout.runScriptPath,
+      installDir,
+      autostart: meta.autostart
+    });
+    await verifyHealth(installLayout);
+    console.log(`[tmex] ${t("upgrade.done")}`);
+    console.log(`- ${t("upgrade.summary.targetVersion")}: ${targetVersion}`);
+    console.log(`- ${t("upgrade.summary.installDir")}: ${installDir}`);
+  } catch (error) {
+    console.error(`[tmex] ${t("upgrade.failedRollingBack")}`);
+    await restoreInstallArtifacts(installLayout, backupDir);
+    await installService({
+      serviceName: meta.serviceName,
+      runScriptPath: installLayout.runScriptPath,
+      installDir,
+      autostart: meta.autostart
+    }).catch(() => null);
+    throw error;
+  } finally {
+    await rm4(backupDir, { recursive: true, force: true }).catch(() => null);
+  }
+}
+
+// src/lib/args.ts
+function parseArgs(argv) {
+  let command = null;
+  const flags = {};
+  const positionals = [];
+  for (let index = 0;index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) {
+      if (command === null) {
+        command = token;
+      } else {
+        positionals.push(token);
+      }
+      continue;
+    }
+    const noPrefix = token.slice(2);
+    const equalIndex = noPrefix.indexOf("=");
+    if (equalIndex >= 0) {
+      const key = noPrefix.slice(0, equalIndex);
+      const value = noPrefix.slice(equalIndex + 1);
+      flags[key] = value;
+      continue;
+    }
+    const maybeNext = argv[index + 1];
+    if (maybeNext && !maybeNext.startsWith("--")) {
+      flags[noPrefix] = maybeNext;
+      index += 1;
+      continue;
+    }
+    flags[noPrefix] = true;
+  }
+  return {
+    command,
+    flags,
+    positionals
+  };
+}
+
+// src/cli-node.ts
+function printHelp() {
+  console.log(t("cli.help"));
+}
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  const requestedLang = (typeof parsed.flags.lang === "string" ? parsed.flags.lang : undefined) || process.env.TMEX_CLI_LANG;
+  setLang(normalizeLang(requestedLang));
+  switch (parsed.command) {
+    case "init":
+      await runInit(parsed);
+      return;
+    case "doctor":
+      await runDoctor(parsed);
+      return;
+    case "upgrade":
+      await runUpgrade(parsed);
+      return;
+    case "uninstall":
+      await runUninstall(parsed);
+      return;
+    case "--help":
+    case "-h":
+    case "help":
+    case undefined:
+    case null:
+      printHelp();
+      return;
+    default:
+      throw new Error(t("cli.error.unknownCommand", { command: parsed.command }));
+  }
+}
+export {
+  main
+};