baton-host 0.1.5 → 0.1.7

package/bin/baton-host.js

@@ -1,7 +1,11 @@
 #!/usr/bin/env node
 
-const { spawn } = require("node:child_process");
+const { spawn, spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const net = require("node:net");
+const os = require("node:os");
 const path = require("node:path");
+const { createInterface } = require("node:readline/promises");
 
 const mapping = {
   "darwin-arm64": "baton-host-darwin-arm64",
@@ -10,37 +14,790 @@ const mapping = {
   "linux-x64": "baton-host-linux-x64"
 };
 
-const key = `${process.platform}-${process.arch}`;
-const pkg = mapping[key];
+const SERVICE_LABEL = "com.baton.host";
+const INSTALL_ROOT = path.join(os.homedir(), ".baton-host");
+const INSTALL_BIN_DIR = path.join(INSTALL_ROOT, "bin");
+const INSTALL_LOG_DIR = path.join(INSTALL_ROOT, "logs");
+const ENV_FILE_PATH = path.join(INSTALL_ROOT, ".env");
+const BRIDGE_INFO_PATH = path.join(INSTALL_ROOT, "bridge-info.json");
+const WRAPPER_PATH = path.join(INSTALL_ROOT, "run.sh");
+const INSTALL_META_PATH = path.join(INSTALL_ROOT, "install.json");
 
-if (!pkg) {
-  console.error(`❌ 当前平台暂不支持: ${key}`);
+function fail(message) {
+  console.error(`❌ ${message}`);
   process.exit(1);
 }
 
-let binaryPath;
-try {
-  const pkgJsonPath = require.resolve(`${pkg}/package.json`);
-  binaryPath = path.join(path.dirname(pkgJsonPath), "bin", "baton-host");
-} catch (error) {
-  console.error(`❌ 未找到平台二进制包 ${pkg}，请重装 baton-host`);
-  process.exit(1);
+function getCurrentPlatformKey() {
+  return `${process.platform}-${process.arch}`;
+}
+
+function getMainPackageVersion() {
+  const packageJsonPath = path.join(__dirname, "..", "package.json");
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  return packageJson.version;
 }
 
-const bundledCloudflaredPath = path.join(path.dirname(binaryPath), process.platform === "win32" ? "cloudflared.exe" : "cloudflared");
+function resolveBundledAssets() {
+  const key = getCurrentPlatformKey();
+  const pkg = mapping[key];
 
-const child = spawn(binaryPath, process.argv.slice(2), {
-  stdio: "inherit",
-  env: {
-    ...process.env,
-    BATON_CLOUDFLARED_BIN: bundledCloudflaredPath
+  if (!pkg) {
+    fail(`当前平台暂不支持: ${key}`);
   }
-});
 
-child.on("exit", (code, signal) => {
-  if (signal) {
-    process.kill(process.pid, signal);
+  let pkgJsonPath;
+  try {
+    pkgJsonPath = require.resolve(`${pkg}/package.json`);
+  } catch (error) {
+    fail(`未找到平台二进制包 ${pkg}，请重新执行 npx baton-host@latest service install`);
+  }
+
+  const binaryPath = path.join(path.dirname(pkgJsonPath), "bin", "baton-host");
+  const cloudflaredPath = path.join(
+    path.dirname(binaryPath),
+    process.platform === "win32" ? "cloudflared.exe" : "cloudflared"
+  );
+
+  if (!fs.existsSync(binaryPath)) {
+    fail(`缺少 Baton Host 二进制: ${binaryPath}`);
+  }
+
+  if (!fs.existsSync(cloudflaredPath)) {
+    fail(`缺少 cloudflared 二进制: ${cloudflaredPath}`);
+  }
+
+  return {
+    binaryPath,
+    cloudflaredPath,
+    version: getMainPackageVersion()
+  };
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function copyExecutable(sourcePath, targetPath) {
+  fs.copyFileSync(sourcePath, targetPath);
+  fs.chmodSync(targetPath, 0o755);
+}
+
+function readInstallMeta() {
+  if (!fs.existsSync(INSTALL_META_PATH)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(INSTALL_META_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeInstallMeta(version) {
+  const payload = {
+    version,
+    installedAt: new Date().toISOString(),
+    platform: process.platform,
+    arch: process.arch
+  };
+  fs.writeFileSync(INSTALL_META_PATH, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+
+function ensureDefaultEnvFile() {
+  if (fs.existsSync(ENV_FILE_PATH)) {
     return;
   }
-  process.exit(code ?? 0);
+
+  const defaultContent = [
+    "# Baton Host 服务环境变量",
+    "BATON_BRIDGE_MODE=cloudflare",
+    "BRIDGE_LOG_PROFILE=core",
+    "PORT=9977",
+    ""
+  ].join("\n");
+
+  fs.writeFileSync(ENV_FILE_PATH, defaultContent, "utf8");
+}
+
+function readEnvFile() {
+  if (!fs.existsSync(ENV_FILE_PATH)) {
+    return {};
+  }
+
+  const result = {};
+  const content = fs.readFileSync(ENV_FILE_PATH, "utf8");
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    const separatorIndex = line.indexOf("=");
+    if (separatorIndex <= 0) {
+      continue;
+    }
+    const key = line.slice(0, separatorIndex).trim();
+    const value = line.slice(separatorIndex + 1).trim();
+    result[key] = value;
+  }
+  return result;
+}
+
+function writeEnvFile(envVars) {
+  const existingContent = fs.existsSync(ENV_FILE_PATH)
+    ? fs.readFileSync(ENV_FILE_PATH, "utf8")
+    : "# Baton Host 服务环境变量\n";
+  const lines = existingContent.split(/\r?\n/);
+  const keysToWrite = new Set(Object.keys(envVars));
+  const seenKeys = new Set();
+  const nextLines = lines.map((rawLine) => {
+    const trimmed = rawLine.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      return rawLine;
+    }
+    const separatorIndex = rawLine.indexOf("=");
+    if (separatorIndex <= 0) {
+      return rawLine;
+    }
+    const key = rawLine.slice(0, separatorIndex).trim();
+    if (!keysToWrite.has(key)) {
+      return rawLine;
+    }
+    seenKeys.add(key);
+    return `${key}=${envVars[key]}`;
+  });
+
+  for (const key of keysToWrite) {
+    if (!seenKeys.has(key)) {
+      nextLines.push(`${key}=${envVars[key]}`);
+    }
+  }
+
+  const content = `${nextLines.filter((line, index, array) => !(index === array.length - 1 && line === "")).join("\n")}\n`;
+  fs.writeFileSync(ENV_FILE_PATH, content, "utf8");
+}
+
+function isInteractiveTerminal() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+function pickAvailablePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close(() => reject(new Error("随机端口分配失败")));
+        return;
+      }
+      resolve(address.port);
+      server.close();
+    });
+  });
+}
+
+function isValidPort(value) {
+  const port = Number(value);
+  return Number.isInteger(port) && port >= 1 && port <= 65535;
+}
+
+async function ensurePortAvailable(port) {
+  await new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => {
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  });
+  return port;
+}
+
+async function promptBridgeModeForInstall() {
+  if (!isInteractiveTerminal()) {
+    return "cloudflare";
+  }
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  try {
+    while (true) {
+      console.log("请选择连接方式：");
+      console.log("1) 局域网（同一 Wi‑Fi 下用）");
+      console.log("2) Cloudflare（推荐，直接回车也选这个）");
+      console.log("3) Tailscale");
+      const answer = (await rl.question("输入 1 / 2 / 3，直接回车默认 Cloudflare: ")).trim();
+      if (!answer || answer === "2") {
+        return "cloudflare";
+      }
+      if (answer === "1") {
+        return "lan";
+      }
+      if (answer === "3") {
+        return "tailscale";
+      }
+      console.log("⚠️ 请输入 1、2、3，或直接回车。\n");
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+async function promptPortForInstall() {
+  const randomPort = await pickAvailablePort();
+  if (!isInteractiveTerminal()) {
+    return randomPort;
+  }
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  try {
+    while (true) {
+      console.log("\n请选择端口：");
+      console.log(`直接回车：自动分配随机端口（推荐，当前候选 ${randomPort}）`);
+      console.log("输入端口号：使用自定义端口");
+      const answer = (await rl.question("输入端口号，或直接回车使用随机端口: ")).trim();
+      if (!answer) {
+        return randomPort;
+      }
+      if (isValidPort(answer)) {
+        try {
+          return await ensurePortAvailable(Number(answer));
+        } catch {
+          console.log("⚠️ 这个端口当前不可用，请换一个。\n");
+          continue;
+        }
+      }
+      console.log("⚠️ 请输入 1-65535 的有效端口号，或直接回车。\n");
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+async function printBridgeInfoFromCache() {
+  if (!fs.existsSync(BRIDGE_INFO_PATH)) {
+    throw new Error("未找到已保存的连接信息，请稍后重试");
+  }
+
+  let cached;
+  try {
+    cached = JSON.parse(fs.readFileSync(BRIDGE_INFO_PATH, "utf8"));
+  } catch {
+    throw new Error("已保存的连接信息损坏，请重新执行 service restart");
+  }
+
+  if (!cached?.bridgeUrl || !cached?.displayLabel) {
+    throw new Error("已保存的连接信息不完整，请稍后重试");
+  }
+
+  const payload = JSON.stringify({ bridgeUrl: cached.bridgeUrl });
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const qrcode = require("qrcode-terminal");
+
+  console.log("\n✅ Baton Bridge 已启动");
+  console.log(`模式: ${cached.displayLabel}`);
+  console.log(`主连接地址: ${cached.bridgeUrl}`);
+  if (cached.lanBridgeUrl && cached.lanBridgeUrl !== cached.bridgeUrl) {
+    console.log(`局域网地址: ${cached.lanBridgeUrl}`);
+  }
+  if (cached.note) {
+    console.log(`说明: ${cached.note}`);
+  }
+  console.log("\n请使用 Baton App 扫描下方二维码连接：\n");
+
+  await new Promise((resolve) => {
+    qrcode.generate(payload, { small: true }, (qrText) => {
+      for (const line of qrText.split("\n")) {
+        console.log(line);
+      }
+      resolve();
+    });
+  });
+
+  console.log("\n在 Baton App → 设置 → Bridge 服务器 → 扫码连接");
+  console.log("现在可以关闭终端，服务会继续在后台运行。\n");
+}
+
+async function waitForBridgeInfo(timeoutMs = 15000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (fs.existsSync(BRIDGE_INFO_PATH)) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  throw new Error("等待连接信息生成超时，请稍后执行 service restart 再试");
+}
+
+async function runBridgePrintCommand() {
+  await waitForBridgeInfo();
+  await printBridgeInfoFromCache();
+}
+
+function buildWrapperScript() {
+  return `#!/bin/sh
+set -eu
+
+BATON_HOME="$HOME/.baton-host"
+ENV_FILE="$BATON_HOME/.env"
+
+if [ -f "$ENV_FILE" ]; then
+  while IFS= read -r line || [ -n "$line" ]; do
+    case "$line" in
+      ''|'#'*) continue ;;
+      *=*)
+        key=\${line%%=*}
+        value=\${line#*=}
+        export "$key=$value"
+        ;;
+    esac
+  done < "$ENV_FILE"
+fi
+
+export BATON_CLOUDFLARED_BIN="$BATON_HOME/bin/cloudflared"
+export PATH="$HOME/.local/bin:$HOME/Library/pnpm:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin\${PATH:+:$PATH}"
+
+exec "$BATON_HOME/bin/baton-host" "$@"
+`;
+}
+
+function writeWrapperScript() {
+  fs.writeFileSync(WRAPPER_PATH, buildWrapperScript(), { mode: 0o755 });
+  fs.chmodSync(WRAPPER_PATH, 0o755);
+}
+
+function escapeXml(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
+}
+
+function getServicePathEnv() {
+  return `${os.homedir()}/.local/bin:${os.homedir()}/Library/pnpm:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin`;
+}
+
+function getLinuxServiceName() {
+  return `${SERVICE_LABEL}.service`;
+}
+
+function getLinuxUnitPath() {
+  return path.join(os.homedir(), ".config", "systemd", "user", getLinuxServiceName());
+}
+
+function buildLinuxUnit() {
+  return `[Unit]
+Description=Baton Host
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=%h/.baton-host/run.sh
+WorkingDirectory=%h/.baton-host
+Restart=always
+RestartSec=2
+Environment=HOME=%h
+Environment=PATH=%h/.local/bin:%h/Library/pnpm:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+function getMacPlistPath() {
+  return path.join(os.homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
+}
+
+function buildMacPlist() {
+  const stdoutPath = path.join(INSTALL_LOG_DIR, "stdout.log");
+  const stderrPath = path.join(INSTALL_LOG_DIR, "stderr.log");
+  const servicePathEnv = getServicePathEnv();
+
+  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(SERVICE_LABEL)}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(WRAPPER_PATH)}</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(INSTALL_ROOT)}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ProcessType</key>
+  <string>Background</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HOME</key>
+    <string>${escapeXml(os.homedir())}</string>
+    <key>PATH</key>
+    <string>${escapeXml(servicePathEnv)}</string>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(stdoutPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(stderrPath)}</string>
+</dict>
+</plist>
+`;
+}
+
+function runCommand(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+
+  if (result.error) {
+    if (options.allowFailure) {
+      return result;
+    }
+    throw result.error;
+  }
+
+  if (!options.allowFailure && result.status !== 0) {
+    const output = (result.stderr || result.stdout || "").trim();
+    throw new Error(output || `${command} ${args.join(" ")} 失败，退出码 ${result.status}`);
+  }
+
+  return result;
+}
+
+function installLinuxService() {
+  const unitPath = getLinuxUnitPath();
+  ensureDir(path.dirname(unitPath));
+  fs.writeFileSync(unitPath, buildLinuxUnit(), "utf8");
+
+  runCommand("systemctl", ["--user", "daemon-reload"]);
+  runCommand("systemctl", ["--user", "enable", getLinuxServiceName()]);
+
+  const restartResult = runCommand(
+    "systemctl",
+    ["--user", "restart", getLinuxServiceName()],
+    { allowFailure: true }
+  );
+
+  if (restartResult.status !== 0) {
+    runCommand("systemctl", ["--user", "start", getLinuxServiceName()]);
+  }
+
+  return unitPath;
+}
+
+function installMacService() {
+  const plistPath = getMacPlistPath();
+  const launchTarget = `gui/${process.getuid()}`;
+  ensureDir(path.dirname(plistPath));
+  fs.writeFileSync(plistPath, buildMacPlist(), "utf8");
+
+  runCommand("launchctl", ["bootout", launchTarget, plistPath], { allowFailure: true });
+  runCommand("launchctl", ["bootstrap", launchTarget, plistPath]);
+  runCommand("launchctl", ["enable", `${launchTarget}/${SERVICE_LABEL}`], { allowFailure: true });
+  runCommand("launchctl", ["kickstart", "-k", `${launchTarget}/${SERVICE_LABEL}`], {
+    allowFailure: true
+  });
+
+  return plistPath;
+}
+
+function removePathIfExists(targetPath) {
+  if (!fs.existsSync(targetPath)) {
+    return;
+  }
+  fs.rmSync(targetPath, { recursive: true, force: true });
+}
+
+function restartLinuxService() {
+  if (!fs.existsSync(getLinuxUnitPath())) {
+    fail("尚未安装 Baton Host systemd 服务，请先执行 npx baton-host@latest service install");
+  }
+  runCommand("systemctl", ["--user", "restart", getLinuxServiceName()]);
+}
+
+function restartMacService() {
+  const plistPath = getMacPlistPath();
+  if (!fs.existsSync(plistPath)) {
+    fail("尚未安装 Baton Host LaunchAgent，请先执行 npx baton-host@latest service install");
+  }
+  const launchTarget = `gui/${process.getuid()}`;
+  runCommand("launchctl", ["bootout", launchTarget, plistPath], { allowFailure: true });
+  runCommand("launchctl", ["bootstrap", launchTarget, plistPath]);
+  runCommand("launchctl", ["kickstart", "-k", `${launchTarget}/${SERVICE_LABEL}`], {
+    allowFailure: true
+  });
+}
+
+function uninstallLinuxService() {
+  runCommand("systemctl", ["--user", "disable", "--now", getLinuxServiceName()], {
+    allowFailure: true
+  });
+  removePathIfExists(getLinuxUnitPath());
+  runCommand("systemctl", ["--user", "daemon-reload"], { allowFailure: true });
+}
+
+function uninstallMacService() {
+  const plistPath = getMacPlistPath();
+  const launchTarget = `gui/${process.getuid()}`;
+  runCommand("launchctl", ["bootout", launchTarget, plistPath], { allowFailure: true });
+  removePathIfExists(plistPath);
+}
+
+function cleanupInstallArtifacts() {
+  removePathIfExists(path.join(INSTALL_BIN_DIR, "baton-host"));
+  removePathIfExists(path.join(INSTALL_BIN_DIR, "cloudflared"));
+  removePathIfExists(INSTALL_BIN_DIR);
+  removePathIfExists(WRAPPER_PATH);
+  removePathIfExists(INSTALL_META_PATH);
+  removePathIfExists(INSTALL_LOG_DIR);
+
+  try {
+    const remaining = fs.existsSync(INSTALL_ROOT) ? fs.readdirSync(INSTALL_ROOT) : [];
+    if (remaining.length === 0) {
+      fs.rmdirSync(INSTALL_ROOT);
+    }
+  } catch {}
+}
+
+function readLinuxStatus() {
+  const installed = fs.existsSync(getLinuxUnitPath());
+  const enabledResult = installed
+    ? runCommand("systemctl", ["--user", "is-enabled", getLinuxServiceName()], { allowFailure: true })
+    : { stdout: "", status: 1 };
+  const activeResult = installed
+    ? runCommand("systemctl", ["--user", "is-active", getLinuxServiceName()], { allowFailure: true })
+    : { stdout: "", status: 1 };
+
+  const enabledState = (enabledResult.stdout || "").trim();
+  const activeState = (activeResult.stdout || "").trim();
+
+  return {
+    installed,
+    loaded: installed && ["enabled", "enabled-runtime", "static", "indirect"].includes(enabledState),
+    running: activeState === "active",
+    detail: activeState || enabledState || "not installed",
+    serviceFile: getLinuxUnitPath()
+  };
+}
+
+function readMacStatus() {
+  const plistPath = getMacPlistPath();
+  const installed = fs.existsSync(plistPath);
+  const printResult = installed
+    ? runCommand("launchctl", ["print", `gui/${process.getuid()}/${SERVICE_LABEL}`], { allowFailure: true })
+    : { stdout: "", stderr: "", status: 1 };
+
+  const output = `${printResult.stdout || ""}\n${printResult.stderr || ""}`;
+  const pidMatch = output.match(/\bpid = (\d+)/);
+  const stateMatch = output.match(/\bstate = ([^\n]+)/);
+
+  return {
+    installed,
+    loaded: installed && printResult.status === 0,
+    running: installed && printResult.status === 0 && !!pidMatch && pidMatch[1] !== "0",
+    detail: stateMatch ? stateMatch[1].trim() : (printResult.status === 0 ? "loaded" : "not loaded"),
+    serviceFile: plistPath
+  };
+}
+
+function printServiceStatus() {
+  const meta = readInstallMeta();
+  const envVars = readEnvFile();
+  const platformStatus = process.platform === "linux" ? readLinuxStatus() : readMacStatus();
+
+  console.log("Baton Host Service Status");
+  console.log("");
+  console.log(`Installed: ${platformStatus.installed ? "yes" : "no"}`);
+  console.log(`Loaded: ${platformStatus.loaded ? "yes" : "no"}`);
+  console.log(`Running: ${platformStatus.running ? "yes" : "no"}`);
+  console.log(`State: ${platformStatus.detail}`);
+  if (meta?.version) {
+    console.log(`Version: ${meta.version}`);
+  }
+  console.log(`Mode: ${envVars.BATON_BRIDGE_MODE || "lan"}`);
+  console.log(`Port: ${envVars.PORT || "9966"}`);
+  console.log(`Log profile: ${envVars.BRIDGE_LOG_PROFILE || "core"}`);
+  console.log(`Binary: ${path.join(INSTALL_BIN_DIR, "baton-host")}`);
+  console.log(`Env file: ${ENV_FILE_PATH}`);
+  console.log(`Service file: ${platformStatus.serviceFile}`);
+}
+
+function ensureSupportedServicePlatform() {
+  if (!["linux", "darwin"].includes(process.platform)) {
+    fail(`当前平台不支持 service 子命令: ${process.platform}`);
+  }
+}
+
+async function handleServiceInstall(options = {}) {
+  ensureSupportedServicePlatform();
+
+  const { preserveConfig = false } = options;
+  const previousVersion = readInstallMeta()?.version || null;
+  const { binaryPath, cloudflaredPath, version } = resolveBundledAssets();
+
+  ensureDir(INSTALL_ROOT);
+  ensureDir(INSTALL_BIN_DIR);
+  ensureDir(INSTALL_LOG_DIR);
+  ensureDefaultEnvFile();
+
+  if (preserveConfig) {
+    const envVars = readEnvFile();
+    if (!envVars.BATON_BRIDGE_MODE || !envVars.PORT) {
+      fail("现有配置不完整，无法直接 upgrade。请先执行 npx baton-host@latest service install");
+    }
+  } else {
+    const mode = await promptBridgeModeForInstall();
+    const port = await promptPortForInstall();
+    writeEnvFile({
+      BATON_BRIDGE_MODE: mode,
+      PORT: String(port)
+    });
+  }
+
+  copyExecutable(binaryPath, path.join(INSTALL_BIN_DIR, "baton-host"));
+  copyExecutable(cloudflaredPath, path.join(INSTALL_BIN_DIR, "cloudflared"));
+  writeWrapperScript();
+  writeInstallMeta(version);
+
+  const serviceFile = process.platform === "linux" ? installLinuxService() : installMacService();
+  const action = preserveConfig
+    ? (previousVersion && previousVersion !== version ? "升级并重启" : "覆盖并重启")
+    : (previousVersion ? "覆盖并重启" : "安装并启动");
+
+  console.log(`✅ Baton Host 服务已${action}`);
+  console.log(`Version: ${version}`);
+  console.log(`Env file: ${ENV_FILE_PATH}`);
+  console.log(`Service file: ${serviceFile}`);
+  await runBridgePrintCommand();
+}
+
+async function handleServiceRestart() {
+  ensureSupportedServicePlatform();
+  if (process.platform === "linux") {
+    restartLinuxService();
+  } else {
+    restartMacService();
+  }
+  console.log("✅ Baton Host 服务已重启");
+  await runBridgePrintCommand();
+}
+
+function handleServiceUninstall() {
+  ensureSupportedServicePlatform();
+  if (process.platform === "linux") {
+    uninstallLinuxService();
+  } else {
+    uninstallMacService();
+  }
+  cleanupInstallArtifacts();
+  console.log("✅ Baton Host 服务已卸载");
+  console.log(`保留配置文件: ${ENV_FILE_PATH}`);
+}
+
+function printServiceUsage() {
+  console.log("Usage:");
+  console.log("  npx baton-host@latest service install");
+  console.log("  npx baton-host@latest service upgrade");
+  console.log("  npx baton-host@latest service restart");
+  console.log("  npx baton-host@latest service status");
+  console.log("  npx baton-host@latest service uninstall");
+  console.log("  npx baton-host@latest service help");
+  console.log("");
+  console.log("配置文件: ~/.baton-host/.env");
+  console.log("  BATON_BRIDGE_MODE=lan|tailscale|cloudflare");
+  console.log("  PORT=9966");
+  console.log("");
+  console.log("说明: install 会进入模式/端口向导；upgrade 复用现有配置并重启服务");
+}
+
+async function handleServiceCommand(args) {
+  const command = args[0] || "install";
+
+  if (command === "install") {
+    await handleServiceInstall();
+    return;
+  }
+
+  if (command === "upgrade") {
+    await handleServiceInstall({ preserveConfig: true });
+    return;
+  }
+
+  if (command === "restart") {
+    await handleServiceRestart();
+    return;
+  }
+
+  if (command === "status") {
+    printServiceStatus();
+    return;
+  }
+
+  if (command === "uninstall") {
+    handleServiceUninstall();
+    return;
+  }
+
+  if (command === "help" || command === "--help" || command === "-h") {
+    printServiceUsage();
+    return;
+  }
+
+  printServiceUsage();
+  process.exit(1);
+}
+
+function spawnHostBinary(args) {
+  const { binaryPath, cloudflaredPath } = resolveBundledAssets();
+  const child = spawn(binaryPath, args, {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      BATON_CLOUDFLARED_BIN: cloudflaredPath
+    }
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 0);
+  });
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args[0] === "service") {
+    await handleServiceCommand(args.slice(1));
+    return;
+  }
+  spawnHostBinary(args);
+}
+
+void main().catch((error) => {
+  fail(error instanceof Error ? error.message : String(error));
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baton-host",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Baton Bridge Host CLI（二进制分发入口）",
   "license": "MIT",
   "bin": {
@@ -10,9 +10,9 @@
     "bin"
   ],
   "optionalDependencies": {
-    "baton-host-darwin-arm64": "0.1.5",
-    "baton-host-darwin-x64": "0.1.5",
-    "baton-host-linux-arm64": "0.1.5",
-    "baton-host-linux-x64": "0.1.5"
+    "baton-host-darwin-arm64": "0.1.7",
+    "baton-host-darwin-x64": "0.1.7",
+    "baton-host-linux-arm64": "0.1.7",
+    "baton-host-linux-x64": "0.1.7"
   }
 }