weacpx 0.3.1 → 0.4.0-beta.0

package/dist/weixin/messaging/inbound.d.ts

@@ -0,0 +1,63 @@
+import type { ChannelMediaKind } from "../../channels/media-types.js";
+import type { WeixinMessage, MessageItem } from "../api/types.js";
+/** Store a context token for a given account+user pair. */
+export declare function setContextToken(accountId: string, userId: string, token: string): void;
+/** Retrieve the cached context token for a given account+user pair. */
+export declare function getContextToken(accountId: string, userId: string): string | undefined;
+/** Strip the `weixin:accountId:` prefix from a chat key, returning the bare user id. */
+export declare function normalizeWeixinUserIdFromChatKey(chatKey: string): string;
+/** Inbound context passed to the OpenClaw core pipeline (matches MsgContext shape). */
+export type WeixinMsgContext = {
+    Body: string;
+    From: string;
+    To: string;
+    AccountId: string;
+    OriginatingChannel: "openclaw-weixin";
+    OriginatingTo: string;
+    MessageSid: string;
+    Timestamp?: number;
+    Provider: "openclaw-weixin";
+    ChatType: "direct";
+    /** Set by monitor after resolveAgentRoute so dispatchReplyFromConfig uses the correct session. */
+    SessionKey?: string;
+    context_token?: string;
+    MediaUrl?: string;
+    MediaPath?: string;
+    MediaType?: string;
+    /** Raw message body for framework command authorization. */
+    CommandBody?: string;
+    /** Whether the sender is authorized to execute slash commands. */
+    CommandAuthorized?: boolean;
+};
+/** Returns true if the message item is a media type (image, video, file, or voice). */
+export declare function isMediaItem(item: MessageItem): boolean;
+export declare function bodyFromItemList(itemList?: MessageItem[]): string;
+export type WeixinInboundMediaOpts = {
+    /** Local path to decrypted image file. */
+    decryptedPicPath?: string;
+    /** Local path to transcoded/raw voice file (.wav or .silk). */
+    decryptedVoicePath?: string;
+    /** MIME type for the voice file (e.g. "audio/wav" or "audio/silk"). */
+    voiceMediaType?: string;
+    /** Local path to decrypted file attachment. */
+    decryptedFilePath?: string;
+    /** MIME type for the file attachment (guessed from file_name). */
+    fileMediaType?: string;
+    /** Local path to decrypted video file. */
+    decryptedVideoPath?: string;
+};
+/**
+ * Convert a WeixinMessage from getUpdates to the inbound MsgContext for the core pipeline.
+ * Media: only pass MediaPath (local file, after CDN download + decrypt).
+ * We never pass MediaUrl — the upstream CDN URL is encrypted/auth-only.
+ * Priority when multiple media types present: image > video > file > voice.
+ */
+export declare function weixinMessageToMsgContext(msg: WeixinMessage, accountId: string, opts?: WeixinInboundMediaOpts): WeixinMsgContext;
+/** Extract the context_token from an inbound WeixinMsgContext. */
+export declare function getContextTokenFromMsgContext(ctx: WeixinMsgContext): string | undefined;
+export interface WeixinInboundMediaDescriptor {
+    item: MessageItem;
+    kind: ChannelMediaKind;
+    fileName?: string;
+}
+export declare function extractWeixinMediaDescriptors(itemList?: MessageItem[]): WeixinInboundMediaDescriptor[];

package/dist/weixin/messaging/orchestration-notice-accounts.d.ts

@@ -0,0 +1,2 @@
+import type { OrchestrationTaskRecord } from "../../orchestration/orchestration-types";
+export declare function resolveOrchestrationNoticeAccountIds(task: Pick<OrchestrationTaskRecord, "accountId" | "deliveryAccountId">, availableAccountIds: string[]): string[];

package/dist/weixin/messaging/quota-errors.d.ts

@@ -0,0 +1,8 @@
+export declare class QuotaDeferredError extends Error {
+    readonly chatKey: string;
+    constructor(input: {
+        chatKey: string;
+        reason: string;
+    });
+}
+export declare function isQuotaDeferredError(error: unknown): error is QuotaDeferredError;

