@modelzen/feishu-codex-bridge 0.2.1 → 0.2.2-win

package/dist/cli.js

@@ -15,7 +15,6 @@ function bridgeVersion() {
 }
 
 // src/cli/commands/doctor.ts
-import { execFileSync as execFileSync2 } from "child_process";
 import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join4 } from "path";
@@ -269,27 +268,56 @@ async function moveIfExists(src, dest) {
 }
 
 // src/agent/codex-appserver/locate.ts
-import { execFileSync } from "child_process";
 import { existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
+import { extname, join as join3 } from "path";
+
+// src/platform/spawn.ts
+import crossSpawn from "cross-spawn";
+function spawnProcess(command, args = [], options = {}) {
+  return crossSpawn(command, [...args], options);
+}
+function spawnProcessSync(command, args = [], options = {}) {
+  return crossSpawn.sync(command, [...args], options);
+}
+function mergeProcessEnv(base = process.env, overrides = {}) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(overrides)) {
+    for (const existing of Object.keys(out)) {
+      if (existing.toLowerCase() === key.toLowerCase()) delete out[existing];
+    }
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+
+// src/agent/codex-appserver/locate.ts
+var IS_WIN = process.platform === "win32";
 function resolveCodexBin() {
   const env = process.env.CODEX_BIN;
   if (env && existsSync2(env)) return env;
   const onPath = which("codex");
   if (onPath) return onPath;
-  const priv = join3(paths.codexCliBinDir, "codex");
-  if (existsSync2(priv)) return priv;
+  for (const cand of execCandidates(paths.codexCliBinDir, "codex")) {
+    if (existsSync2(cand)) return cand;
+  }
   const appBundle = "/Applications/Codex.app/Contents/Resources/codex";
   if (process.platform === "darwin" && existsSync2(appBundle)) return appBundle;
   return null;
 }
+function execCandidates(dir, base) {
+  const exact = join3(dir, base);
+  if (!IS_WIN || extname(base)) return [exact];
+  const exts = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((e) => e.trim()).filter(Boolean);
+  return [exact, ...exts.map((e) => join3(dir, base + e.toLowerCase()))];
+}
 function which(cmd) {
   try {
-    const out = execFileSync(process.platform === "win32" ? "where" : "which", [cmd], {
+    const res = spawnProcessSync(IS_WIN ? "where" : "which", [cmd], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
-    const first = out.split("\n").map((l) => l.trim()).find(Boolean);
+    if (res.status !== 0 || typeof res.stdout !== "string") return null;
+    const first = res.stdout.split("\n").map((l) => l.trim()).find(Boolean);
     return first && existsSync2(first) ? first : null;
   } catch {
     return null;
@@ -297,7 +325,9 @@ function which(cmd) {
 }
 function codexVersion(bin) {
   try {
-    return execFileSync(bin, ["--version"], { encoding: "utf8" }).trim();
+    const res = spawnProcessSync(bin, ["--version"], { encoding: "utf8" });
+    if (res.status !== 0 || typeof res.stdout !== "string") return null;
+    return res.stdout.trim();
   } catch {
     return null;
   }
@@ -355,7 +385,9 @@ ${failed === 0 ? "\u5168\u90E8\u901A\u8FC7 \u2713" : `${failed} \u9879\u9700\u59
 }
 function tryExec(cmd, args) {
   try {
-    return execFileSync2(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const res = spawnProcessSync(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    if (res.status !== 0 || typeof res.stdout !== "string") return null;
+    return res.stdout.trim();
   } catch {
     return null;
   }
@@ -538,7 +570,7 @@ async function spawnExecProvider(pc, ref) {
   const timeoutMs = pc.noOutputTimeoutMs ?? DEFAULT_EXEC_TIMEOUT_MS;
   const maxOutput = pc.maxOutputBytes ?? DEFAULT_EXEC_MAX_OUTPUT;
   const providerName = ref.provider ?? DEFAULT_PROVIDER;
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const env = {};
     if (pc.passEnv) for (const k of pc.passEnv) {
       const v = process.env[k];
@@ -583,7 +615,7 @@ async function spawnExecProvider(pc, ref) {
       try {
         const parsed = JSON.parse(stdout);
         const value = parsed.values?.[ref.id];
-        if (typeof value === "string") return resolve6(value);
+        if (typeof value === "string") return resolve7(value);
         const err = parsed.errors?.[ref.id]?.message;
         reject(new Error(`exec provider did not return secret for ${ref.id}${err ? `: ${err}` : ""}`));
       } catch (err) {
@@ -1131,7 +1163,6 @@ ${rule}`);
 import { createLarkChannel, Domain } from "@larksuiteoapi/node-sdk";
 
 // src/agent/codex-appserver/app-server-client.ts
-import { spawn as spawn3 } from "child_process";
 var AsyncQueue = class {
   items = [];
   waiters = [];
@@ -1152,7 +1183,7 @@ var AsyncQueue = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve6) => this.waiters.push(resolve6));
+      const next = await new Promise((resolve7) => this.waiters.push(resolve7));
       if (next.done) return;
       yield next.value;
     }
@@ -1174,9 +1205,9 @@ var AppServerClient = class {
   }
   /** spawn + initialize handshake. Throws if spawn/handshake fails. */
   async connect() {
-    const child = spawn3(this.opts.bin, ["app-server", "--listen", "stdio://"], {
+    const child = spawnProcess(this.opts.bin, ["app-server", "--listen", "stdio://"], {
       cwd: this.opts.cwd,
-      env: { ...process.env, ...this.opts.env, FEISHU_CODEX_BRIDGE: "1" },
+      env: mergeProcessEnv(process.env, { ...this.opts.env, FEISHU_CODEX_BRIDGE: "1" }),
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.child = child;
@@ -1203,8 +1234,8 @@ var AppServerClient = class {
     const id = ++this.nextId;
     const payload = `${JSON.stringify({ jsonrpc: "2.0", id, method, params: params ?? {} })}
 `;
-    return new Promise((resolve6, reject) => {
-      this.pending.set(id, { resolve: resolve6, reject });
+    return new Promise((resolve7, reject) => {
+      this.pending.set(id, { resolve: resolve7, reject });
       this.child.stdin.write(payload, (err) => {
         if (err) {
           this.pending.delete(id);
@@ -1227,15 +1258,36 @@ var AppServerClient = class {
     this.closed = true;
     const child = this.child;
     if (!child || child.exitCode !== null) return;
+    if (process.platform === "win32" && child.pid) {
+      await new Promise((resolve7) => {
+        let settled = false;
+        const done = () => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(t);
+          resolve7();
+        };
+        const t = setTimeout(done, graceMs);
+        child.once("exit", done);
+        spawnProcess("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" }).on(
+          "error",
+          () => {
+            child.kill();
+            done();
+          }
+        );
+      });
+      return;
+    }
     child.kill("SIGTERM");
-    await new Promise((resolve6) => {
+    await new Promise((resolve7) => {
       const t = setTimeout(() => {
         if (child.exitCode === null) child.kill("SIGKILL");
-        resolve6();
+        resolve7();
       }, graceMs);
       child.once("exit", () => {
         clearTimeout(t);
-        resolve6();
+        resolve7();
       });
     });
   }
@@ -1368,12 +1420,12 @@ var BRIDGE_DEVELOPER_INSTRUCTIONS = [
 ].join("\n");
 var READ_HISTORY_TIMEOUT_MS = 2e4;
 function withDeadline(p, ms, label) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const t = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
     p.then(
       (v) => {
         clearTimeout(t);
-        resolve6(v);
+        resolve7(v);
       },
       (e) => {
         clearTimeout(t);
@@ -1413,11 +1465,11 @@ var CodexThread = class {
       if (self.model) params.model = self.model;
       if (self.effort) params.effort = self.effort;
       let startError;
-      const startFailed = new Promise((resolve6) => {
+      const startFailed = new Promise((resolve7) => {
         self.client.request("turn/start", params).then(void 0, (err) => {
           startError = err instanceof Error ? err : new Error(String(err));
           log.fail("agent", startError, { phase: "turn/start" });
-          resolve6("start-failed");
+          resolve7("start-failed");
         });
       });
       const stream2 = self.client.stream()[Symbol.asyncIterator]();
@@ -2907,7 +2959,7 @@ function structureSig(card2, eid) {
 
 // src/card/outbound-images.ts
 import { readFile as readFile5, stat as stat2 } from "fs/promises";
-import { extname, isAbsolute, resolve as resolve2, sep } from "path";
+import { extname as extname2, isAbsolute, resolve as resolve2, sep } from "path";
 var MAX_IMAGES = 9;
 var MAX_BYTES = 10 * 1024 * 1024;
 var DOWNLOAD_TIMEOUT_MS = 1e4;
@@ -2973,7 +3025,7 @@ async function loadLocal(src, cwd) {
     log.warn("outbound", "image-outside-cwd", { src: src.slice(0, 80) });
     return { cacheKey: `local:${abs}` };
   }
-  const ext = extname(abs).slice(1).toLowerCase();
+  const ext = extname2(abs).slice(1).toLowerCase();
   if (!ALLOWED_EXT.has(ext)) {
     log.warn("outbound", "image-ext", { ext, src: src.slice(0, 80) });
     return { cacheKey: `local:${abs}` };
@@ -3504,39 +3556,106 @@ function buildGroupSettingsCard(project) {
 }
 
 // src/service/update.ts
-import { execFile, spawn as spawn5 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname7, join as join8, resolve as resolve4 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { execFile, spawn as spawn4 } from "child_process";
+import { existsSync as existsSync7, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname10, join as join11, resolve as resolve5 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 import { promisify } from "util";
 
 // src/service/launchd.ts
-import { spawn as spawn4, spawnSync } from "child_process";
+import { spawn as spawn3, spawnSync } from "child_process";
 import { existsSync as existsSync4 } from "fs";
-import { appendFile, mkdir as mkdir5, rm as rm2, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir6, rm as rm2, writeFile as writeFile5 } from "fs/promises";
 import { homedir as homedir3, userInfo as userInfo2 } from "os";
+import { dirname as dirname7, join as join8, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/service/common.ts
+import { createReadStream, statSync } from "fs";
+import { appendFile, mkdir as mkdir5, readFile as readFile7 } from "fs/promises";
 import { dirname as dirname6, join as join7, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var LAUNCHD_LABEL = "ai.feishu-codex-bridge.bot";
-function launchAgentPlistPath() {
-  return join7(homedir3(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-}
 function serviceStdoutPath() {
   return join7(paths.appDir, "service.log");
 }
 function serviceStderrPath() {
   return join7(paths.appDir, "service.err.log");
 }
+async function ensureLogFiles() {
+  await mkdir5(paths.appDir, { recursive: true });
+  await appendFile(serviceStdoutPath(), "");
+  await appendFile(serviceStderrPath(), "");
+}
 function resolveCliBinPath() {
   const distDir = dirname6(fileURLToPath2(import.meta.url));
   return resolve3(distDir, "..", "bin", "feishu-codex-bridge.mjs");
 }
+async function tailServiceLogs(follow) {
+  await ensureLogFiles();
+  const files = [serviceStdoutPath(), serviceStderrPath()];
+  for (const f of files) {
+    const tail = await lastLines(f, 100);
+    if (tail) process.stdout.write(`
+===== ${f} =====
+${tail}
+`);
+  }
+  if (!follow) return;
+  const offsets = new Map(files.map((f) => [f, fileSize(f)]));
+  await new Promise((resolvePromise) => {
+    const onSigint = () => {
+      clearInterval(timer);
+      process.off("SIGINT", onSigint);
+      resolvePromise();
+    };
+    process.on("SIGINT", onSigint);
+    const timer = setInterval(() => {
+      for (const f of files) {
+        const size = fileSize(f);
+        const from = offsets.get(f) ?? 0;
+        if (size > from) {
+          offsets.set(f, size);
+          createReadStream(f, { start: from, end: size - 1, encoding: "utf8" }).pipe(process.stdout, {
+            end: false
+          });
+        } else if (size < from) {
+          offsets.set(f, size);
+        }
+      }
+    }, 700);
+  });
+}
+function fileSize(file) {
+  try {
+    return statSync(file).size;
+  } catch {
+    return 0;
+  }
+}
+async function lastLines(file, n) {
+  try {
+    const text = await readFile7(file, "utf8");
+    return text.split("\n").slice(-n - 1).join("\n").trimEnd();
+  } catch {
+    return "";
+  }
+}
+
+// src/service/launchd.ts
+var LAUNCHD_LABEL = "ai.feishu-codex-bridge.bot";
+function launchAgentPlistPath() {
+  return join8(homedir3(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+}
+function resolveCliBinPath2() {
+  const distDir = dirname7(fileURLToPath3(import.meta.url));
+  return resolve4(distDir, "..", "bin", "feishu-codex-bridge.mjs");
+}
 function escapeXml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 function buildPlist() {
   const nodePath = process.execPath;
-  const cliBinPath = resolveCliBinPath();
+  const cliBinPath = resolveCliBinPath2();
   const pathEnv = process.env.PATH ?? "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/sbin";
   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">
@@ -3569,7 +3688,7 @@ function buildPlist() {
 }
 async function installLaunchd() {
   const plistPath = launchAgentPlistPath();
-  await mkdir5(dirname6(plistPath), { recursive: true });
+  await mkdir6(dirname7(plistPath), { recursive: true });
   await ensureLogFiles();
   await writeFile5(plistPath, buildPlist(), "utf8");
   if (isLoaded()) {
@@ -3607,9 +3726,10 @@ function statusLaunchd() {
   const raw = result.stdout || result.stderr;
   const parsed = parseLaunchdStatus(raw);
   return {
+    platformName: "launchd (macOS)",
     installed: existsSync4(launchAgentPlistPath()),
-    loaded: result.ok,
-    plistPath: launchAgentPlistPath(),
+    running: result.ok,
+    servicePath: launchAgentPlistPath(),
     stdoutPath: serviceStdoutPath(),
     stderrPath: serviceStderrPath(),
     pid: parsed.pid,
@@ -3621,7 +3741,7 @@ async function tailLaunchdLogs(follow) {
   await ensureLogFiles();
   const args = follow ? ["-f", serviceStdoutPath(), serviceStderrPath()] : ["-n", "100", serviceStdoutPath(), serviceStderrPath()];
   await new Promise((resolvePromise, reject) => {
-    const child = spawn4("tail", args, { stdio: "inherit" });
+    const child = spawn3("tail", args, { stdio: "inherit" });
     child.on("error", reject);
     child.on("close", (code) => {
       if (code === 0 || follow && code === null) {
@@ -3652,11 +3772,6 @@ async function waitUntilUnloaded(timeoutMs = 5e3) {
   }
   throw new Error(`launchd service \u672A\u5728 ${timeoutMs}ms \u5185\u5378\u8F7D\u5B8C\u6210`);
 }
-async function ensureLogFiles() {
-  await mkdir5(paths.appDir, { recursive: true });
-  await appendFile(serviceStdoutPath(), "");
-  await appendFile(serviceStderrPath(), "");
-}
 function userTarget() {
   return `gui/${userInfo2().uid}`;
 }
@@ -3677,29 +3792,291 @@ function launchctlError(command, result) {
   return new Error(`${command} \u5931\u8D25\uFF08exit ${result.status ?? "unknown"}\uFF09${output ? `\uFF1A${output}` : ""}`);
 }
 
-// src/service/adapter.ts
-function getServiceAdapter() {
-  if (process.platform !== "darwin") {
-    throw new Error("service\uFF1A\u5F53\u524D\u5E73\u53F0\u6682\u4E0D\u652F\u6301\uFF0C\u540E\u7EED\u4F1A\u652F\u6301 Windows/systemd\u3002");
+// src/service/schtasks.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir7, rm as rm3, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname8, join as join9 } from "path";
+var WINDOWS_TASK_NAME = "feishu-codex-bridge";
+function launcherCmdPath() {
+  return join9(paths.appDir, "service-launcher.cmd");
+}
+function buildLauncherCmd() {
+  const nodePath = process.execPath;
+  const cliBinPath = resolveCliBinPath();
+  const pathEnv = process.env.PATH ?? "";
+  return [
+    "@echo off",
+    `set "PATH=${pathEnv}"`,
+    `"${nodePath}" "${cliBinPath}" run >> "${serviceStdoutPath()}" 2>> "${serviceStderrPath()}"`,
+    ""
+  ].join("\r\n");
+}
+function runSchtasks(args) {
+  const r = spawnSync2("schtasks", args, { encoding: "utf8" });
+  return {
+    ok: r.status === 0,
+    status: r.status,
+    stdout: r.stdout ?? "",
+    stderr: r.stderr ?? ""
+  };
+}
+function schtasksError(command, r) {
+  const out = [r.stderr.trim(), r.stdout.trim()].filter(Boolean).join("\n");
+  return new Error(`${command} \u5931\u8D25\uFF08exit ${r.status ?? "unknown"}\uFF09${out ? `\uFF1A${out}` : ""}`);
+}
+async function writeLauncherCmd() {
+  const cmdPath = launcherCmdPath();
+  await mkdir7(dirname8(cmdPath), { recursive: true });
+  await ensureLogFiles();
+  await writeFile6(cmdPath, buildLauncherCmd(), "utf8");
+}
+async function installSchtask() {
+  await writeLauncherCmd();
+  const create = runSchtasks([
+    "/Create",
+    "/F",
+    "/SC",
+    "ONLOGON",
+    "/RL",
+    "LIMITED",
+    "/TN",
+    WINDOWS_TASK_NAME,
+    "/TR",
+    `"${launcherCmdPath()}"`
+  ]);
+  if (!create.ok) throw schtasksError("schtasks /Create", create);
+  const run = runSchtasks(["/Run", "/TN", WINDOWS_TASK_NAME]);
+  if (!run.ok) throw schtasksError("schtasks /Run", run);
+  return statusSchtask();
+}
+async function uninstallSchtask() {
+  runSchtasks(["/End", "/TN", WINDOWS_TASK_NAME]);
+  const del = runSchtasks(["/Delete", "/F", "/TN", WINDOWS_TASK_NAME]);
+  if (!del.ok && isTaskRegistered()) throw schtasksError("schtasks /Delete", del);
+  if (existsSync5(launcherCmdPath())) await rm3(launcherCmdPath(), { force: true });
+}
+async function restartSchtask() {
+  if (!isTaskRegistered()) {
+    throw new Error(`\u8BA1\u5212\u4EFB\u52A1\u672A\u5B89\u88C5\uFF1A${WINDOWS_TASK_NAME}\uFF08\u5148\u8FD0\u884C \`feishu-codex-bridge start\`\uFF09`);
+  }
+  runSchtasks(["/End", "/TN", WINDOWS_TASK_NAME]);
+  await waitUntilStopped();
+  const run = runSchtasks(["/Run", "/TN", WINDOWS_TASK_NAME]);
+  if (!run.ok) throw schtasksError("schtasks /Run", run);
+  return statusSchtask();
+}
+function statusSchtask() {
+  const installed = isTaskRegistered();
+  const raw = installed ? describeTask() : "";
+  return {
+    platformName: "Task Scheduler (Windows)",
+    installed,
+    running: installed && /Status:\s+Running/i.test(raw),
+    servicePath: WINDOWS_TASK_NAME,
+    stdoutPath: serviceStdoutPath(),
+    stderrPath: serviceStderrPath(),
+    // `Process ID:` only appears in verbose output while the task is running.
+    pid: raw.match(/Process ID:\s*(\d+)/i)?.[1],
+    // `Last Result: 0` ⇒ last run succeeded. Surface it as the exit code.
+    lastExit: raw.match(/Last Result:\s*(-?\d+)/i)?.[1],
+    raw
+  };
+}
+function isTaskRegistered() {
+  const r = spawnSync2("schtasks", ["/Query", "/TN", WINDOWS_TASK_NAME], {
+    stdio: ["ignore", "ignore", "ignore"]
+  });
+  return r.status === 0;
+}
+function schtaskRunning() {
+  if (!isTaskRegistered()) return false;
+  return /Status:\s+Running/i.test(describeTask());
+}
+function describeTask() {
+  const r = runSchtasks(["/Query", "/V", "/FO", "LIST", "/TN", WINDOWS_TASK_NAME]);
+  return r.stdout || r.stderr || "";
+}
+async function waitUntilStopped(timeoutMs = 5e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!schtaskRunning()) return true;
+    await new Promise((r) => setTimeout(r, 200));
   }
+  return false;
+}
+
+// src/service/systemd.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir8, rm as rm4, writeFile as writeFile7 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname9, join as join10 } from "path";
+var SYSTEMD_UNIT_NAME = "feishu-codex-bridge.service";
+function systemdUnitPath() {
+  const base = process.env.XDG_CONFIG_HOME ?? join10(homedir4(), ".config");
+  return join10(base, "systemd", "user", SYSTEMD_UNIT_NAME);
+}
+function buildUnit() {
+  const esc = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const nodePath = process.execPath;
+  const cliBinPath = resolveCliBinPath();
+  const pathEnv = process.env.PATH ?? "";
+  return `[Unit]
+Description=feishu-codex-bridge bot
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart="${esc(nodePath)}" "${esc(cliBinPath)}" run
+Restart=always
+RestartSec=5
+StandardOutput=append:${serviceStdoutPath()}
+StandardError=append:${serviceStderrPath()}
+Environment="PATH=${esc(pathEnv)}"
+
+[Install]
+WantedBy=default.target
+`;
+}
+function runSystemctl(args) {
+  const r = spawnSync3("systemctl", ["--user", ...args], { encoding: "utf8" });
   return {
-    install: installLaunchd,
-    uninstall: uninstallLaunchd,
-    status: async () => statusLaunchd(),
-    restart: restartLaunchd,
-    logs: tailLaunchdLogs
+    ok: r.status === 0,
+    status: r.status,
+    stdout: r.stdout ?? "",
+    stderr: (r.error ? `${r.error.message}
+` : "") + (r.stderr ?? "")
+  };
+}
+function systemctlError(command, r) {
+  const out = [r.stderr.trim(), r.stdout.trim()].filter(Boolean).join("\n");
+  return new Error(`${command} \u5931\u8D25\uFF08exit ${r.status ?? "unknown"}\uFF09${out ? `\uFF1A${out}` : ""}`);
+}
+function systemdAvailable() {
+  const r = spawnSync3("systemctl", ["--user", "is-system-running"], { encoding: "utf8" });
+  if (r.error) return false;
+  const out = `${r.stdout ?? ""}${r.stderr ?? ""}`;
+  return !/not been booted with systemd|Failed to connect to (the )?bus|Failed to (connect|get) D-?Bus/i.test(out);
+}
+function ensureSystemdOrThrow() {
+  if (systemdAvailable()) return;
+  throw new Error(
+    "\u672A\u68C0\u6D4B\u5230\u53EF\u7528\u7684\u7528\u6237\u7EA7 systemd\u3002WSL \u9700\u5728 /etc/wsl.conf \u5199\u5165 `[boot]\\nsystemd=true` \u540E\u6267\u884C `wsl --shutdown` \u91CD\u542F\uFF1B\u6216\u76F4\u63A5\u7528 `feishu-codex-bridge run` \u524D\u53F0\u8FD0\u884C\uFF08\u65E0\u9700\u540E\u53F0\u670D\u52A1\uFF09\u3002"
+  );
+}
+async function installSystemd() {
+  ensureSystemdOrThrow();
+  const unitPath = systemdUnitPath();
+  await mkdir8(dirname9(unitPath), { recursive: true });
+  await ensureLogFiles();
+  await writeFile7(unitPath, buildUnit(), "utf8");
+  const reload = runSystemctl(["daemon-reload"]);
+  if (!reload.ok) throw systemctlError("systemctl --user daemon-reload", reload);
+  const enable = runSystemctl(["enable", "--now", SYSTEMD_UNIT_NAME]);
+  if (!enable.ok) throw systemctlError("systemctl --user enable --now", enable);
+  return statusSystemd();
+}
+async function uninstallSystemd() {
+  if (systemdAvailable() && unitExists()) {
+    runSystemctl(["disable", "--now", SYSTEMD_UNIT_NAME]);
+  }
+  await rm4(systemdUnitPath(), { force: true });
+  if (systemdAvailable()) runSystemctl(["daemon-reload"]);
+}
+async function restartSystemd() {
+  ensureSystemdOrThrow();
+  if (!unitExists()) {
+    throw new Error(`systemd unit \u672A\u5B89\u88C5\uFF1A${systemdUnitPath()}\uFF08\u5148\u8FD0\u884C \`feishu-codex-bridge start\`\uFF09`);
+  }
+  const restart = runSystemctl(["restart", SYSTEMD_UNIT_NAME]);
+  if (!restart.ok) throw systemctlError("systemctl --user restart", restart);
+  return statusSystemd();
+}
+function statusSystemd() {
+  const installed = unitExists();
+  const raw = installed && systemdAvailable() ? describeService() : "";
+  return {
+    platformName: "systemd (Linux user)",
+    installed,
+    running: systemdActive(),
+    servicePath: systemdUnitPath(),
+    stdoutPath: serviceStdoutPath(),
+    stderrPath: serviceStderrPath(),
+    pid: raw.match(/Main PID:\s*(\d+)/)?.[1],
+    // On an inactive unit the "Process: <pid> ExecStart=... status=<n>" line
+    // carries the last exit code.
+    lastExit: raw.match(/Process:\s+\d+\s+ExecStart=.*status=(\d+)/)?.[1],
+    raw
   };
 }
+function unitExists() {
+  return existsSync6(systemdUnitPath());
+}
+function systemdActive() {
+  const r = spawnSync3("systemctl", ["--user", "is-active", SYSTEMD_UNIT_NAME], {
+    stdio: ["ignore", "ignore", "ignore"]
+  });
+  return r.status === 0;
+}
+function describeService() {
+  const r = runSystemctl(["status", SYSTEMD_UNIT_NAME, "--no-pager"]);
+  return r.stdout || r.stderr || "";
+}
+
+// src/service/adapter.ts
+function getServiceAdapter() {
+  if (process.platform === "darwin") {
+    return {
+      install: installLaunchd,
+      uninstall: uninstallLaunchd,
+      status: async () => statusLaunchd(),
+      restart: restartLaunchd,
+      logs: tailLaunchdLogs
+    };
+  }
+  if (process.platform === "win32") {
+    return {
+      install: installSchtask,
+      uninstall: uninstallSchtask,
+      status: async () => statusSchtask(),
+      restart: restartSchtask,
+      logs: tailServiceLogs
+    };
+  }
+  if (process.platform === "linux") {
+    return {
+      install: installSystemd,
+      uninstall: uninstallSystemd,
+      status: async () => statusSystemd(),
+      restart: restartSystemd,
+      logs: tailServiceLogs
+    };
+  }
+  throw new Error(
+    "service\uFF1A\u5F53\u524D\u5E73\u53F0\u6682\u4E0D\u652F\u6301\u540E\u53F0\u670D\u52A1\uFF08\u4EC5 macOS launchd / Windows \u8BA1\u5212\u4EFB\u52A1 / Linux systemd\uFF09\u3002\u8BF7\u7528 `feishu-codex-bridge run` \u524D\u53F0\u8FD0\u884C\u3002"
+  );
+}
+function isServiceRunning() {
+  try {
+    if (process.platform === "darwin") return isLoaded();
+    if (process.platform === "win32") return schtaskRunning();
+    if (process.platform === "linux") return systemdActive();
+  } catch {
+  }
+  return false;
+}
 
 // src/service/update.ts
 var execFileP = promisify(execFile);
 var NPM = process.platform === "win32" ? "npm.cmd" : "npm";
 function pkgRoot() {
-  return resolve4(dirname7(fileURLToPath3(import.meta.url)), "..");
+  return resolve5(dirname10(fileURLToPath4(import.meta.url)), "..");
 }
 function pkgJson() {
   try {
-    return JSON.parse(readFileSync2(join8(pkgRoot(), "package.json"), "utf8"));
+    return JSON.parse(readFileSync2(join11(pkgRoot(), "package.json"), "utf8"));
   } catch {
     return {};
   }
@@ -3711,7 +4088,7 @@ function packageName() {
   return pkgJson().name ?? "@modelzen/feishu-codex-bridge";
 }
 function isDevSource() {
-  return existsSync5(join8(pkgRoot(), ".git"));
+  return existsSync7(join11(pkgRoot(), ".git"));
 }
 function isNewer(a, b) {
   const pa = a.split(".").map((n) => Number.parseInt(n, 10) || 0);
@@ -3734,7 +4111,7 @@ async function latestVersion() {
 async function installLatest(opts = {}) {
   const target = `${packageName()}@latest`;
   return await new Promise((resolveP) => {
-    const child = spawn5(NPM, ["install", "-g", target], {
+    const child = spawn4(NPM, ["install", "-g", target], {
       stdio: opts.inherit ? ["ignore", "inherit", "inherit"] : ["ignore", "pipe", "pipe"]
     });
     let out = "";
@@ -3750,20 +4127,16 @@ async function installLatest(opts = {}) {
   });
 }
 function daemonRunning() {
-  try {
-    return statusLaunchd().loaded;
-  } catch {
-    return false;
-  }
+  return isServiceRunning();
 }
 async function restartDaemon() {
   await getServiceAdapter().restart();
 }
 
 // src/project/lifecycle.ts
-import { mkdir as mkdir6 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import { isAbsolute as isAbsolute2, join as join9, resolve as resolve5 } from "path";
+import { mkdir as mkdir9 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { isAbsolute as isAbsolute2, join as join12, resolve as resolve6 } from "path";
 
 // src/project/git-info.ts
 import { execFile as execFile2 } from "child_process";
@@ -3898,12 +4271,12 @@ async function onboardGroup(channel, project) {
 // src/project/lifecycle.ts
 async function resolveCwd(name, existingPath) {
   if (existingPath) {
-    const cwd2 = isAbsolute2(existingPath) ? existingPath : resolve5(existingPath);
-    if (!existsSync6(cwd2)) throw new Error(`\u6587\u4EF6\u5939\u4E0D\u5B58\u5728\uFF1A${cwd2}`);
+    const cwd2 = isAbsolute2(existingPath) ? existingPath : resolve6(existingPath);
+    if (!existsSync8(cwd2)) throw new Error(`\u6587\u4EF6\u5939\u4E0D\u5B58\u5728\uFF1A${cwd2}`);
     return { cwd: cwd2, blank: false };
   }
-  const cwd = join9(paths.projectsRootDir, name);
-  await mkdir6(cwd, { recursive: true });
+  const cwd = join12(paths.projectsRootDir, name);
+  await mkdir9(cwd, { recursive: true });
   return { cwd, blank: true };
 }
 async function createProject(channel, input2) {
@@ -3970,12 +4343,12 @@ async function leaveChat(channel, chatId) {
 }
 
 // src/bot/session-store.ts
-import { mkdir as mkdir7, readFile as readFile7, rename as rename5, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname8 } from "path";
+import { mkdir as mkdir10, readFile as readFile8, rename as rename5, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname11 } from "path";
 var FILE_VERSION3 = 1;
 async function read2() {
   try {
-    const text = await readFile7(paths.sessionsFile, "utf8");
+    const text = await readFile8(paths.sessionsFile, "utf8");
     const parsed = JSON.parse(text);
     return Array.isArray(parsed.sessions) ? parsed.sessions : [];
   } catch (err) {
@@ -3984,10 +4357,10 @@ async function read2() {
   }
 }
 async function write2(sessions) {
-  await mkdir7(dirname8(paths.sessionsFile), { recursive: true });
+  await mkdir10(dirname11(paths.sessionsFile), { recursive: true });
   const tmp = `${paths.sessionsFile}.tmp-${process.pid}`;
   const body = { version: FILE_VERSION3, sessions };
-  await writeFile6(tmp, `${JSON.stringify(body, null, 2)}
+  await writeFile8(tmp, `${JSON.stringify(body, null, 2)}
 `, "utf8");
   await rename5(tmp, paths.sessionsFile);
 }
@@ -4031,8 +4404,8 @@ async function handleDmConsole(channel, cfg, msg) {
 }
 
 // src/bot/media.ts
-import { mkdir as mkdir8, readdir as readdir2, rm as rm3, stat as stat3 } from "fs/promises";
-import { join as join10 } from "path";
+import { mkdir as mkdir11, readdir as readdir2, rm as rm5, stat as stat3 } from "fs/promises";
+import { join as join13 } from "path";
 var MAX_IMAGES2 = 9;
 var MEDIA_TTL_MS = 60 * 6e4;
 var EXT_BY_CONTENT_TYPE = {
@@ -4061,7 +4434,7 @@ async function collectInboundImages(channel, msg) {
   if (refs.length === 0) return [];
   await pruneOldMedia();
   try {
-    await mkdir8(paths.mediaDir, { recursive: true });
+    await mkdir11(paths.mediaDir, { recursive: true });
   } catch {
   }
   const out = [];
@@ -4137,7 +4510,7 @@ async function downloadOne(channel, ref, index) {
       params: { type: "image" }
     });
     const ext = extFromHeaders(res.headers);
-    const file = join10(paths.mediaDir, `${safeName(ref.fileKey)}-${index}.${ext}`);
+    const file = join13(paths.mediaDir, `${safeName(ref.fileKey)}-${index}.${ext}`);
     await res.writeFile(file);
     return file;
   } catch (err) {
@@ -4171,10 +4544,10 @@ async function pruneOldMedia() {
   }
   const cutoff = Date.now() - MEDIA_TTL_MS;
   for (const name of entries) {
-    const file = join10(paths.mediaDir, name);
+    const file = join13(paths.mediaDir, name);
     try {
       const st = await stat3(file);
-      if (st.mtimeMs < cutoff) await rm3(file, { force: true });
+      if (st.mtimeMs < cutoff) await rm5(file, { force: true });
     } catch {
     }
   }
@@ -5546,7 +5919,7 @@ async function startBridge(opts) {
 
 // src/core/single-instance.ts
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, unlinkSync, writeFileSync } from "fs";
-import { dirname as dirname9 } from "path";
+import { dirname as dirname12 } from "path";
 var BridgeAlreadyRunningError = class extends Error {
   constructor(pid) {
     super(
@@ -5575,7 +5948,7 @@ function acquireSingleInstanceLock(appId) {
   } catch (err) {
     if (err instanceof BridgeAlreadyRunningError) throw err;
   }
-  mkdirSync2(dirname9(file), { recursive: true });
+  mkdirSync2(dirname12(file), { recursive: true });
   const record = { pid: process.pid, appId, startedAt: Date.now() };
   writeFileSync(file, `${JSON.stringify(record)}
 `, "utf8");
@@ -5644,12 +6017,12 @@ async function runStart() {
     return;
   }
   const status = await getServiceAdapter().install();
-  console.log("\u2713 \u540E\u53F0\u670D\u52A1\u5DF2\u5B89\u88C5\u5E76\u542F\u52A8\uFF08\u5F00\u673A\u81EA\u542F\u3001\u5D29\u6E83\u81EA\u52A8\u62C9\u8D77\uFF09\u3002");
+  console.log(installedNote());
   printStatus(status);
 }
 async function runStop() {
   await getServiceAdapter().uninstall();
-  console.log("\u2713 \u540E\u53F0\u670D\u52A1\u5DF2\u505C\u6B62\uFF0C\u5E76\u5DF2\u5173\u95ED\u5F00\u673A\u81EA\u542F\uFF08\u5DF2\u79FB\u9664 launchd plist\uFF09\u3002");
+  console.log("\u2713 \u540E\u53F0\u670D\u52A1\u5DF2\u505C\u6B62\uFF0C\u5E76\u5DF2\u5173\u95ED\u81EA\u542F\uFF08\u5DF2\u79FB\u9664\u670D\u52A1\u5B9A\u4E49\uFF09\u3002");
 }
 async function runRestart() {
   const status = await getServiceAdapter().restart();
@@ -5662,18 +6035,29 @@ async function runStatus() {
 async function runLogs(follow) {
   await getServiceAdapter().logs(follow);
 }
+function installedNote() {
+  switch (process.platform) {
+    case "win32":
+      return "\u2713 \u540E\u53F0\u670D\u52A1\u5DF2\u5B89\u88C5\u5E76\u542F\u52A8\uFF08\u767B\u5F55\u81EA\u542F\uFF1B\u6CE8\u610F\uFF1AWindows \u8BA1\u5212\u4EFB\u52A1\u65E0\u5D29\u6E83\u81EA\u52A8\u62C9\u8D77\uFF09\u3002";
+    case "linux":
+      return "\u2713 \u540E\u53F0\u670D\u52A1\u5DF2\u5B89\u88C5\u5E76\u542F\u52A8\uFF08\u767B\u5F55\u81EA\u542F\u3001\u5D29\u6E83\u81EA\u52A8\u62C9\u8D77\uFF09\u3002\n  \u63D0\u793A\uFF1A\u6CE8\u9500\u540E\u4ECD\u4FDD\u6301\u8FD0\u884C\u9700\u6267\u884C\u4E00\u6B21 `loginctl enable-linger $USER`\u3002";
+    default:
+      return "\u2713 \u540E\u53F0\u670D\u52A1\u5DF2\u5B89\u88C5\u5E76\u542F\u52A8\uFF08\u5F00\u673A\u81EA\u542F\u3001\u5D29\u6E83\u81EA\u52A8\u62C9\u8D77\uFF09\u3002";
+  }
+}
 function printStatus(status) {
-  console.log(`plist:     ${status.plistPath}`);
+  console.log(`service:   ${status.platformName}`);
+  console.log(`path:      ${status.servicePath}`);
   console.log(`installed: ${status.installed ? "yes" : "no"}`);
-  console.log(`loaded:    ${status.loaded ? "yes" : "no"}`);
+  console.log(`running:   ${status.running ? "yes" : "no"}`);
   console.log(`pid:       ${status.pid ?? "-"}`);
   console.log(`last exit: ${status.lastExit ?? "-"}`);
   console.log(`stdout:    ${status.stdoutPath}`);
   console.log(`stderr:    ${status.stderrPath}`);
   if (!status.installed) {
     console.log("\u63D0\u793A\uFF1A\u540E\u53F0\u670D\u52A1\u5C1A\u672A\u5B89\u88C5\uFF0C\u8FD0\u884C `feishu-codex-bridge start`\u3002");
-  } else if (!status.loaded) {
-    console.log("\u63D0\u793A\uFF1Aplist \u5DF2\u5B58\u5728\uFF0C\u4F46 launchd \u5F53\u524D\u672A\u52A0\u8F7D\uFF08\u8BD5\u8BD5 `restart`\uFF09\u3002");
+  } else if (!status.running) {
+    console.log("\u63D0\u793A\uFF1A\u670D\u52A1\u5DF2\u6CE8\u518C\u4F46\u5F53\u524D\u672A\u8FD0\u884C\uFF08\u8BD5\u8BD5 `restart`\uFF09\u3002");
   }
 }
 
@@ -5726,7 +6110,7 @@ async function runUpdate(opts = {}) {
 }
 
 // src/cli/commands/bot.ts
-import { rm as rm4 } from "fs/promises";
+import { rm as rm6 } from "fs/promises";
 async function runBotInit(name) {
   if (!ensureCodex()) {
     process.exitCode = 1;
@@ -5781,7 +6165,7 @@ async function runBotRm(name) {
   }
   const after = await removeBot(bot2.appId);
   await removeSecret(secretKeyForApp(bot2.appId));
-  await rm4(botDir(bot2.appId), { recursive: true, force: true });
+  await rm6(botDir(bot2.appId), { recursive: true, force: true });
   console.log(`\u2713 \u5DF2\u79FB\u9664\u673A\u5668\u4EBA\u300C${bot2.name}\u300D(${bot2.appId})\uFF1A\u6CE8\u518C\u8868 + \u5BC6\u94A5 + \u72B6\u6001\u76EE\u5F55(projects/sessions)\u3002`);
   if (after.bots.length === 0) {
     console.log("  \u5DF2\u65E0\u4EFB\u4F55\u673A\u5668\u4EBA\uFF0C`bot init` \u91CD\u65B0\u521B\u5EFA\u3002");
@@ -5839,15 +6223,15 @@ async function secretsRemove(id) {
   console.log(ok ? `\u2713 \u5DF2\u5220\u9664: ${id}` : `\u672A\u627E\u5230: ${id}`);
 }
 function readStdin() {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     let data = "";
     if (process.stdin.isTTY) {
-      resolve6("");
+      resolve7("");
       return;
     }
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (c) => data += c);
-    process.stdin.on("end", () => resolve6(data));
+    process.stdin.on("end", () => resolve7(data));
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelzen/feishu-codex-bridge",
-  "version": "0.2.1",
+  "version": "0.2.2-win",
   "description": "Bridge Feishu/Lark messenger with local Codex via app-server (project=group, thread=session)",
   "type": "module",
   "bin": {
@@ -30,9 +30,11 @@
   "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.65.0",
     "commander": "^12.1.0",
+    "cross-spawn": "^7.0.6",
     "qrcode-terminal": "^0.12.0"
   },
   "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
     "@types/node": "^22.10.0",
     "@types/qrcode-terminal": "^0.12.2",
     "tsup": "^8.3.5",