weacpx 0.2.1 → 0.2.2

package/dist/bridge/bridge-main.js

@@ -276,6 +276,39 @@ function normalizeBridgeNonInteractivePermissions(value) {
 // src/bridge/bridge-server.ts
 init_prompt_output();
 
+// src/bridge/bridge-request-scheduler.ts
+class BridgeRequestScheduler {
+  sessions = new Map;
+  run(sessionName, lane, task) {
+    if (lane === "control") {
+      return Promise.resolve().then(task);
+    }
+    const state = this.sessions.get(sessionName) ?? this.createSessionState(sessionName);
+    state.pendingNormals += 1;
+    const result = state.tail.then(() => task());
+    state.tail = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return result.finally(() => {
+      state.pendingNormals -= 1;
+      if (state.pendingNormals === 0 && this.sessions.get(sessionName) === state) {
+        this.sessions.delete(sessionName);
+      }
+    });
+  }
+  createSessionState(sessionName) {
+    const state = {
+      pendingNormals: 0,
+      tail: Promise.resolve()
+    };
+    this.sessions.set(sessionName, state);
+    return state;
+  }
+}
+
+// src/bridge/bridge-server.ts
 class BridgeInvalidRequestError extends Error {
 }
 var BRIDGE_METHODS = new Set([
@@ -288,9 +321,11 @@ var BRIDGE_METHODS = new Set([
   "setMode",
   "cancel"
 ]);
+var SESSION_SCOPED_METHODS = new Set(["hasSession", "ensureSession", "prompt", "setMode", "cancel"]);
 
 class BridgeServer {
   runtime;
+  scheduler = new BridgeRequestScheduler;
   constructor(runtime) {
     this.runtime = runtime;
   }
@@ -299,7 +334,7 @@ class BridgeServer {
     try {
       const request = parseBridgeRequest(line);
       requestId = request.id;
-      const result = await this.dispatch(request.id, request.method, request.params, writeLine);
+      const result = await this.dispatchRequest(request.id, request.method, request.params, writeLine);
       return `${JSON.stringify({
         id: request.id,
         ok: true,
@@ -326,6 +361,21 @@ class BridgeServer {
 `;
     }
   }
+  async dispatchRequest(requestId, method, params, writeLine) {
+    if (!SESSION_SCOPED_METHODS.has(method)) {
+      return await this.dispatch(requestId, method, params, writeLine);
+    }
+    const sessionName = getSessionName(params);
+    if (!sessionName) {
+      return await this.dispatch(requestId, method, params, writeLine);
+    }
+    const sessionKey = getSessionScheduleKey(params);
+    if (!sessionKey) {
+      return await this.dispatch(requestId, method, params, writeLine);
+    }
+    const lane = method === "cancel" ? "control" : "normal";
+    return await this.scheduler.run(sessionKey, lane, () => this.dispatch(requestId, method, params, writeLine));
+  }
   async dispatch(requestId, method, params, writeLine) {
     switch (method) {
       case "ping":
@@ -431,6 +481,24 @@ function parseBridgeRequest(line) {
     params
   };
 }
+function getSessionName(params) {
+  return asNonEmptyString(params.name);
+}
+function getSessionScheduleKey(params) {
+  const name = asNonEmptyString(params.name);
+  const cwd = asNonEmptyString(params.cwd);
+  const agentIdentity = asNonEmptyString(params.agentCommand) ?? asNonEmptyString(params.agent);
+  if (!name || !cwd || !agentIdentity) {
+    return;
+  }
+  return JSON.stringify([agentIdentity, cwd, name]);
+}
+function asNonEmptyString(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return;
+  }
+  return value;
+}
 function requireString(params, key) {
   const value = params[key];
   if (typeof value !== "string" || value.length === 0) {
@@ -733,17 +801,53 @@ async function tryRepairAcpxSessionIndex() {
 }
 
 // src/bridge/bridge-main.ts
-var 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)
-}));
-var input = createInterface({
-  input: process.stdin,
-  crlfDelay: Infinity
-});
-for await (const line of input) {
-  const response = await server.handleLine(line, (chunk) => {
-    process.stdout.write(chunk);
+async function processBridgeInput(options) {
+  const pendingWrites = new Set;
+  let firstError;
+  for await (const line of options.input) {
+    const pendingWrite = (async () => {
+      const response = await options.server.handleLine(line, (chunk) => {
+        options.write(chunk);
+      });
+      options.write(response);
+    })();
+    const observedPendingWrite = pendingWrite.catch((error) => {
+      if (firstError === undefined) {
+        firstError = error;
+        options.input.close();
+      }
+    });
+    pendingWrites.add(pendingWrite);
+    observedPendingWrite.finally(() => {
+      pendingWrites.delete(pendingWrite);
+    });
+  }
+  await Promise.allSettled(pendingWrites);
+  if (firstError !== undefined) {
+    throw firstError;
+  }
+}
+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)
+  }));
+  const input = createInterface({
+    input: process.stdin,
+    crlfDelay: Infinity
+  });
+  await processBridgeInput({
+    input,
+    server,
+    write: (chunk) => {
+      process.stdout.write(chunk);
+    }
   });
-  process.stdout.write(response);
 }