package/dist/weixin/messaging/quota-manager.d.ts

@@ -0,0 +1,44 @@
+export declare const MID_BUDGET = 6;
+export declare const FINAL_BUDGET = 4;
+export interface PendingFinalChunk {
+    /** Pre-formatted body, already carrying the (k/N) pagination prefix. */
+    text: string;
+    /** 1-based chunk index. */
+    seq: number;
+    /** Total chunk count for this final answer. */
+    total: number;
+    contextToken?: string;
+    accountId?: string;
+}
+export interface QuotaSnapshot {
+    remaining: number;
+    midUsed: number;
+    finalUsed: number;
+    midRemaining: number;
+    finalRemaining: number;
+}
+export interface QuotaObserver {
+    onInbound?(chatKey: string): void;
+    onMidReserved?(chatKey: string, snapshot: QuotaSnapshot): void;
+    onMidRejected?(chatKey: string, snapshot: QuotaSnapshot): void;
+    onFinalReserved?(chatKey: string, snapshot: QuotaSnapshot): void;
+    onFinalRejected?(chatKey: string, snapshot: QuotaSnapshot): void;
+}
+export declare class QuotaManager {
+    private readonly states;
+    private readonly observer;
+    private readonly normalizeKey;
+    constructor(observer?: QuotaObserver, normalizeKey?: (key: string) => string);
+    onInbound(chatKey: string): void;
+    reserveMidSegment(chatKey: string): boolean;
+    reserveFinal(chatKey: string): boolean;
+    finalRemaining(chatKey: string): number;
+    enqueuePendingFinal(chatKey: string, chunks: PendingFinalChunk[]): void;
+    prependPendingFinal(chatKey: string, chunks: PendingFinalChunk[]): void;
+    drainPendingFinalUpToBudget(chatKey: string, available: number): PendingFinalChunk[];
+    hasPendingFinal(chatKey: string): boolean;
+    countPendingFinal(chatKey: string): number;
+    clearPendingFinal(chatKey: string): void;
+    snapshot(chatKey: string): QuotaSnapshot;
+    private getOrCreate;
+}

package/dist/weixin/messaging/send-errors.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Structured error type for failed Weixin API calls.
+ *
+ * Two ways the API signals failure:
+ * 1. Non-2xx HTTP status (network / gateway).
+ * 2. 2xx HTTP with a JSON body whose `errcode` is non-zero (logical failure,
+ *    e.g. quota exhausted, invalid context_token, expired session). The
+ *    original implementation only handled case 1, so logical failures
+ *    appeared as silent successes — that is why "10 reply quota exhausted"
+ *    never showed up in the logs.
+ */
+export declare class WeixinSendError extends Error {
+    readonly endpoint: string;
+    readonly httpStatus: number;
+    readonly errcode?: number;
+    readonly errmsg?: string;
+    readonly textPreview: string;
+    constructor(input: {
+        endpoint: string;
+        httpStatus: number;
+        errcode?: number;
+        errmsg?: string;
+        textPreview: string;
+    });
+}
+/** Type guard for callers that need to read structured fields. */
+export declare function isWeixinSendError(error: unknown): error is WeixinSendError;
+/**
+ * Extract structured fields from any error for logging context.
+ * Returns sparse object so spreading into log context only adds what we know.
+ */
+export declare function describeWeixinSendError(error: unknown): {
+    message: string;
+    errcode?: number;
+    errmsg?: string;
+    httpStatus?: number;
+    endpoint?: string;
+    textPreview?: string;
+};

package/dist/weixin/messaging/send-media.d.ts

