weacpx 0.4.9 → 0.4.10

package/dist/bridge/bridge-main.js

@@ -1042,6 +1042,13 @@ function normalizeBridgePermissionMode(value) {
 function normalizeBridgeNonInteractivePermissions(value) {
   return value === "deny" || value === "fail" ? value : "deny";
 }
+function normalizeBridgeQueueOwnerTtlSeconds(value) {
+  if (value === undefined) {
+    return;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
 
 // src/bridge/bridge-server.ts
 init_prompt_output();
@@ -1125,7 +1132,8 @@ class BridgeRuntime {
   queueOwnerLauncher;
   acpxVerboseSupported = undefined;
   constructor(command = "acpx", run = defaultRunner, runSessionCreate = shellSessionCreateRunner, options = {}, runPromptCommand = defaultPromptRunner, repairSessionIndex = tryRepairAcpxSessionIndex, queueOwnerLauncher = new AcpxQueueOwnerLauncher({
-    acpxCommand: command
+    acpxCommand: command,
+    ...typeof options.queueOwnerTtlSeconds === "number" && Number.isFinite(options.queueOwnerTtlSeconds) ? { ttlMs: options.queueOwnerTtlSeconds * 1000 } : {}
   })) {
     this.command = command;
     this.run = run;
@@ -1381,13 +1389,21 @@ class BridgeRuntime {
       "--json-strict",
       "--cwd",
       input.cwd,
-      ...this.buildPermissionArgs()
+      ...this.buildPermissionArgs(),
+      ...this.buildQueueOwnerTtlArgs()
     ];
     if (input.agentCommand) {
       return [...prefix, "--agent", input.agentCommand, ...tail];
     }
     return [...prefix, input.agent, ...tail];
   }
+  buildQueueOwnerTtlArgs() {
+    const ttl = this.options.queueOwnerTtlSeconds;
+    if (typeof ttl !== "number" || !Number.isFinite(ttl)) {
+      return [];
+    }
+    return ["--ttl", String(ttl)];
+  }
   buildPermissionArgs() {
     const permissionMode = this.options.permissionMode ?? "approve-all";
     const nonInteractivePermissions = this.options.nonInteractivePermissions ?? "deny";
@@ -1924,7 +1940,8 @@ async function processBridgeInput(options) {
 async function runBridgeMain() {
   const server = new BridgeServer(new BridgeRuntime(process.env.WEACPX_BRIDGE_ACPX_COMMAND ?? "acpx", undefined, undefined, {
     permissionMode: normalizeBridgePermissionMode(process.env.WEACPX_BRIDGE_PERMISSION_MODE),
-    nonInteractivePermissions: normalizeBridgeNonInteractivePermissions(process.env.WEACPX_BRIDGE_NON_INTERACTIVE_PERMISSIONS)
+    nonInteractivePermissions: normalizeBridgeNonInteractivePermissions(process.env.WEACPX_BRIDGE_NON_INTERACTIVE_PERMISSIONS),
+    queueOwnerTtlSeconds: normalizeBridgeQueueOwnerTtlSeconds(process.env.WEACPX_BRIDGE_QUEUE_OWNER_TTL_SECONDS)
   }));
   const input = createInterface({
     input: process.stdin,

package/dist/cli.js

@@ -1999,6 +1999,7 @@ var require_lib = __commonJS((exports, module) => {
 
 // src/util/private-file.ts
 import { chmod, mkdir, writeFile } from "node:fs/promises";
+import { chmodSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 async function writePrivateFileAtomic(path, content) {
   await mkdir(dirname(path), { recursive: true });
@@ -2031,6 +2032,25 @@ async function writePrivateFileAtomic(path, content) {
     await release();
   }
 }
+function writePrivateFileSync(path, content, deps = {}) {
+  mkdirSync(dirname(path), { recursive: true });
+  const platform = deps.platform ?? process.platform;
+  const atomicWrite = deps.atomicWrite ?? ((p, c) => import_write_file_atomic.default.sync(p, c, { mode: PRIVATE_FILE_MODE, encoding: "utf8", fsync: true }));
+  try {
+    atomicWrite(path, content);
+  } catch (error) {
+    if (!isTransientWriteError(error, platform)) {
+      throw error;
+    }
+    const directWrite = deps.directWrite ?? ((p, c) => {
+      writeFileSync(p, c, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
+      try {
+        chmodSync(p, PRIVATE_FILE_MODE);
+      } catch {}
+    });
+    directWrite(path, content);
+  }
+}
 async function retryTransientWriteErrors(run, options = {}) {
   const platform = options.platform ?? process.platform;
   const maxAttempts = options.maxAttempts ?? WRITE_RETRY_MAX_ATTEMPTS;
@@ -2206,6 +2226,9 @@ function parseConfig(raw, options = {}) {
       throw new Error("transport.permissionPolicy must be a non-empty string");
     }
   }
+  if ("queueOwnerTtlSeconds" in transport && (typeof transport.queueOwnerTtlSeconds !== "number" || !Number.isFinite(transport.queueOwnerTtlSeconds) || transport.queueOwnerTtlSeconds < 0)) {
+    throw new Error("transport.queueOwnerTtlSeconds must be a non-negative number (0 = keep alive forever)");
+  }
   if (!isRecord(raw.agents)) {
     throw new Error("agents must be an object");
   }
@@ -2302,7 +2325,8 @@ function parseConfig(raw, options = {}) {
       ...typeof transport.permissionPolicy === "string" ? { permissionPolicy: transport.permissionPolicy } : {},
       type: transportType,
       permissionMode,
-      nonInteractivePermissions
+      nonInteractivePermissions,
+      queueOwnerTtlSeconds: typeof transport.queueOwnerTtlSeconds === "number" ? transport.queueOwnerTtlSeconds : DEFAULT_QUEUE_OWNER_TTL_SECONDS
     },
     logging: {
       level: resolvedLoggingLevel,
@@ -2428,7 +2452,7 @@ function parseOrchestrationConfig(raw) {
     maxParallelTasksPerAgent: typeof raw.maxParallelTasksPerAgent === "number" && Number.isFinite(raw.maxParallelTasksPerAgent) && raw.maxParallelTasksPerAgent >= 1 ? Math.floor(raw.maxParallelTasksPerAgent) : DEFAULT_ORCHESTRATION_CONFIG.maxParallelTasksPerAgent
   };
 }
-var DEFAULT_PERF_LOG_CONFIG, DEFAULT_LOGGING_CONFIG, DEFAULT_PERMISSION_MODE = "approve-all", DEFAULT_NON_INTERACTIVE_PERMISSIONS = "deny", DEFAULT_CHANNEL_CONFIG, DEFAULT_ORCHESTRATION_CONFIG;
+var DEFAULT_PERF_LOG_CONFIG, DEFAULT_LOGGING_CONFIG, DEFAULT_PERMISSION_MODE = "approve-all", DEFAULT_NON_INTERACTIVE_PERMISSIONS = "deny", DEFAULT_QUEUE_OWNER_TTL_SECONDS = 1800, DEFAULT_CHANNEL_CONFIG, DEFAULT_ORCHESTRATION_CONFIG;
 var init_load_config = __esm(() => {
   init_workspace_path();
   DEFAULT_PERF_LOG_CONFIG = {
@@ -2729,7 +2753,7 @@ class DaemonStatusStore {
 var init_daemon_status = () => {};
 
 // src/daemon/daemon-controller.ts
-import { mkdir as mkdir3, readFile as readFile4, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir3, open, readFile as readFile4, rm as rm2 } from "node:fs/promises";
 import { dirname as dirname3 } from "node:path";
 
 class DaemonController {
@@ -2788,9 +2812,19 @@ class DaemonController {
     if (current.state === "indeterminate") {
       throw new Error(`weacpx daemon process is already running (pid ${current.pid}) but status metadata is missing`);
     }
-    await this.statusStore.clear();
-    const pid = await this.deps.spawnDetached(options);
-    await this.writePid(pid);
+    const pidHandle = await this.openPidFileExclusive();
+    let pid;
+    try {
+      await this.statusStore.clear();
+      pid = await this.deps.spawnDetached(options);
+      await pidHandle.write(`${pid}
+`);
+    } catch (error) {
+      await pidHandle.close().catch(() => {});
+      await rm2(this.paths.pidFile, { force: true }).catch(() => {});
+      throw error;
+    }
+    await pidHandle.close();
     await this.waitForStartupMetadata(pid, options.firstRunOnboarding ? this.onboardingStartupTimeoutMs : this.startupTimeoutMs, options.startupWait);
     return { state: "started", pid };
   }
@@ -2818,10 +2852,16 @@ class DaemonController {
       throw error;
     }
   }
-  async writePid(pid) {
+  async openPidFileExclusive() {
     await mkdir3(dirname3(this.paths.pidFile), { recursive: true });
-    await writeFile3(this.paths.pidFile, `${pid}
-`);
+    try {
+      return await open(this.paths.pidFile, "wx", 384);
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        throw new Error(`weacpx daemon pid file already exists (${this.paths.pidFile}); another start may be in progress`);
+      }
+      throw error;
+    }
   }
   async clearRuntimeFiles() {
     await rm2(this.paths.pidFile, { force: true });
@@ -2918,15 +2958,17 @@ async function defaultRunProcessCommand(command, args) {
 var init_terminate_process_tree = () => {};
 
 // src/daemon/create-daemon-controller.ts
-import { mkdir as mkdir4, open } from "node:fs/promises";
+import { mkdir as mkdir4, open as open2 } from "node:fs/promises";
 import { spawn as spawn2 } from "node:child_process";
 function createDaemonController(paths, options) {
   return new DaemonController(paths, {
     isProcessRunning: options.isProcessRunning ?? defaultIsProcessRunning2,
     spawnDetached: async (spawnOptions) => {
       await mkdir4(paths.runtimeDir, { recursive: true });
-      const stdoutHandle = await open(paths.stdoutLog, "a");
-      const stderrHandle = await open(paths.stderrLog, "a");
+      const stdoutHandle = await open2(paths.stdoutLog, "a", 384);
+      const stderrHandle = await open2(paths.stderrLog, "a", 384);
+      await stdoutHandle.chmod(384).catch(() => {});
+      await stderrHandle.chmod(384).catch(() => {});
       try {
         return await (options.spawnProcess ?? defaultSpawnProcess)(buildSpawnRequest(paths, options, stdoutHandle.fd, stderrHandle.fd, spawnOptions));
       } finally {
@@ -10014,7 +10056,7 @@ var init_state_store = __esm(() => {
 });
 
 // src/plugins/plugin-home.ts
-import { mkdir as mkdir6, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir6, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
 import { join as join3 } from "node:path";
 function coerceMissing(value) {
@@ -10040,7 +10082,7 @@ function resolvePluginHome(input = {}) {
 }
 async function ensurePluginHome(pluginHome) {
   await mkdir6(pluginHome, { recursive: true, mode: 448 });
-  await writeFile5(join3(pluginHome, "package.json"), JSON.stringify({ private: true, type: "module" }, null, 2) + `
+  await writeFile4(join3(pluginHome, "package.json"), JSON.stringify({ private: true, type: "module" }, null, 2) + `
 `, { flag: "wx" }).catch((error2) => {
     if (error2.code !== "EEXIST")
       throw error2;
@@ -10179,8 +10221,6 @@ function loadWeixinAccount(accountId) {
   return null;
 }
 function saveWeixinAccount(accountId, update) {
-  const dir = resolveAccountsDir();
-  ensureDirSync(dir);
   const existing = loadWeixinAccount(accountId) ?? {};
   const token = update.token?.trim() || existing.token;
   const baseUrl = update.baseUrl?.trim() || existing.baseUrl;
@@ -10190,11 +10230,7 @@ function saveWeixinAccount(accountId, update) {
     ...baseUrl ? { baseUrl } : {},
     ...userId ? { userId } : {}
   };
-  const filePath = resolveAccountPath(accountId);
-  fs3.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
-  try {
-    fs3.chmodSync(filePath, 384);
-  } catch {}
+  writePrivateFileSync(resolveAccountPath(accountId), JSON.stringify(data, null, 2));
 }
 function clearWeixinAccount(accountId) {
   try {
@@ -10295,6 +10331,7 @@ var DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com", CDN_BASE_URL = "https://
 var init_accounts = __esm(() => {
   init_ensure_dir();
   init_state_dir();
+  init_private_file();
 });
 
 // src/weixin/util/logger.ts
@@ -12298,8 +12335,7 @@ function persistContextTokens(accountId) {
   }
   const filePath = resolveContextTokenFilePath(accountId);
   try {
-    fs5.mkdirSync(path6.dirname(filePath), { recursive: true });
-    fs5.writeFileSync(filePath, JSON.stringify(tokens), "utf-8");
+    writePrivateFileSync(filePath, JSON.stringify(tokens));
   } catch (err) {
     logger.warn(`persistContextTokens: failed to write ${filePath}: ${String(err)}`);
   }
@@ -12422,6 +12458,7 @@ var init_inbound = __esm(() => {
   init_random();
   init_types2();
   init_state_dir();
+  init_private_file();
   contextTokenStore = new Map;
 });
 
@@ -12544,7 +12581,7 @@ function createConversationExecutor() {
 }
 
 // src/channels/media-store.ts
-import { access as access2, mkdir as mkdir7, readdir, rm as rm4, stat, writeFile as writeFile6 } from "node:fs/promises";
+import { access as access2, mkdir as mkdir7, readdir, rm as rm4, stat, writeFile as writeFile5 } from "node:fs/promises";
 import path7 from "node:path";
 
 class RuntimeMediaStore {
@@ -12568,7 +12605,7 @@ class RuntimeMediaStore {
     if (!isPathInside(resolvedFile, resolvedRoot)) {
       throw new Error("media path escapes runtime media root");
     }
-    await writeFile6(resolvedFile, input.buffer);
+    await writeFile5(resolvedFile, input.buffer);
     return {
       kind: input.kind,
       filePath: resolvedFile,
@@ -14789,13 +14826,11 @@ function loadGetUpdatesBuf(filePath) {
   return readSyncBufFile(getLegacySyncBufDefaultJsonPath());
 }
 function saveGetUpdatesBuf(filePath, getUpdatesBuf) {
-  const dir = path13.dirname(filePath);
-  ensureDirSync(dir);
-  fs10.writeFileSync(filePath, JSON.stringify({ get_updates_buf: getUpdatesBuf }, null, 0), "utf-8");
+  writePrivateFileSync(filePath, JSON.stringify({ get_updates_buf: getUpdatesBuf }, null, 0));
 }
 var init_sync_buf = __esm(() => {
   init_accounts();
-  init_ensure_dir();
+  init_private_file();
   init_state_dir();
 });
 
@@ -15408,7 +15443,7 @@ var init_deliver_coordinator_message = __esm(() => {
 });
 
 // src/weixin/monitor/consumer-lock.ts
-import { mkdir as mkdir8, open as open2, readFile as readFile6, rm as rm6 } from "node:fs/promises";
+import { mkdir as mkdir8, open as open3, readFile as readFile6, rm as rm6 } from "node:fs/promises";
 import { dirname as dirname8, join as join5 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 function createWeixinConsumerLock(options = {}) {
@@ -15420,7 +15455,7 @@ function createWeixinConsumerLock(options = {}) {
       await mkdir8(dirname8(lockFilePath), { recursive: true });
       while (true) {
         try {
-          const handle = await open2(lockFilePath, "wx");
+          const handle = await open3(lockFilePath, "wx");
           try {
             await handle.writeFile(`${JSON.stringify(meta2, null, 2)}
 `, "utf8");
@@ -16105,21 +16140,27 @@ async function loadConfiguredPlugins(input) {
   const importPlugin = input.importPlugin ?? importPluginFromHome;
   const loaded = [];
   for (const config2 of enabled) {
-    let moduleValue;
     try {
-      moduleValue = await importPlugin(config2.name, pluginHome);
+      let moduleValue;
+      try {
+        moduleValue = await importPlugin(config2.name, pluginHome);
+      } catch (error2) {
+        const message = error2 instanceof Error ? error2.message : String(error2);
+        throw new Error(`failed to load plugin ${config2.name}: ${message}`);
+      }
+      const plugin = validateWeacpxPlugin(moduleValue, config2.name, {
+        ...input.currentWeacpxVersion !== undefined ? { currentWeacpxVersion: input.currentWeacpxVersion } : {}
+      });
+      const channels = plugin.channels ?? [];
+      for (const channel of channels) {
+        registerChannelPlugin(channel);
+      }
+      loaded.push({ name: config2.name, channels: channels.map((channel) => channel.type) });
     } catch (error2) {
-      const message = error2 instanceof Error ? error2.message : String(error2);
-      throw new Error(`failed to load plugin ${config2.name}: ${message}`);
-    }
-    const plugin = validateWeacpxPlugin(moduleValue, config2.name, {
-      ...input.currentWeacpxVersion !== undefined ? { currentWeacpxVersion: input.currentWeacpxVersion } : {}
-    });
-    const channels = plugin.channels ?? [];
-    for (const channel of channels) {
-      registerChannelPlugin(channel);
+      if (!input.onPluginError)
+        throw error2;
+      input.onPluginError({ name: config2.name, error: error2 });
     }
-    loaded.push({ name: config2.name, channels: channels.map((channel) => channel.type) });
   }
   return loaded;
 }
@@ -16140,7 +16181,7 @@ var init_bootstrap = __esm(() => {
 });
 
 // src/logging/app-logger.ts
-import { appendFile, mkdir as mkdir9 } from "node:fs/promises";
+import { appendFile, chmod as chmod2, mkdir as mkdir9 } from "node:fs/promises";
 import { dirname as dirname10 } from "node:path";
 function createNoopAppLogger() {
   return {
@@ -16154,6 +16195,7 @@ function createNoopAppLogger() {
 function createAppLogger(options) {
   const now = options.now ?? (() => new Date);
   let writeChain = Promise.resolve();
+  let modeEnsured = false;
   return {
     debug: async (event, message, context) => {
       await enqueueWrite("debug", event, message, context);
@@ -16182,8 +16224,12 @@ function createAppLogger(options) {
     }
     const line = formatLogLine(now(), level, event, message, context);
     await mkdir9(dirname10(options.filePath), { recursive: true });
+    if (!modeEnsured) {
+      modeEnsured = true;
+      await chmod2(options.filePath, 384).catch(() => {});
+    }
     await rotateIfNeeded(options.filePath, Buffer.byteLength(line), options.maxSizeBytes, options.maxFiles);
-    await appendFile(options.filePath, line, "utf8");
+    await appendFile(options.filePath, line, { encoding: "utf8", mode: 384 });
   }
 }
 function formatLogLine(time3, level, event, message, context) {
@@ -23934,6 +23980,20 @@ class SessionService {
   async createSession(alias, agent, workspace) {
     return await this.createLogicalSession(alias, agent, workspace, `${workspace}:${alias}`);
   }
+  listAllResolvedSessions() {
+    const seen = new Set;
+    const resolved = [];
+    for (const session of Object.values(this.state.sessions)) {
+      if (seen.has(session.transport_session)) {
+        continue;
+      }
+      seen.add(session.transport_session);
+      try {
+        resolved.push(this.toResolvedSession(session));
+      } catch {}
+    }
+    return resolved;
+  }
   resolveSession(alias, agent, workspace, transportSession) {
     this.validateSession(alias, agent, workspace);
     return this.toResolvedSession({
@@ -24621,7 +24681,8 @@ async function spawnAcpxBridgeClient(options = {}) {
       ...process.env,
       WEACPX_BRIDGE_ACPX_COMMAND: options.acpxCommand ?? "acpx",
       WEACPX_BRIDGE_PERMISSION_MODE: options.permissionMode ?? "approve-all",
-      WEACPX_BRIDGE_NON_INTERACTIVE_PERMISSIONS: options.nonInteractivePermissions ?? "deny"
+      WEACPX_BRIDGE_NON_INTERACTIVE_PERMISSIONS: options.nonInteractivePermissions ?? "deny",
+      ...typeof options.queueOwnerTtlSeconds === "number" && Number.isFinite(options.queueOwnerTtlSeconds) ? { WEACPX_BRIDGE_QUEUE_OWNER_TTL_SECONDS: String(options.queueOwnerTtlSeconds) } : {}
     },
     stdio: ["pipe", "pipe", "inherit"]
   });
@@ -25049,7 +25110,7 @@ var init_spawn_command = __esm(() => {
 });
 
 // src/transport/prompt-media.ts
-import { mkdtemp, open as open3, rm as rm8, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdtemp, open as open4, rm as rm8, writeFile as writeFile7 } from "node:fs/promises";
 import { tmpdir as defaultTmpdir } from "node:os";
 import path14 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
@@ -25118,7 +25179,7 @@ async function writeStructuredPromptBlocks(blocks, deps) {
   }
 }
 async function readImageFileBounded(filePath, maxBytes) {
-  const handle = await open3(filePath, "r");
+  const handle = await open4(filePath, "r");
   try {
     const imageStats = await handle.stat();
     if (!imageStats.isFile()) {
@@ -25173,7 +25234,7 @@ var init_prompt_media = __esm(() => {
   defaultStructuredPromptFileDeps = {
     readImageFile: readImageFileBounded,
     mkdtemp,
-    writeFile: writeFile8,
+    writeFile: writeFile7,
     rm: rm8,
     tmpdir: defaultTmpdir
   };
@@ -25480,12 +25541,12 @@ function resolveNodePtyHelperPath(packageJsonPath, platform, arch) {
   }
   return join12(dirname12(packageJsonPath), "prebuilds", `${platform}-${arch}`, "spawn-helper");
 }
-async function ensureNodePtyHelperExecutable(helperPath, chmod2 = chmodFs) {
+async function ensureNodePtyHelperExecutable(helperPath, chmod3 = chmodFs) {
   if (!helperPath) {
     return;
   }
   try {
-    await chmod2(helperPath, 493);
+    await chmod3(helperPath, 493);
   } catch (error2) {
     if (error2.code === "ENOENT") {
       return;
@@ -25778,6 +25839,7 @@ class AcpxCliTransport {
   permissionMode;
   nonInteractivePermissions;
   permissionPolicy;
+  queueOwnerTtlSeconds;
   runCommand;
   runPtyCommand;
   queueOwnerLauncher;
@@ -25788,10 +25850,12 @@ class AcpxCliTransport {
     this.permissionMode = options.permissionMode ?? "approve-all";
     this.nonInteractivePermissions = options.nonInteractivePermissions ?? "deny";
     this.permissionPolicy = options.permissionPolicy;
+    this.queueOwnerTtlSeconds = options.queueOwnerTtlSeconds;
     this.runCommand = runCommand;
     this.runPtyCommand = runPtyCommand;
     this.queueOwnerLauncher = queueOwnerLauncher ?? new AcpxQueueOwnerLauncher({
-      acpxCommand: this.command
+      acpxCommand: this.command,
+      ...typeof this.queueOwnerTtlSeconds === "number" && Number.isFinite(this.queueOwnerTtlSeconds) ? { ttlMs: this.queueOwnerTtlSeconds * 1000 } : {}
     });
     this.streamingHooks = streamingHooks;
   }
@@ -26115,7 +26179,8 @@ ${baseText}` : "" };
       "--json-strict",
       "--cwd",
       session.cwd,
-      ...this.buildPermissionArgs()
+      ...this.buildPermissionArgs(),
+      ...this.buildQueueOwnerTtlArgs()
     ];
     const tail2 = promptFile ? ["prompt", "-s", session.transportSession, "--file", promptFile] : ["prompt", "-s", session.transportSession, text];
     if (session.agentCommand) {
@@ -26123,6 +26188,12 @@ ${baseText}` : "" };
     }
     return [...prefix, session.agent, ...tail2];
   }
+  buildQueueOwnerTtlArgs() {
+    if (typeof this.queueOwnerTtlSeconds !== "number" || !Number.isFinite(this.queueOwnerTtlSeconds)) {
+      return [];
+    }
+    return ["--ttl", String(this.queueOwnerTtlSeconds)];
+  }
   buildPermissionArgs() {
     const modeFlag = permissionModeToFlag(this.permissionMode);
     const args = [modeFlag, "--non-interactive-permissions", this.nonInteractivePermissions];
@@ -26169,6 +26240,146 @@ var init_acpx_cli_transport = __esm(() => {
   require4 = createRequire5(import.meta.url);
 });
 
+// src/transport/queue-owner-reaper.ts
+import { spawn as spawn10 } from "node:child_process";
+async function reapQueueOwners(acpxCommand, targets, deps = {}) {
+  const resolveRecordId = deps.resolveRecordId ?? defaultResolveRecordId;
+  const terminate = deps.terminate ?? terminateAcpxQueueOwner;
+  const timeoutMs = deps.timeoutMs ?? 5000;
+  const seen = new Set;
+  const unique = targets.filter((target) => {
+    if (seen.has(target.transportSession)) {
+      return false;
+    }
+    seen.add(target.transportSession);
+    return true;
+  });
+  let terminated = 0;
+  const reapOne = async (target) => {
+    try {
+      const recordId = await resolveRecordId(acpxCommand, target);
+      if (!recordId) {
+        return;
+      }
+      await terminate(recordId);
+      terminated += 1;
+    } catch (error2) {
+      deps.onError?.(target, error2);
+    }
+  };
+  await settleWithinTimeout(Promise.all(unique.map(reapOne)), timeoutMs);
+  return { terminated, attempted: unique.length };
+}
+function settleWithinTimeout(work, timeoutMs) {
+  return new Promise((resolve3) => {
+    let settled = false;
+    const finish = () => {
+      if (!settled) {
+        settled = true;
+        resolve3();
+      }
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+    work.then(() => {
+      clearTimeout(timer);
+      finish();
+    }, () => {
+      clearTimeout(timer);
+      finish();
+    });
+  });
+}
+async function defaultResolveRecordId(acpxCommand, target) {
+  const args = [
+    "--format",
+    "quiet",
+    "--cwd",
+    target.cwd,
+    ...target.agentCommand ? ["--agent", target.agentCommand] : [target.agent],
+    "sessions",
+    "show",
+    target.transportSession
+  ];
+  const spawnSpec = resolveSpawnCommand(acpxCommand, args);
+  const result = await runCapture2(spawnSpec.command, spawnSpec.args, 4000);
+  if (result.code !== 0) {
+    return null;
+  }
+  return parseRecordId(result.stdout);
+}
+function parseRecordId(stdout2) {
+  try {
+    const parsed = JSON.parse(stdout2);
+    if (typeof parsed.acpxRecordId === "string") {
+      return parsed.acpxRecordId;
+    }
+    if (typeof parsed.id === "string") {
+      return parsed.id;
+    }
+  } catch {
+    const firstLine = stdout2.trim().split(/\r?\n/, 1)[0];
+    if (firstLine && /^[\w.:-]+$/.test(firstLine) && firstLine.length >= 8) {
+      return firstLine;
+    }
+  }
+  return null;
+}
+function runCapture2(command, args, timeoutMs) {
+  return new Promise((resolve3) => {
+    const child = spawn10(command, args, { stdio: ["ignore", "pipe", "ignore"] });
+    let stdout2 = "";
+    let done = false;
+    const finish = (code) => {
+      if (done) {
+        return;
+      }
+      done = true;
+      clearTimeout(timer);
+      resolve3({ code, stdout: stdout2 });
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish(1);
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout2 += String(chunk);
+    });
+    child.once("error", () => finish(1));
+    child.once("close", (code) => finish(code ?? 1));
+  });
+}
+var init_queue_owner_reaper = __esm(() => {
+  init_spawn_command();
+  init_acpx_queue_owner_launcher();
+});
+
+// src/transport/collect-reap-targets.ts
+function workerBindingReapTargets(orchestration, config2) {
+  const targets = [];
+  for (const [workerSession, binding] of Object.entries(orchestration.workerBindings)) {
+    const agentConfig = config2.agents[binding.targetAgent];
+    if (!agentConfig) {
+      continue;
+    }
+    const cwd = binding.cwd ?? config2.workspaces[binding.workspace]?.cwd;
+    if (!cwd) {
+      continue;
+    }
+    const agentCommand = resolveAgentCommand(agentConfig.driver, agentConfig.command);
+    targets.push({
+      agent: binding.targetAgent,
+      ...agentCommand ? { agentCommand } : {},
+      cwd,
+      transportSession: workerSession
+    });
+  }
+  return targets;
+}
+var init_collect_reap_targets = () => {};
+
 // src/channels/channel-registry.ts
 var exports_channel_registry = {};
 __export(exports_channel_registry, {
@@ -26364,7 +26575,11 @@ function startProgressHeartbeat(orchestration, config2, logger2, channel) {
   if (thresholdSeconds <= 0) {
     return;
   }
+  let ticking = false;
   return setInterval(async () => {
+    if (ticking)
+      return;
+    ticking = true;
     try {
       const tasks = await orchestration.listHeartbeatTasks(thresholdSeconds);
       for (const task of tasks) {
@@ -26385,6 +26600,8 @@ function startProgressHeartbeat(orchestration, config2, logger2, channel) {
       await logger2.error("orchestration.heartbeat.check_failed", "heartbeat check failed", {
         message: error2 instanceof Error ? error2.message : String(error2)
       });
+    } finally {
+      ticking = false;
     }
   }, 60000);
 }
@@ -26437,7 +26654,8 @@ async function buildApp(paths, deps = {}) {
     acpxCommand,
     bridgeEntryPath: resolveBridgeEntryPath(),
     permissionMode: config2.transport.permissionMode,
-    nonInteractivePermissions: config2.transport.nonInteractivePermissions
+    nonInteractivePermissions: config2.transport.nonInteractivePermissions,
+    ...typeof config2.transport.queueOwnerTtlSeconds === "number" ? { queueOwnerTtlSeconds: config2.transport.queueOwnerTtlSeconds } : {}
   })))) : deps.createCliTransport?.(acpxCommand) ?? new AcpxCliTransport({ ...config2.transport, command: acpxCommand });
   const quota = new QuotaManager({
     onInbound: (chatKey) => {
@@ -26812,6 +27030,35 @@ async function buildApp(paths, deps = {}) {
         clearInterval(progressHeartbeatInterval);
       }
       await Promise.allSettled([...pendingWorkerDispatches]);
+      try {
+        const targets = [
+          ...sessions.listAllResolvedSessions().map((session) => ({
+            agent: session.agent,
+            ...session.agentCommand ? { agentCommand: session.agentCommand } : {},
+            cwd: session.cwd,
+            transportSession: session.transportSession
+          })),
+          ...workerBindingReapTargets(state.orchestration, config2)
+        ];
+        if (targets.length > 0) {
+          const { terminated, attempted } = await reapQueueOwners(acpxCommand, targets, {
+            onError: (target, error2) => {
+              logger2.info("transport.queue_owner_reap.failed", "failed to reap queue owner on shutdown", {
+                transport_session: target.transportSession,
+                error: error2 instanceof Error ? error2.message : String(error2)
+              }).catch(() => {});
+            }
+          });
+          await logger2.info("transport.queue_owner_reap.completed", "reaped warm queue owners on shutdown", {
+            terminated,
+            attempted
+          }).catch(() => {});
+        }
+      } catch (err) {
+        await logger2.error("transport.queue_owner_reap.error", "queue owner reap failed during shutdown", {
+          error: err instanceof Error ? err.message : String(err)
+        }).catch(() => {});
+      }
       await debouncedStateStore.dispose();
       if ("dispose" in transport && typeof transport.dispose === "function") {
         await transport.dispose();
@@ -26842,7 +27089,12 @@ async function main() {
     await ensureConfigExists(paths.configPath);
     const startupConfig = await loadConfig(paths.configPath);
     const { loadConfiguredPlugins: loadConfiguredPlugins2 } = await Promise.resolve().then(() => (init_plugin_loader(), exports_plugin_loader));
-    await loadConfiguredPlugins2({ plugins: startupConfig.plugins });
+    await loadConfiguredPlugins2({
+      plugins: startupConfig.plugins,
+      onPluginError: ({ name, error: error2 }) => {
+        console.error(`[weacpx] skipping plugin ${name}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      }
+    });
     const { channelDeps } = await prepareChannelMedia(paths.configPath, startupConfig);
     const channelRegistry = new MessageChannelRegistry(createMessageChannels2(startupConfig.channels, channelDeps));
     await runConsole(paths, {
@@ -26926,6 +27178,8 @@ var init_main = __esm(async () => {
   init_acpx_bridge_client();
   init_acpx_bridge_transport();
   init_acpx_cli_transport();
+  init_queue_owner_reaper();
+  init_collect_reap_targets();
   init_channel_registry();
   init_media_store();
   init_quota_errors();
@@ -26936,7 +27190,7 @@ var init_main = __esm(async () => {
 });
 
 // src/doctor/checks/acpx-check.ts
-import { spawn as spawn10 } from "node:child_process";
+import { spawn as spawn11 } from "node:child_process";
 async function checkAcpx(options = {}) {
   const runtimePaths = (options.resolveRuntimePaths ?? resolveRuntimePaths)();
   try {
@@ -26983,7 +27237,7 @@ function buildDetails(metadata, version2, verbose) {
 async function defaultRunVersion(command) {
   const spawnSpec = resolveSpawnCommand(command, ["--version"]);
   return await new Promise((resolve3, reject) => {
-    const child = spawn10(spawnSpec.command, spawnSpec.args, {
+    const child = spawn11(spawnSpec.command, spawnSpec.args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout2 = "";
@@ -28004,7 +28258,7 @@ import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // src/daemon/daemon-runtime.ts
 init_daemon_status();
-import { mkdir as mkdir5, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir5, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
 import { dirname as dirname5 } from "node:path";
 
 class DaemonRuntime {
@@ -28032,7 +28286,7 @@ class DaemonRuntime {
       stderr_log: this.paths.stderrLog
     };
     await mkdir5(dirname5(this.paths.pidFile), { recursive: true });
-    await writeFile4(this.paths.pidFile, `${this.options.pid}
+    await writeFile3(this.paths.pidFile, `${this.options.pid}
 `);
     await this.statusStore.save(this.currentStatus);
   }
@@ -43916,7 +44170,12 @@ async function defaultRun(options = {}) {
   await ensureConfigExists(runtimePaths.configPath);
   const config2 = await loadConfig(runtimePaths.configPath);
   const { loadConfiguredPlugins: loadConfiguredPlugins2 } = await Promise.resolve().then(() => (init_plugin_loader(), exports_plugin_loader));
-  await loadConfiguredPlugins2({ plugins: config2.plugins });
+  await loadConfiguredPlugins2({
+    plugins: config2.plugins,
+    onPluginError: ({ name, error: error2 }) => {
+      console.error(`[weacpx] skipping plugin ${name}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    }
+  });
   const { createMessageChannels: createMessageChannels2 } = await Promise.resolve().then(() => (init_create_channel(), exports_create_channel));
   const { MessageChannelRegistry: MessageChannelRegistry2 } = await Promise.resolve().then(() => (init_channel_registry(), exports_channel_registry));
   const daemonPaths = resolveDaemonPathsForCurrentConfig();

package/dist/config/types.d.ts

@@ -19,6 +19,13 @@ export interface TransportConfig {
     permissionMode: PermissionMode;
     nonInteractivePermissions: NonInteractivePermissions;
     permissionPolicy?: string;
+    /**
+     * Idle TTL (seconds) passed to acpx as `--ttl` on prompt commands. Governs how
+     * long the acpx queue owner (and the warm ACP agent it holds) survives between
+     * prompts, so follow-up messages in a conversation skip the agent cold start.
+     * `0` keeps the owner alive forever. Defaults to 1800 (30 min).
+     */
+    queueOwnerTtlSeconds?: number;
 }
 export type LoggingLevel = "error" | "info" | "debug";
 export interface PerfLogConfig {

package/dist/util/private-file.d.ts

@@ -0,0 +1,26 @@
+export declare function writePrivateFileAtomic(path: string, content: string): Promise<void>;
+/**
+ * Synchronous private-file write for hot-path callers that cannot await
+ * (e.g. per-message weixin credential/sync-buf/context-token persistence).
+ * Atomic via write-file-atomic's temp+rename, created at 0600 so the secret is
+ * never momentarily world-readable. No cross-process lock: weixin's per-account
+ * consumer lock already serializes the single writing daemon.
+ */
+interface WritePrivateFileSyncDeps {
+    platform?: NodeJS.Platform;
+    atomicWrite?: (path: string, content: string) => void;
+    directWrite?: (path: string, content: string) => void;
+}
+export declare function writePrivateFileSync(path: string, content: string, deps?: WritePrivateFileSyncDeps): void;
+interface RetryTransientWriteOptions {
+    platform?: NodeJS.Platform;
+    maxAttempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    delay?: (ms: number) => Promise<void>;
+}
+export declare function retryTransientWriteErrors(run: () => Promise<void>, options?: RetryTransientWriteOptions): Promise<void>;
+export declare const __privateFileForTests: {
+    retryTransientWriteErrors: typeof retryTransientWriteErrors;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weacpx",
-  "version": "0.4.9",
+  "version": "0.4.10",
   "description": "使用微信 ClawBot 随时随地通过 `acpx` 控制 Claude Code、Codex 等 Agents。",
   "keywords": [
     "acpx",