baton-host 0.1.4 → 0.1.6

package/bin/baton-host.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 
-const { spawn } = require("node:child_process");
+const { spawn, spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const os = require("node:os");
 const path = require("node:path");
 
 const mapping = {
@@ -10,37 +12,566 @@ 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 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;
+}
+
+function resolveBundledAssets() {
+  const key = getCurrentPlatformKey();
+  const pkg = mapping[key];
+
+  if (!pkg) {
+    fail(`当前平台暂不支持: ${key}`);
+  }
+
+  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()
+  };
 }
 
-const bundledCloudflaredPath = path.join(path.dirname(binaryPath), process.platform === "win32" ? "cloudflared.exe" : "cloudflared");
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function copyExecutable(sourcePath, targetPath) {
+  fs.copyFileSync(sourcePath, targetPath);
+  fs.chmodSync(targetPath, 0o755);
+}
 
-const child = spawn(binaryPath, process.argv.slice(2), {
-  stdio: "inherit",
-  env: {
-    ...process.env,
-    BATON_CLOUDFLARED_BIN: bundledCloudflaredPath
+function readInstallMeta() {
+  if (!fs.existsSync(INSTALL_META_PATH)) {
+    return null;
   }
-});
 
-child.on("exit", (code, signal) => {
-  if (signal) {
-    process.kill(process.pid, signal);
+  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=lan",
+    "BRIDGE_LOG_PROFILE=core",
+    "PORT=9966",
+    ""
+  ].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 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}`);
+  }
+}
+
+function handleServiceInstall() {
+  ensureSupportedServicePlatform();
+
+  const previousVersion = readInstallMeta()?.version || null;
+  const { binaryPath, cloudflaredPath, version } = resolveBundledAssets();
+
+  ensureDir(INSTALL_ROOT);
+  ensureDir(INSTALL_BIN_DIR);
+  ensureDir(INSTALL_LOG_DIR);
+
+  copyExecutable(binaryPath, path.join(INSTALL_BIN_DIR, "baton-host"));
+  copyExecutable(cloudflaredPath, path.join(INSTALL_BIN_DIR, "cloudflared"));
+  ensureDefaultEnvFile();
+  writeWrapperScript();
+  writeInstallMeta(version);
+
+  const serviceFile = process.platform === "linux" ? installLinuxService() : installMacService();
+  const action = previousVersion && previousVersion !== version
+    ? "升级并重启"
+    : previousVersion
+      ? "覆盖并重启"
+      : "安装并启动";
+
+  console.log(`✅ Baton Host 服务已${action}`);
+  console.log(`Version: ${version}`);
+  console.log(`Binary: ${path.join(INSTALL_BIN_DIR, "baton-host")}`);
+  console.log(`Env file: ${ENV_FILE_PATH}`);
+  console.log(`Service file: ${serviceFile}`);
+}
+
+function handleServiceRestart() {
+  ensureSupportedServicePlatform();
+  if (process.platform === "linux") {
+    restartLinuxService();
+  } else {
+    restartMacService();
+  }
+  console.log("✅ Baton Host 服务已重启");
+}
+
+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 都会覆盖二进制并重启服务");
+}
+
+function handleServiceCommand(args) {
+  const command = args[0] || "install";
+
+  if (command === "install" || command === "upgrade") {
+    handleServiceInstall();
+    return;
+  }
+
+  if (command === "restart") {
+    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);
+  });
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  if (args[0] === "service") {
+    handleServiceCommand(args.slice(1));
+    return;
+  }
+  spawnHostBinary(args);
+}
+
+try {
+  main();
+} catch (error) {
+  fail(error instanceof Error ? error.message : String(error));
+}

package/package.json

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