@@ -0,0 +1,23 @@
+import type { WeixinApiOptions } from "../api/api.js";
+import type { OutboundChannelMedia } from "../../channels/media-types.js";
+/**
+ * Upload a local file and send it as a weixin message, routing by MIME type:
+ *   video/*  → uploadVideoToWeixin        + sendVideoMessageWeixin
+ *   image/*  → uploadFileToWeixin         + sendImageMessageWeixin
+ *   else     → uploadFileAttachmentToWeixin + sendFileMessageWeixin
+ *
+ * Used by both the auto-reply deliver path (monitor.ts) and the outbound
+ * sendMedia path (channel.ts) so they stay in sync.
+ */
+export declare function sendWeixinMediaFile(params: {
+    media?: OutboundChannelMedia;
+    filePath: string;
+    to: string;
+    text: string;
+    opts: WeixinApiOptions & {
+        contextToken?: string;
+    };
+    cdnBaseUrl: string;
+}): Promise<{
+    messageId: string;
+}>;

package/dist/weixin/messaging/send-orchestration-notice.d.ts

@@ -0,0 +1,10 @@
+import type { OrchestrationTaskRecord } from "../../orchestration/orchestration-types";
+import { sendMessageWeixin } from "./send.js";
+interface NoticeDeps {
+    baseUrl: string;
+    token?: string;
+    contextToken: string;
+    sendMessage?: typeof sendMessageWeixin;
+}
+export declare function sendOrchestrationTaskNotice(task: OrchestrationTaskRecord, deps: NoticeDeps): Promise<void>;
+export {};

package/dist/weixin/messaging/send.d.ts

@@ -0,0 +1,71 @@
+import type { WeixinApiOptions } from "../api/api.js";
+import type { UploadedFileInfo } from "../cdn/upload.js";
+export declare function generateClientId(): string;
+/**
+ * Convert markdown-formatted model reply to plain text for Weixin delivery.
+ * Preserves newlines; strips markdown syntax.
+ */
+export declare function markdownToPlainText(text: string): string;
+/**
+ * Send a plain text message downstream.
+ * contextToken is required for all reply sends; missing it breaks conversation association.
+ */
+export declare function sendMessageWeixin(params: {
+    to: string;
+    text: string;
+    opts: WeixinApiOptions & {
+        contextToken?: string;
+    };
+}): Promise<{
+    messageId: string;
+}>;
+/**
+ * Send an image message downstream using a previously uploaded file.
+ * Optionally include a text caption as a separate TEXT item before the image.
+ *
+ * ImageItem fields:
+ *   - media.encrypt_query_param: CDN download param
+ *   - media.aes_key: AES key, base64-encoded
+ *   - mid_size: original ciphertext file size
+ */
+export declare function sendImageMessageWeixin(params: {
+    to: string;
+    text: string;
+    uploaded: UploadedFileInfo;
+    opts: WeixinApiOptions & {
+        contextToken?: string;
+    };
+}): Promise<{
+    messageId: string;
+}>;
+/**
+ * Send a video message downstream using a previously uploaded file.
+ * VideoItem: media (CDN ref), video_size (ciphertext bytes).
+ * Includes an optional text caption sent as a separate TEXT item first.
+ */
+export declare function sendVideoMessageWeixin(params: {
+    to: string;
+    text: string;
+    uploaded: UploadedFileInfo;
+    opts: WeixinApiOptions & {
+        contextToken?: string;
+    };
+}): Promise<{
+    messageId: string;
+}>;
+/**
+ * Send a file attachment downstream using a previously uploaded file.
+ * FileItem: media (CDN ref), file_name, len (plaintext bytes as string).
+ * Includes an optional text caption sent as a separate TEXT item first.
+ */
+export declare function sendFileMessageWeixin(params: {
+    to: string;
+    text: string;
+    fileName: string;
+    uploaded: UploadedFileInfo;
+    opts: WeixinApiOptions & {
+        contextToken?: string;
+    };
+}): Promise<{
+    messageId: string;
+}>;

package/dist/weixin/messaging/slash-commands.d.ts

