feishu-devops 0.1.0 → 26.627.1

package/dist/cli.js

@@ -4,7 +4,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "feishu-devops",
-  version: "0.1.0",
+  version: "26.627.1",
   description: "\u98DE\u4E66\u6D88\u606F bot\uFF1A\u626B\u7801\u521B\u5EFA\u5E94\u7528\uFF0C\u901A\u8FC7 Claude Code / Codex \u5904\u7406\u6D88\u606F",
   type: "module",
   bin: {
@@ -144,6 +144,12 @@ function daemonStdoutPath() {
 function daemonStderrPath() {
   return join2(daemonLogDir(), "daemon-stderr.log");
 }
+function spawnDaemonPidPath() {
+  return join2(daemonLogDir(), "bot.pid");
+}
+function spawnDaemonMarkerPath() {
+  return join2(daemonLogDir(), ".spawn-daemon");
+}
 
 // src/daemon/launchd.ts
 import { spawnSync } from "child_process";
@@ -393,10 +399,131 @@ async function deleteTask() {
   return r;
 }
 
+// src/daemon/spawn-daemon.ts
+import { spawn } from "child_process";
+import { closeSync, existsSync as existsSync4, openSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { mkdir as mkdir3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+function readPid() {
+  if (!existsSync4(spawnDaemonPidPath())) return null;
+  const raw = readFileSync(spawnDaemonPidPath(), "utf8").trim();
+  const pid = Number.parseInt(raw, 10);
+  return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function markerExists() {
+  return existsSync4(spawnDaemonMarkerPath());
+}
+function isRunning() {
+  const pid = readPid();
+  if (pid === null) return false;
+  if (!isProcessAlive(pid)) {
+    try {
+      unlinkSync(spawnDaemonPidPath());
+    } catch {
+    }
+    return false;
+  }
+  return true;
+}
+async function install(extraRunArgs = []) {
+  void extraRunArgs;
+  await mkdir3(daemonLogDir(), { recursive: true });
+  await writeFile3(spawnDaemonMarkerPath(), "spawn-daemon\n", "utf8");
+}
+function start(extraRunArgs = []) {
+  if (isRunning()) {
+    return { ok: true, stderr: "" };
+  }
+  const invocation = resolveDaemonRunInvocation(extraRunArgs);
+  let outFd;
+  let errFd;
+  try {
+    outFd = openSync(daemonStdoutPath(), "a");
+    errFd = openSync(daemonStderrPath(), "a");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, stderr: message };
+  }
+  const child = spawn(invocation.program, invocation.runArgs, {
+    detached: true,
+    stdio: ["ignore", outFd, errFd],
+    cwd: invocation.cwd,
+    env: {
+      ...process.env,
+      PATH: process.env.PATH ?? "",
+      FEISHU_DEVOPS_HOME: paths.rootDir
+    }
+  });
+  closeSync(outFd);
+  closeSync(errFd);
+  if (!child.pid) {
+    return { ok: false, stderr: "failed to spawn daemon process" };
+  }
+  try {
+    writeFileSync(spawnDaemonPidPath(), `${child.pid}
+`, "utf8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, stderr: message };
+  }
+  child.unref();
+  return { ok: true, stderr: "" };
+}
+function stop() {
+  const pid = readPid();
+  if (pid === null || !isProcessAlive(pid)) {
+    return { ok: true, stderr: "" };
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, stderr: message };
+  }
+  return { ok: true, stderr: "" };
+}
+function stopAndDisableAutostart() {
+  return stop();
+}
+function restart(extraRunArgs = []) {
+  const r = stop();
+  if (!r.ok) return r;
+  return start(extraRunArgs);
+}
+async function waitUntilInactive(timeoutMs = 5e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isRunning()) return true;
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  return false;
+}
+async function deleteMarker() {
+  await rm3(spawnDaemonMarkerPath(), { force: true });
+  await rm3(spawnDaemonPidPath(), { force: true });
+}
+function describeService2() {
+  const pid = readPid();
+  if (pid !== null && isProcessAlive(pid)) {
+    return `bot (detached): running (pid ${pid})`;
+  }
+  if (pid !== null) {
+    return `bot (detached): not running (stale pid ${pid})`;
+  }
+  return "bot (detached): not running";
+}
+
 // src/daemon/systemd.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync4 } from "fs";
-import { mkdir as mkdir3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir4, rm as rm4, writeFile as writeFile4 } from "fs/promises";
 import { dirname as dirname4 } from "path";
 function buildUnit(inputs) {
   const escape = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
@@ -431,12 +558,12 @@ async function writeUnit(extraRunArgs = []) {
     cwd: invocation.cwd
   });
   const unitPath = systemdUnitPath();
-  await mkdir3(dirname4(unitPath), { recursive: true });
-  await mkdir3(daemonLogDir(), { recursive: true });
-  await writeFile3(unitPath, content, "utf8");
+  await mkdir4(dirname4(unitPath), { recursive: true });
+  await mkdir4(daemonLogDir(), { recursive: true });
+  await writeFile4(unitPath, content, "utf8");
 }
 function unitExists() {
-  return existsSync4(systemdUnitPath());
+  return existsSync5(systemdUnitPath());
 }
 function runSystemctl(args) {
   const r = spawnSync3("systemctl", ["--user", ...args], { encoding: "utf8" });
@@ -446,19 +573,31 @@ function runSystemctl(args) {
     stdout: r.stdout ?? ""
   };
 }
+function isUserBusAvailable() {
+  const r = spawnSync3("systemctl", ["--user", "is-system-running"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const combined = `${r.stderr ?? ""}
+${r.stdout ?? ""}`;
+  if (/Failed to connect to bus|Couldn't connect to bus|No medium found|找不到介质/i.test(combined)) {
+    return false;
+  }
+  return r.status !== null;
+}
 function daemonReload() {
   return runSystemctl(["daemon-reload"]);
 }
 function enableAndStart() {
   return runSystemctl(["enable", "--now", systemdUnitName()]);
 }
-function stop() {
+function stop2() {
   return runSystemctl(["stop", systemdUnitName()]);
 }
 function disableAndStop() {
   return runSystemctl(["disable", "--now", systemdUnitName()]);
 }
-function restart() {
+function restart2() {
   return runSystemctl(["restart", systemdUnitName()]);
 }
 function isActive() {
@@ -467,11 +606,11 @@ function isActive() {
   });
   return r.status === 0;
 }
-function describeService2() {
+function describeService3() {
   const r = runSystemctl(["status", systemdUnitName(), "--no-pager"]);
   return r.stdout || r.stderr || "";
 }
-async function waitUntilInactive(timeoutMs = 5e3) {
+async function waitUntilInactive2(timeoutMs = 5e3) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (!isActive()) return true;
@@ -480,7 +619,7 @@ async function waitUntilInactive(timeoutMs = 5e3) {
   return false;
 }
 async function deleteUnit() {
-  await rm3(systemdUnitPath(), { force: true });
+  await rm4(systemdUnitPath(), { force: true });
 }
 
 // src/daemon/service-adapter.ts
@@ -504,6 +643,26 @@ function makeLaunchdAdapter(extraRunArgs) {
     })
   };
 }
+function makeSpawnDaemonAdapter(extraRunArgs) {
+  return {
+    platformName: "detached process (Linux fallback)",
+    fileExists: () => markerExists(),
+    isRunning: () => isRunning(),
+    servicePath: () => spawnDaemonPidPath(),
+    install: () => install(extraRunArgs),
+    start: () => start(extraRunArgs),
+    stop: () => stop(),
+    stopAndDisableAutostart: () => stopAndDisableAutostart(),
+    restart: () => restart(extraRunArgs),
+    waitUntilStopped: (timeoutMs) => waitUntilInactive(timeoutMs),
+    deleteFile: () => deleteMarker(),
+    describeStatus: () => describeService2(),
+    parseStatus: (text) => ({
+      pid: text.match(/pid[:\s]+(\d+)/i)?.[1],
+      lastExit: void 0
+    })
+  };
+}
 function makeSystemdAdapter(extraRunArgs) {
   return {
     platformName: "systemd (Linux user)",
@@ -515,15 +674,15 @@ function makeSystemdAdapter(extraRunArgs) {
       daemonReload();
     },
     start: () => enableAndStart(),
-    stop: () => stop(),
+    stop: () => stop2(),
     stopAndDisableAutostart: () => disableAndStop(),
-    restart: () => restart(),
-    waitUntilStopped: (timeoutMs) => waitUntilInactive(timeoutMs),
+    restart: () => restart2(),
+    waitUntilStopped: (timeoutMs) => waitUntilInactive2(timeoutMs),
     deleteFile: async () => {
       await deleteUnit();
       daemonReload();
     },
-    describeStatus: () => describeService2(),
+    describeStatus: () => describeService3(),
     parseStatus: (text) => ({
       pid: text.match(/Main PID:\s*(\d+)/)?.[1],
       lastExit: text.match(/Process:\s+\d+\s+ExecStart=.*status=(\d+)/)?.[1]
@@ -557,7 +716,9 @@ function makeSchtasksAdapter(extraRunArgs) {
 }
 function getServiceAdapter(extraRunArgs = []) {
   if (process.platform === "darwin") return makeLaunchdAdapter(extraRunArgs);
-  if (process.platform === "linux") return makeSystemdAdapter(extraRunArgs);
+  if (process.platform === "linux") {
+    return isUserBusAvailable() ? makeSystemdAdapter(extraRunArgs) : makeSpawnDaemonAdapter(extraRunArgs);
+  }
   if (process.platform === "win32") return makeSchtasksAdapter(extraRunArgs);
   return null;
 }
@@ -619,7 +780,7 @@ import { readFile } from "fs/promises";
 
 // src/platform/atomic-write.ts
 import { randomBytes } from "crypto";
-import { chmod, mkdir as mkdir4, open, rm as rm4 } from "fs/promises";
+import { chmod, mkdir as mkdir5, open, rm as rm5 } from "fs/promises";
 import { basename, dirname as dirname5, join as join4 } from "path";
 import { promisify } from "util";
 import gracefulFs from "graceful-fs";
@@ -627,7 +788,7 @@ var gracefulRename = promisify(gracefulFs.rename);
 var DEFAULT_RENAME_ATTEMPTS = 5;
 var DEFAULT_RETRY_DELAY_MS = 25;
 async function writeFileAtomic(path, data, opts = {}) {
-  await mkdir4(dirname5(path), { recursive: true });
+  await mkdir5(dirname5(path), { recursive: true });
   const tmp = join4(
     dirname5(path),
     `.${basename(path)}.tmp-${process.pid}-${Date.now()}-${randomBytes(3).toString("hex")}`
@@ -647,7 +808,7 @@ async function writeFileAtomic(path, data, opts = {}) {
     await chmod(tmp, opts.mode ?? 384);
     await renameWithRetry(tmp, path, opts);
   } catch (err) {
-    await rm4(tmp, { force: true }).catch(() => {
+    await rm5(tmp, { force: true }).catch(() => {
     });
     throw err;
   }
@@ -835,6 +996,22 @@ function printServiceFailure(stderr) {
     console.error(`  ${cleaned}`);
     return;
   }
+  if (/Failed to connect to bus|Couldn't connect to bus|No medium found|找不到介质/i.test(cleaned)) {
+    console.error("\u2717 bot \u542F\u52A8\u5931\u8D25\u3002");
+    console.error("");
+    console.error("\u5F53\u524D\u73AF\u5883\u65E0\u6CD5\u8FDE\u63A5 systemd \u7528\u6237 D-Bus\uFF08\u5E38\u89C1\u4E8E SSH\u3001Docker\u3001\u65E0\u56FE\u5F62\u4F1A\u8BDD\uFF09\u3002");
+    console.error("");
+    console.error("\u53EF\u9009\u65B9\u6848\uFF1A");
+    console.error("  1. \u524D\u53F0\u8FD0\u884C: feishu-devops run");
+    console.error("  2. \u542F\u7528 systemd \u7528\u6237\u4F1A\u8BDD\u540E\u91CD\u8BD5:");
+    console.error("       export XDG_RUNTIME_DIR=/run/user/$(id -u)");
+    console.error("       sudo loginctl enable-linger $USER");
+    console.error("       npm start");
+    console.error("");
+    console.error("\u539F\u59CB\u9519\u8BEF:");
+    console.error(`  ${cleaned}`);
+    return;
+  }
   console.error("\u2717 bot \u542F\u52A8\u5931\u8D25:");
   console.error(cleaned);
 }
@@ -880,6 +1057,9 @@ ${formatServiceStderr(r2.stderr)}`);
     process.exit(1);
   }
   console.log("\u2713 bot \u5DF2\u5728\u540E\u53F0\u542F\u52A8");
+  if (adapter.platformName.includes("fallback")) {
+    console.log("  \u540E\u53F0\u65B9\u5F0F: detached \u8FDB\u7A0B\uFF08systemd \u7528\u6237\u4F1A\u8BDD\u4E0D\u53EF\u7528\uFF09");
+  }
   console.log("  \u65E5\u5FD7:");
   console.log(`    ${daemonStdoutPath()}`);
   console.log(`    ${daemonStderrPath()}`);
@@ -934,6 +1114,9 @@ async function runServiceRestart(opts = {}) {
     process.exit(1);
   }
   console.log("\u2713 bot \u5DF2\u5728\u540E\u53F0\u542F\u52A8");
+  if (adapter.platformName.includes("fallback")) {
+    console.log("  \u540E\u53F0\u65B9\u5F0F: detached \u8FDB\u7A0B\uFF08systemd \u7528\u6237\u4F1A\u8BDD\u4E0D\u53EF\u7528\uFF09");
+  }
   console.log("  \u65E5\u5FD7:");
   console.log(`    ${daemonStdoutPath()}`);
   console.log(`    ${daemonStderrPath()}`);
@@ -970,7 +1153,7 @@ import { createInterface as createInterface2 } from "readline";
 // src/core/logger.ts
 import { AsyncLocalStorage } from "async_hooks";
 import { createWriteStream, mkdirSync } from "fs";
-import { open as open2, readdir, rm as rm5, stat } from "fs/promises";
+import { open as open2, readdir, rm as rm6, stat } from "fs/promises";
 import { join as join5 } from "path";
 
 // src/core/telemetry.ts
@@ -3674,7 +3857,7 @@ function isTerminalEvent(event) {
 
 // src/session/catalog.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { open as open3, readFile as readFile2, rename, mkdir as mkdir5 } from "fs/promises";
+import { open as open3, readFile as readFile2, rename, mkdir as mkdir6 } from "fs/promises";
 import { dirname as dirname6 } from "path";
 var DEFAULT_MAX_ARCHIVED_AGE_MS = 90 * 24 * 60 * 60 * 1e3;
 var DEFAULT_MAX_ENTRIES_PER_SCOPE = 20;
@@ -3797,7 +3980,7 @@ var SessionCatalog = class {
     });
   }
   async persist() {
-    await mkdir5(dirname6(this.path), { recursive: true });
+    await mkdir6(dirname6(this.path), { recursive: true });
     const tmp = `${this.path}.${process.pid}.${Date.now()}.${randomUUID2()}.tmp`;
     const payload = `${JSON.stringify(this.entries(), null, 2)}
 `;
@@ -5419,14 +5602,14 @@ function normalizeCommandInput(msg) {
 }
 
 // src/bot/run-shell.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 var DEFAULT_TIMEOUT_MS = 3e5;
 var MAX_OUTPUT_CHARS = 3500;
 async function runShellCommand(command, opts = {}) {
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const cwd = opts.cwd ?? process.cwd();
   return new Promise((resolve3) => {
-    const child = spawn(command, {
+    const child = spawn2(command, {
       shell: true,
       cwd,
       env: process.env,
@@ -5780,7 +5963,7 @@ async function handleStatus(_args, ctx) {
     effectiveCwd: effective,
     sessionId: isCodex ? catalogEntry?.threadId : sess?.sessionId,
     sessionStale: usesSessionStore && Boolean(cwd && sess && sess.cwd !== cwd),
-    agentName: ctx.agent?.displayName ?? profile?.agentKind ?? "unknown",
+    agentName: resolveStatusAgentName(ctx),
     runtimeAccess: runtimeAccessStatus(profile),
     activeRun: Boolean(ctx.activeRuns?.get(ctx.scope)),
     queue: ctx.processPool?.snapshot(),
@@ -5886,6 +6069,13 @@ async function handleSwitch(args, ctx) {
 function isSwitchableAgentKind(value) {
   return value === "claude" || value === "codex" || value === "cursor";
 }
+function resolveStatusAgentName(ctx) {
+  if (ctx.runtime?.agentUnavailable) {
+    const kind = ctx.profileConfig?.agentKind ?? "agent";
+    return `${kind}\uFF08\u4E0D\u53EF\u7528\uFF09`;
+  }
+  return ctx.agent?.displayName ?? ctx.profileConfig?.agentKind ?? "unknown";
+}
 function runtimeAccessStatus(profile) {
   if (!profile) return { label: "access", value: "unknown" };
   if (profile.agentKind === "claude") {
@@ -6023,8 +6213,9 @@ function log2(level, phase, detail) {
 async function startChannel(cfg, startOpts = {}) {
   const fullCfg = startOpts.cfg ?? cfg;
   const configPath = startOpts.configPath ?? paths.configFile;
+  const profileConfig = toProfileConfig(fullCfg);
   const agentEnabled = Boolean(startOpts.agent) && isAgentEnabled(fullCfg);
-  const profileConfig = agentEnabled ? toProfileConfig(fullCfg) : void 0;
+  const agentUnavailable = startOpts.agentUnavailable === true;
   configureLogger({ logsDir: `${paths.rootDir}/logs` });
   const { app } = cfg.accounts;
   const workspaces = startOpts.workspaces ?? new WorkspaceStore();
@@ -6048,6 +6239,7 @@ async function startChannel(cfg, startOpts = {}) {
     agent: startOpts.agent,
     executor: agentEnabled && startOpts.agent ? new RunExecutor({ agent: startOpts.agent, pool, activeRuns }) : void 0,
     agentEnabled,
+    agentUnavailable,
     cursorDebug: startOpts.cursorDebug === true,
     configPath
   };
@@ -6158,10 +6350,11 @@ async function startChannel(cfg, startOpts = {}) {
     bot: identity?.name ?? "unknown",
     openId: identity?.openId ?? "-",
     appId: app.id,
-    agent: runtime.agentEnabled ? runtime.profileConfig?.agentKind : "disabled"
+    agent: agentEnabled ? profileConfig.agentKind : agentUnavailable ? "unavailable" : "disabled"
   });
   console.log(
-    runtime.agentEnabled ? `\u6B63\u5728\u76D1\u542C\u6D88\u606F\uFF08agent: ${runtime.profileConfig?.agentKind ?? "unknown"}\uFF09\u3002\u6309 Ctrl+C \u9000\u51FA\u3002
+    agentEnabled ? `\u6B63\u5728\u76D1\u542C\u6D88\u606F\uFF08agent: ${profileConfig.agentKind}\uFF09\u3002\u6309 Ctrl+C \u9000\u51FA\u3002
+` : agentUnavailable ? `\u6B63\u5728\u76D1\u542C\u6D88\u606F\uFF08agent \u4E0D\u53EF\u7528\uFF0C\u659C\u6760\u547D\u4EE4\u4E0E\u56FA\u5B9A\u56DE\u590D\u4ECD\u53EF\u7528\uFF09\u3002\u6309 Ctrl+C \u9000\u51FA\u3002
 ` : "\u6B63\u5728\u76D1\u542C\u6D88\u606F\u3002\u6309 Ctrl+C \u9000\u51FA\u3002\n"
   );
   return {
@@ -6278,14 +6471,16 @@ async function runStart(opts) {
   const sessionCatalog = new SessionCatalog();
   await sessionCatalog.load();
   let agent;
+  let agentUnavailable = false;
   if (agentKind !== "disabled") {
     agent = createRuntimeAgent(fullCfg, { configPath, cursorDebug: opts.debug });
     const availability = await checkRuntimeAgentAvailability(agent);
     if (!availability.ok) {
-      console.error(availability.message);
-      process.exit(1);
-    }
-    if (agentKind === "claude") {
+      console.warn("\u26A0 Agent \u4E0D\u53EF\u7528\uFF0C\u670D\u52A1\u5C06\u4EE5\u65E0 Agent \u6A21\u5F0F\u542F\u52A8\uFF08/cmd\u3001/status \u7B49\u547D\u4EE4\u4ECD\u53EF\u7528\uFF09");
+      console.warn(availability.message);
+      agent = void 0;
+      agentUnavailable = true;
+    } else if (agentKind === "claude") {
       try {
         const claudePath = await resolveClaudeBinaryPath();
         console.log(`\u2713 Claude Code: ${claudePath}`);
@@ -6309,7 +6504,8 @@ async function runStart(opts) {
     sessions,
     sessionCatalog,
     cursorDebug: opts.debug,
-    configPath
+    configPath,
+    agentUnavailable
   });
   const shutdown = async (signal) => {
     console.log(`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feishu-devops",
-  "version": "0.1.0",
+  "version": "26.627.1",
   "description": "飞书消息 bot：扫码创建应用，通过 Claude Code / Codex 处理消息",
   "type": "module",
   "bin": {