+if (__require.main == __require.module) {
+  await runBridgeMain();
+}
+export {
+  runBridgeMain,
+  processBridgeInput
+};

package/dist/cli.js

@@ -2423,6 +2423,47 @@ var init_session_guard = __esm(() => {
   pauseUntilMap = new Map;
 });
 
+// src/weixin/messaging/conversation-executor.ts
+function createConversationExecutor() {
+  const states = new Map;
+  const getState = (conversationId) => {
+    const existing = states.get(conversationId);
+    if (existing)
+      return existing;
+    const created = { activeControls: 0 };
+    states.set(conversationId, created);
+    return created;
+  };
+  const cleanupState = (conversationId, state) => {
+    if (!state.normalTail && state.activeControls === 0) {
+      states.delete(conversationId);
+    }
+  };
+  return {
+    run(conversationId, lane, task) {
+      const state = getState(conversationId);
+      if (lane === "control") {
+        state.activeControls += 1;
+        return Promise.resolve().then(task).finally(() => {
+          state.activeControls -= 1;
+          cleanupState(conversationId, state);
+        });
+      }
+      const previous = state.normalTail ?? Promise.resolve();
+      const next = previous.catch(() => {
+        return;
+      }).then(task);
+      state.normalTail = next;
+      return next.finally(() => {
+        if (state.normalTail === next) {
+          state.normalTail = undefined;
+        }
+        cleanupState(conversationId, state);
+      });
+    }
+  };
+}
+
 // src/weixin/api/types.ts
 var UploadMediaType, MessageType, MessageItemType, MessageState, TypingStatus;
 var init_types = __esm(() => {
@@ -3360,6 +3401,10 @@ function extractTextBody(itemList) {
   }
   return "";
 }
+function getWeixinMessageTurnLane(full) {
+  const textBody = extractTextBody(full.item_list).trim().toLowerCase();
+  return textBody === "/cancel" || textBody === "/stop" ? "control" : "normal";
+}
 function findMediaItem(itemList) {
   if (!itemList?.length)
     return;
@@ -3611,6 +3656,7 @@ async function monitorWeixinProvider(opts) {
     log(`[weixin] no previous sync buf, starting fresh`);
   }
   const configManager = new WeixinConfigManager({ baseUrl, token }, log);
+  const conversationExecutor = createConversationExecutor();
   const seenMessageIds = new Set;
   const messageIdOrder = [];
   const DEDUP_WINDOW = 100;
@@ -3672,7 +3718,7 @@ async function monitorWeixinProvider(opts) {
         aLog.info(`inbound: from=${full.from_user_id} types=${full.item_list?.map((i) => i.type).join(",") ?? "none"}`);
         const fromUserId = full.from_user_id ?? "";
         const cachedConfig = await configManager.getForUser(fromUserId, full.context_token);
-        await handleWeixinMessageTurn(full, {
+        conversationExecutor.run(full.from_user_id ?? "", getWeixinMessageTurnLane(full), () => handleWeixinMessageTurn(full, {
           accountId,
           agent,
           baseUrl,
@@ -3681,6 +3727,8 @@ async function monitorWeixinProvider(opts) {
           typingTicket: cachedConfig.typingTicket,
           log,
           errLog
+        })).catch((err) => {
+          errLog(`[weixin] message turn failed: ${String(err)}`);
         });
       }
     } catch (err) {
@@ -4852,6 +4900,11 @@ async function handleCancel(context, chatKey) {
     const result = await context.interaction.cancelTransportSession(session);
     return { text: result.message || "cancelled" };
   } catch (error) {
+    const recovered = await context.recovery.tryRecoverMissingSession(session, error);
+    if (recovered) {
+      const result = await context.interaction.cancelTransportSession(recovered);
+      return { text: result.message || "cancelled" };
+    }
     return context.recovery.renderTransportError(session, error);
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "weacpx",
   "description": "使用微信 ClawBot 随时随地通过 `acpx` 控制 Claude Code、Codex 等 Agents。",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "main": "index.js",
   "directories": {
     "doc": "docs",