@@ -0,0 +1,40 @@
+import type { PendingFinalChunk } from "./quota-manager.js";
+export interface SlashCommandResult {
+    /** 是否是斜杠指令（true 表示已处理，不需要继续走 AI） */
+    handled: boolean;
+}
+export interface SlashCommandContext {
+    to: string;
+    contextToken?: string;
+    baseUrl: string;
+    token?: string;
+    accountId: string;
+    log: (msg: string) => void;
+    errLog: (msg: string) => void;
+    /** Called when /clear is invoked to reset the agent session. */
+    onClear?: () => void | Promise<void>;
+    hasPendingFinal?: (chatKey: string) => boolean;
+    drainPendingFinal?: (chatKey: string, available: number) => PendingFinalChunk[];
+    prependPendingFinal?: (chatKey: string, chunks: PendingFinalChunk[]) => void;
+    reserveFinal?: (chatKey: string) => boolean;
+    finalRemaining?: (chatKey: string) => number;
+    sendText?: (params: {
+        to: string;
+        text: string;
+        contextToken?: string;
+    }) => Promise<void>;
+}
+/**
+ * v1.4: drain the next wave of pending paginated-final chunks parked by an
+ * earlier inbound's overflow. Sends up to `finalRemaining(chatKey)` chunks; if
+ * any chunks remain after the wave, appends a heads-up tail to this wave's
+ * last chunk so the user knows another `/jx` will pull more. No-op when there
+ * is nothing pending or the wiring is incomplete.
+ */
+export declare function drainPendingFinalForJx(ctx: SlashCommandContext): Promise<void>;
+/**
+ * 尝试处理斜杠指令
+ *
+ * @returns handled=true 表示该消息已作为指令处理，不需要继续走 AI 管道
+ */
+export declare function handleSlashCommand(content: string, ctx: SlashCommandContext, receivedAt: number, eventTimestamp?: number): Promise<SlashCommandResult>;

package/dist/weixin/monitor/consumer-lock.d.ts

@@ -0,0 +1,24 @@
+export interface WeixinConsumerLockMetadata {
+    pid: number;
+    mode: "foreground" | "daemon";
+    startedAt: string;
+    configPath: string;
+    statePath: string;
+    hostname?: string;
+}
+export interface WeixinConsumerLock {
+    acquire: (meta: WeixinConsumerLockMetadata) => Promise<void>;
+    release: () => Promise<void>;
+}
+export declare class ActiveWeixinConsumerLockError extends Error {
+    readonly existing: WeixinConsumerLockMetadata;
+    readonly lockFilePath: string;
+    constructor(lockFilePath: string, existing: WeixinConsumerLockMetadata);
+}
+interface CreateWeixinConsumerLockOptions {
+    lockFilePath?: string;
+    isProcessRunning?: (pid: number) => boolean;
+    onDiagnostic?: (event: "lock_exists" | "lock_invalid_removed" | "lock_stale_removed" | "lock_active_conflict" | "lock_acquired" | "lock_released", context: Record<string, string | number | boolean | undefined>) => void | Promise<void>;
+}
+export declare function createWeixinConsumerLock(options?: CreateWeixinConsumerLockOptions): WeixinConsumerLock;
+export {};

package/dist/weixin/monitor/monitor.d.ts

@@ -0,0 +1,28 @@
+import type { Agent } from "../agent/interface.js";
+import type { PendingFinalChunk } from "../messaging/quota-manager.js";
+import type { RuntimeMediaStore } from "../../channels/media-store.js";
+export type MonitorWeixinOpts = {
+    baseUrl: string;
+    cdnBaseUrl: string;
+    token?: string;
+    accountId: string;
+    agent: Agent;
+    abortSignal?: AbortSignal;
+    longPollTimeoutMs?: number;
+    log?: (msg: string) => void;
+    onInbound?: (chatKey: string) => void;
+    reserveFinal?: (chatKey: string) => boolean;
+    finalRemaining?: (chatKey: string) => number;
+    hasPendingFinal?: (chatKey: string) => boolean;
+    drainPendingFinal?: (chatKey: string, available: number) => PendingFinalChunk[];
+    prependPendingFinal?: (chatKey: string, chunks: PendingFinalChunk[]) => void;
+    enqueuePendingFinal?: (chatKey: string, chunks: PendingFinalChunk[]) => void;
+    dropPendingFinal?: (chatKey: string) => void;
+    mediaStore?: RuntimeMediaStore;
+    allowedMediaRoots?: string[];
+};
+/**
+ * Long-poll loop: getUpdates → process message → call agent → send reply.
+ * Runs until aborted.
+ */
+export declare function monitorWeixinProvider(opts: MonitorWeixinOpts): Promise<void>;

package/dist/weixin/storage/state-dir.d.ts

@@ -0,0 +1,2 @@
+/** Resolve the OpenClaw state directory (mirrors core logic in src/infra). */
+export declare function resolveStateDir(): string;

package/dist/weixin/storage/sync-buf.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Path to the persistent get_updates_buf file for an account.
+ * Stored alongside account data: ~/.openclaw/openclaw-weixin/accounts/{accountId}.sync.json
+ */
+export declare function getSyncBufFilePath(accountId: string): string;
+export type SyncBufData = {
+    get_updates_buf: string;
+};
+/**
+ * Load persisted get_updates_buf.
+ * Falls back in order:
+ *   1. Primary path (normalized accountId, new installs)
+ *   2. Compat path (raw accountId derived from pattern, old installs)
+ *   3. Legacy single-account path (very old installs without multi-account support)
+ */
+export declare function loadGetUpdatesBuf(filePath: string): string | undefined;
+/**
+ * Persist get_updates_buf. Creates parent dir if needed.
+ */
+export declare function saveGetUpdatesBuf(filePath: string, getUpdatesBuf: string): void;

package/dist/weixin/util/logger.d.ts

@@ -0,0 +1,14 @@
+/** Dynamically change the minimum log level at runtime. */
+export declare function setLogLevel(level: string): void;
+export type Logger = {
+    info(message: string): void;
+    debug(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    /** Returns a child logger whose messages are prefixed with `[accountId]`. */
+    withAccount(accountId: string): Logger;
+    /** Returns the current main log file path. */
+    getLogFilePath(): string;
+    close(): void;
+};
+export declare const logger: Logger;

package/dist/weixin/util/random.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Generate a prefixed unique ID using timestamp + crypto random bytes.
+ * Format: `{prefix}:{timestamp}-{8-char hex}`
+ */
+export declare function generateId(prefix: string): string;
+/**
+ * Generate a temporary file name with random suffix.
+ * Format: `{prefix}-{timestamp}-{8-char hex}{ext}`
+ */
+export declare function tempFileName(prefix: string, ext: string): string;

package/dist/weixin/util/redact.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Truncate a string, appending a length indicator when trimmed.
+ * Returns `""` for empty/undefined input.
+ */
+export declare function truncate(s: string | undefined, max: number): string;
+/**
+ * Redact a token/secret: show only the first few chars + total length.
+ * Returns `"(none)"` when absent.
+ */
+export declare function redactToken(token: string | undefined, prefixLen?: number): string;
+/**
+ * Redact a JSON body string for safe logging. JSON objects are structurally
+ * sanitized so secrets and user-authored message bodies are not written to
+ * disk. Non-JSON payloads fall back to length-bounded truncation.
+ */
+export declare function redactBody(body: string | undefined, maxLen?: number): string;
+/**
+ * Strip query string (which often contains signatures/tokens) from a URL,
+ * keeping only origin + pathname.
+ */
+export declare function redactUrl(rawUrl: string): string;

package/package.json

@@ -1,39 +1,56 @@
 {
   "name": "weacpx",
+  "version": "0.4.0-beta.0",
   "description": "使用微信 ClawBot 随时随地通过 `acpx` 控制 Claude Code、Codex 等 Agents。",
-  "version": "0.3.1",
-  "main": "index.js",
-  "directories": {
-    "doc": "docs",
-    "test": "tests"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/gadzan/weacpx.git"
-  },
   "keywords": [
     "acpx",
     "weixin-agent-sdk",
     "openclaw",
-    "weixin"
+    "weixin",
+    "yuanbao",
+    "feishu"
   ],
   "author": "gadzan",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/gadzan/weacpx/issues"
   },
-  "homepage": "https://github.com/gadzan/weacpx#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gadzan/weacpx.git"
+  },
   "type": "module",
   "bin": {
-    "weacpx": "dist/cli.js"
+    "weacpx": "./dist/cli.js"
+  },
+  "exports": {
+    "./plugin-api": {
+      "types": "./dist/plugin-api.d.ts",
+      "default": "./dist/plugin-api.js"
+    }
   },
   "files": [
     "dist",
     "README.md",
     "config.example.json"
   ],
+  "workspaces": [
+    "packages/*"
+  ],
   "scripts": {
-    "build": "bun build ./src/cli.ts ./src/bridge/bridge-main.ts --outdir ./dist --target node --external node-pty",
+    "clean:dist": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "clean:channel-yuanbao": "node -e \"require('node:fs').rmSync('packages/channel-yuanbao/dist',{recursive:true,force:true})\"",
+    "clean:channel-feishu": "node -e \"require('node:fs').rmSync('packages/channel-feishu/dist',{recursive:true,force:true})\"",
+    "build": "bun run clean:dist && bun build ./src/cli.ts ./src/bridge/bridge-main.ts ./src/plugin-api.ts --outdir ./dist --target node --external node-pty && bun run build:plugin-api",
+    "build:plugin-api": "tsc -p tsconfig.plugin-api.json",
+    "build:channel-yuanbao": "bun run build:plugin-api && bun run clean:channel-yuanbao && bun build ./packages/channel-yuanbao/src/index.ts --outdir ./packages/channel-yuanbao/dist --target node --external weacpx && tsc -p packages/channel-yuanbao/tsconfig.json",
+    "build:channel-feishu": "bun run build:plugin-api && bun run clean:channel-feishu && bun build ./packages/channel-feishu/src/index.ts --outdir ./packages/channel-feishu/dist --target node --external weacpx && tsc -p packages/channel-feishu/tsconfig.json",
+    "build:packages": "bun run build && bun run build:channel-yuanbao && bun run build:channel-feishu",
+    "verify:publish": "bun run build:packages && node ./scripts/verify-publish.mjs",
+    "publish:weacpx": "bun publish --cwd .",
+    "publish:channel-feishu": "bun publish --cwd packages/channel-feishu --access public",
+    "publish:channel-yuanbao": "bun publish --cwd packages/channel-yuanbao --access public",
+    "publish:plugins": "bun run publish:channel-yuanbao && bun run publish:channel-feishu",
     "dev": "bun run ./src/cli.ts run",
     "dry-run": "bun run ./src/dry-run.ts",
     "login": "bun run ./src/cli.ts login",
@@ -43,13 +60,18 @@
     "daemon:stop": "bun run ./src/cli.ts stop",
     "test": "node ./scripts/run-tests.mjs",
     "test:unit": "node ./scripts/run-tests.mjs tests/unit",
-    "test:smoke": "node ./scripts/run-tests.mjs tests/smoke"
+    "test:smoke": "node ./scripts/run-tests.mjs tests/smoke",
+    "smoke:local-install": "node ./scripts/smoke-local-install.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.19.0",
-    "acpx": "^0.5.3",
+    "acpx": "^0.6.1",
     "node-pty": "^1.1.0",
+    "proper-lockfile": "^4.1.2",
+    "protobufjs": "^7.5.6",
     "qrcode-terminal": "^0.12.0",
+    "write-file-atomic": "^8.0.0",
+    "ws": "^8.20.0",
     "zod": "^3",
     "zod-to-json-schema": "^3"
   },
@@ -60,7 +82,9 @@
     "node": ">=22"
   },
   "devDependencies": {
-    "@types/bun": "^1.3.11",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/write-file-atomic": "^4.0.3",
+    "@types/ws": "^8.18.1",
     "bun-types": "^1.3.11",
     "typescript": "^6.0.2"
   }