@cjhyy/code-shell-chat 0.8.0

package/dist/wechat-login.js

@@ -0,0 +1,97 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { defaultGatewayConfigPath } from "./config.js";
+import { loginWechatWithQr, } from "./wechat.js";
+import { defaultWechatDataDirectory, FileWechatCredentialStore, wechatCredentialFingerprint, } from "./wechat-storage.js";
+/**
+ * Complete the personal-WeChat QR flow and persist both the owner-only token
+ * and the matching CodeShell gateway configuration. Shared by the CLI and the
+ * Desktop Link page so both entry points produce exactly the same files.
+ */
+export async function loginCodeShellWechat(options = {}) {
+    const configPath = resolve(options.configPath ?? defaultGatewayConfigPath());
+    const credentialsDir = resolve(options.credentialsDir ?? defaultWechatDataDirectory());
+    const store = new FileWechatCredentialStore(credentialsDir);
+    const login = options.login ?? loginWechatWithQr;
+    const result = await login({
+        signal: options.signal,
+        localTokens: store.listTokens(),
+        onQrCode: options.onQrCode,
+        onStatus: options.onStatus,
+        requestVerificationCode: options.requestVerificationCode,
+    });
+    let credentials;
+    let credentialsChanged = false;
+    if (result.connected && result.credentials) {
+        const previous = store.load(result.credentials.accountId);
+        credentials = store.save(result.credentials);
+        credentialsChanged =
+            !previous || previous.token !== credentials.token || previous.baseUrl !== credentials.baseUrl;
+    }
+    else if (result.alreadyConnected) {
+        credentials = store.load();
+        if (!credentials) {
+            throw new Error("微信端已绑定，但本机没有可用凭据；请在微信中先解除后重新登录");
+        }
+    }
+    else {
+        throw new Error("个人微信未完成连接");
+    }
+    const stateStore = store.stateStore(credentials.accountId, wechatCredentialFingerprint(credentials.token));
+    if (credentialsChanged) {
+        // Cursor and context tokens belong to the credential session that
+        // produced them. Reusing them after a QR rebind can yield prepare failed
+        // or poll from an unrelated cursor, so make the new binding start clean.
+        // reset() stamps the new credential fingerprint, so an adapter still
+        // running with the revoked token refuses to write its stale state back.
+        await stateStore.reset({});
+    }
+    else {
+        try {
+            await stateStore.load();
+        }
+        catch {
+            // Keep ordinary adapter startup fail-closed. An explicit successful
+            // login (including an already-connected confirmation) is the recovery
+            // boundary where replacing an unsafe state file is intentional.
+            await stateStore.reset({});
+        }
+    }
+    updateWechatConfig({
+        configPath,
+        credentials,
+        credentialsDir: options.credentialsDir ? credentialsDir : undefined,
+    });
+    return { accountId: credentials.accountId, configPath };
+}
+function updateWechatConfig(options) {
+    let raw = {};
+    if (existsSync(options.configPath)) {
+        if (process.platform !== "win32" && (statSync(options.configPath).mode & 0o077) !== 0) {
+            throw new Error(`Chat gateway 配置权限必须为 0600：${options.configPath}`);
+        }
+        const parsed = JSON.parse(readFileSync(options.configPath, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error(`Chat gateway 配置不是 JSON object：${options.configPath}`);
+        }
+        raw = parsed;
+    }
+    const existing = raw.wechat && typeof raw.wechat === "object" && !Array.isArray(raw.wechat)
+        ? raw.wechat
+        : {};
+    const updated = {
+        ...raw,
+        wechat: {
+            ...existing,
+            enabled: true,
+            accountId: options.credentials.accountId,
+            ...(options.credentialsDir ? { credentialsDir: options.credentialsDir } : {}),
+        },
+    };
+    mkdirSync(dirname(options.configPath), { recursive: true, mode: 0o700 });
+    const temporary = `${options.configPath}.${process.pid}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(updated, null, 2)}\n`, { mode: 0o600 });
+    renameSync(temporary, options.configPath);
+    if (process.platform !== "win32")
+        chmodSync(options.configPath, 0o600);
+}

package/dist/wechat-storage.d.ts

@@ -0,0 +1,61 @@
+export interface WechatCredentials {
+    accountId: string;
+    token: string;
+    baseUrl: string;
+    userId?: string;
+    savedAt?: string;
+}
+export interface WechatAdapterState {
+    cursor?: string;
+    contextTokens?: Record<string, string>;
+}
+export interface WechatStateStore {
+    load(): Promise<WechatAdapterState | undefined>;
+    save(state: WechatAdapterState): Promise<void>;
+}
+/**
+ * Short non-reversible identity of the bot token. Stored inside the state file
+ * so a state written by one credential generation can never be silently
+ * overwritten by an adapter still running with a revoked one.
+ */
+export declare function wechatCredentialFingerprint(token: string): string;
+export declare class WechatStateOwnershipError extends Error {
+    constructor(filePath: string);
+}
+export declare function defaultWechatDataDirectory(env?: NodeJS.ProcessEnv): string;
+export declare function normalizeWechatAccountId(accountId: string): string;
+export declare class FileWechatCredentialStore {
+    readonly directory: string;
+    constructor(directory?: string);
+    listAccountIds(): string[];
+    listTokens(): string[];
+    load(accountId?: string): WechatCredentials | undefined;
+    save(credentials: WechatCredentials): WechatCredentials;
+    stateStore(accountId: string, credentialFingerprint?: string): FileWechatStateStore;
+    credentialPath(accountId: string): string;
+    statePath(accountId: string): string;
+}
+export declare class FileWechatStateStore implements WechatStateStore {
+    readonly filePath: string;
+    /** Binds this store to one credential generation; omitted disables the check. */
+    readonly credentialFingerprint?: string | undefined;
+    constructor(filePath: string, 
+    /** Binds this store to one credential generation; omitted disables the check. */
+    credentialFingerprint?: string | undefined);
+    load(): Promise<WechatAdapterState | undefined>;
+    save(state: WechatAdapterState): Promise<void>;
+    /**
+     * Claim the state file for this credential unconditionally. Only the QR
+     * login flow may use it: an explicit successful login is the one boundary
+     * where replacing another generation's state is intentional.
+     */
+    reset(state: WechatAdapterState): Promise<void>;
+    private write;
+    private assertOwnership;
+}
+/**
+ * Synchronous readiness probe for hosts that expose proactive destinations in
+ * a status/catalog call. It deliberately shares the exact parser used by the
+ * adapter instead of letting each host reinterpret the state-file schema.
+ */
+export declare function hasWechatStoredContextToken(filePath: string, target: string): boolean;

package/dist/wechat-storage.js

@@ -0,0 +1,251 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmodSync, closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const MAX_WECHAT_STORE_BYTES = 1024 * 1024;
+/**
+ * Short non-reversible identity of the bot token. Stored inside the state file
+ * so a state written by one credential generation can never be silently
+ * overwritten by an adapter still running with a revoked one.
+ */
+export function wechatCredentialFingerprint(token) {
+    return createHash("sha256").update(token).digest("base64url").slice(0, 16);
+}
+export class WechatStateOwnershipError extends Error {
+    constructor(filePath) {
+        super(`微信状态文件属于另一个登录凭据（可能已重新扫码绑定），请重启 Gateway：${filePath}`);
+        this.name = "WechatStateOwnershipError";
+    }
+}
+export function defaultWechatDataDirectory(env = process.env) {
+    return join(env.HOME ?? homedir(), ".code-shell", "chat", "wechat");
+}
+export function normalizeWechatAccountId(accountId) {
+    const normalized = accountId
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (!normalized)
+        throw new Error("微信 accountId 无效");
+    return normalized;
+}
+export class FileWechatCredentialStore {
+    directory;
+    constructor(directory = defaultWechatDataDirectory()) {
+        this.directory = directory;
+    }
+    listAccountIds() {
+        const value = readJson(join(this.directory, "accounts.json"));
+        if (!Array.isArray(value))
+            return [];
+        return value.filter((item) => typeof item === "string" && Boolean(item.trim()));
+    }
+    listTokens() {
+        return this.listAccountIds()
+            .map((accountId) => this.load(accountId)?.token)
+            .filter((token) => Boolean(token));
+    }
+    load(accountId) {
+        const selected = accountId ? normalizeWechatAccountId(accountId) : this.listAccountIds().at(-1);
+        if (!selected)
+            return undefined;
+        const value = readJson(this.credentialPath(selected));
+        if (!isRecord(value))
+            return undefined;
+        const token = readString(value.token);
+        const storedAccountId = readString(value.accountId) ?? selected;
+        const baseUrl = readString(value.baseUrl);
+        if (!token || !baseUrl)
+            return undefined;
+        return {
+            accountId: storedAccountId,
+            token,
+            baseUrl,
+            userId: readString(value.userId),
+            savedAt: readString(value.savedAt),
+        };
+    }
+    save(credentials) {
+        const normalizedId = normalizeWechatAccountId(credentials.accountId);
+        const value = {
+            ...credentials,
+            accountId: normalizedId,
+            savedAt: new Date().toISOString(),
+        };
+        writeOwnerOnlyJson(this.credentialPath(normalizedId), value);
+        const accountIds = this.listAccountIds().filter((id) => id !== normalizedId);
+        writeOwnerOnlyJson(join(this.directory, "accounts.json"), [...accountIds, normalizedId]);
+        return value;
+    }
+    stateStore(accountId, credentialFingerprint) {
+        return new FileWechatStateStore(this.statePath(accountId), credentialFingerprint);
+    }
+    credentialPath(accountId) {
+        return join(this.directory, "accounts", `${normalizeWechatAccountId(accountId)}.json`);
+    }
+    statePath(accountId) {
+        return join(this.directory, "accounts", `${normalizeWechatAccountId(accountId)}.state.json`);
+    }
+}
+export class FileWechatStateStore {
+    filePath;
+    credentialFingerprint;
+    constructor(filePath, 
+    /** Binds this store to one credential generation; omitted disables the check. */
+    credentialFingerprint) {
+        this.filePath = filePath;
+        this.credentialFingerprint = credentialFingerprint;
+    }
+    async load() {
+        const value = readJson(this.filePath, true);
+        this.assertOwnership(value);
+        const parsed = parseWechatAdapterState(value);
+        if (value !== undefined && !parsed) {
+            throw new Error(`微信状态文件格式无效：${this.filePath}`);
+        }
+        return parsed;
+    }
+    async save(state) {
+        // Cheap ownership probe before every write. A file stamped by another
+        // credential (fresh QR rebind) must never be overwritten by a stale
+        // adapter, while a legacy file without a fingerprint is adopted by the
+        // first stamped writer. A check-then-write race with a concurrent rebind
+        // is still possible, but the exposure shrinks from "every future persist"
+        // to at most the single write already in flight during the rebind.
+        this.assertOwnership(readJson(this.filePath));
+        this.write(state);
+    }
+    /**
+     * Claim the state file for this credential unconditionally. Only the QR
+     * login flow may use it: an explicit successful login is the one boundary
+     * where replacing another generation's state is intentional.
+     */
+    async reset(state) {
+        this.write(state);
+    }
+    write(state) {
+        writeOwnerOnlyJson(this.filePath, this.credentialFingerprint
+            ? { ...state, credentialFingerprint: this.credentialFingerprint }
+            : state);
+    }
+    assertOwnership(value) {
+        if (!this.credentialFingerprint)
+            return;
+        const existing = isRecord(value) ? readString(value.credentialFingerprint) : undefined;
+        if (existing && existing !== this.credentialFingerprint) {
+            throw new WechatStateOwnershipError(this.filePath);
+        }
+    }
+}
+/**
+ * Synchronous readiness probe for hosts that expose proactive destinations in
+ * a status/catalog call. It deliberately shares the exact parser used by the
+ * adapter instead of letting each host reinterpret the state-file schema.
+ */
+export function hasWechatStoredContextToken(filePath, target) {
+    if (!target.trim())
+        return false;
+    const state = parseWechatAdapterState(readJson(filePath));
+    const token = state?.contextTokens?.[target];
+    return typeof token === "string" && Boolean(token.trim());
+}
+function writeOwnerOnlyJson(filePath, value) {
+    const dir = dirname(filePath);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const dirInfo = lstatSync(dir);
+    if (dirInfo.isSymbolicLink() || !dirInfo.isDirectory()) {
+        throw new Error(`微信凭据或状态目录不是普通目录：${dir}`);
+    }
+    try {
+        chmodSync(dir, 0o700);
+    }
+    catch {
+        // Best effort on platforms without POSIX modes.
+    }
+    const body = `${JSON.stringify(value, null, 2)}\n`;
+    if (Buffer.byteLength(body, "utf8") > MAX_WECHAT_STORE_BYTES) {
+        throw new Error("微信凭据或状态文件超过大小限制");
+    }
+    const temporary = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, body, { mode: 0o600, flag: "wx" });
+        renameSync(temporary, filePath);
+        try {
+            chmodSync(filePath, 0o600);
+        }
+        catch {
+            // Best effort on platforms without POSIX modes.
+        }
+    }
+    catch (error) {
+        try {
+            rmSync(temporary, { force: true });
+        }
+        catch {
+            // Preserve the original write/rename error.
+        }
+        throw error;
+    }
+}
+function readJson(filePath, strict = false) {
+    let handle;
+    try {
+        const info = lstatSync(filePath);
+        if (info.isSymbolicLink() || !info.isFile()) {
+            throw new Error(`微信凭据或状态文件不是普通文件：${filePath}`);
+        }
+        if (info.size > MAX_WECHAT_STORE_BYTES) {
+            throw new Error(`微信凭据或状态文件超过大小限制：${filePath}`);
+        }
+        if (process.platform !== "win32" && (info.mode & 0o077) !== 0) {
+            throw new Error(`微信凭据或状态文件权限必须为 0600：${filePath}`);
+        }
+        const noFollow = process.platform === "win32" ? 0 : constants.O_NOFOLLOW;
+        handle = openSync(filePath, constants.O_RDONLY | noFollow);
+        const openedInfo = fstatSync(handle);
+        if (!openedInfo.isFile() || openedInfo.size > MAX_WECHAT_STORE_BYTES) {
+            throw new Error(`微信凭据或状态文件无效：${filePath}`);
+        }
+        if (process.platform !== "win32" && (openedInfo.mode & 0o077) !== 0) {
+            throw new Error(`微信凭据或状态文件权限必须为 0600：${filePath}`);
+        }
+        const raw = readFileSync(handle, "utf8");
+        if (Buffer.byteLength(raw, "utf8") > MAX_WECHAT_STORE_BYTES) {
+            throw new Error(`微信凭据或状态文件超过大小限制：${filePath}`);
+        }
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        if (strict) {
+            const detail = error instanceof Error ? `：${error.message}` : "";
+            throw new Error(`无法安全读取微信状态文件：${filePath}${detail}`, {
+                cause: error,
+            });
+        }
+        return undefined;
+    }
+    finally {
+        if (handle !== undefined)
+            closeSync(handle);
+    }
+}
+function parseWechatAdapterState(value) {
+    if (!isRecord(value))
+        return undefined;
+    const contextTokens = isRecord(value.contextTokens)
+        ? Object.fromEntries(Object.entries(value.contextTokens).filter((entry) => Boolean(entry[0].trim()) && typeof entry[1] === "string" && Boolean(entry[1].trim())))
+        : undefined;
+    return {
+        cursor: readString(value.cursor),
+        ...(contextTokens ? { contextTokens } : {}),
+    };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}

package/dist/wechat.d.ts

@@ -0,0 +1,129 @@
+import type { ChannelAdapter, ChannelMessageHandler, OutgoingMessage } from "./channel.js";
+import { type WechatCredentials, type WechatStateStore } from "./wechat-storage.js";
+export * from "./wechat-storage.js";
+export declare const WECHAT_DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+export declare const WECHAT_PROTOCOL_VERSION = "2.4.6";
+export declare const WECHAT_DEFAULT_BOT_AGENT = "CodeShellChat/0.7.1";
+export interface WechatAdapterConfig {
+    accountId: string;
+    token: string;
+    baseUrl?: string;
+    botAgent?: string;
+    protocolVersion?: string;
+    /** Only enable for an explicitly trusted self-hosted compatible backend. */
+    allowUnsafeBaseUrl?: boolean;
+    /**
+     * Exact extra hostnames trusted for inbound media downloads, extending the
+     * built-in WeChat CDN allowlist (e.g. a regional CDN variant). Downloads
+     * stay HTTPS-only; this never affects the API baseUrl trust decision.
+     */
+    extraCdnDownloadHosts?: readonly string[];
+}
+export interface WechatAdapterOptions {
+    fetch?: typeof fetch;
+    sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
+    log?: (message: string) => void;
+    stateStore?: WechatStateStore;
+    now?: () => number;
+    maxMessageAgeMs?: number;
+    /** Retries only explicit platform rate-limit responses, reusing client_id. */
+    rateLimitRetries?: number;
+    rateLimitRetryBaseMs?: number;
+    /** Account-wide cooldown after explicit rate-limit retries are exhausted. */
+    rateLimitCooldownMs?: number;
+}
+export interface WechatDirectSendResult {
+    channel: "wechat";
+    target: string;
+    status: "accepted";
+    /** iLink acknowledges API acceptance, not display on the recipient device. */
+    terminalDeliveryConfirmed: false;
+    /** True when the helper reused the adapter already long-polling this account. */
+    viaLiveAdapter: boolean;
+}
+/** Personal WeChat ClawBot adapter using Tencent's documented iLink Bot HTTP protocol. */
+export declare class WechatAdapter implements ChannelAdapter {
+    private readonly config;
+    readonly channel = "wechat";
+    readonly capabilities: import("./channel.js").ChannelCapabilities;
+    readonly supportsOutgoingAttachments = true;
+    private readonly fetchFn;
+    private readonly sleepFn;
+    private readonly log;
+    private readonly stateStore?;
+    private readonly now;
+    private readonly maxMessageAgeMs;
+    private readonly rateLimitRetries;
+    private readonly rateLimitRetryBaseMs;
+    private readonly rateLimitCooldownMs;
+    private readonly accountKey;
+    private readonly credentialKey;
+    private readonly extraCdnDownloadHosts;
+    private readonly baseUrl;
+    private readonly protocolVersion;
+    private readonly botAgent;
+    private state;
+    private stateReady?;
+    private stateWrite;
+    /** Set once the state file is owned by a newer QR binding; never cleared. */
+    private staleCredential;
+    /** Preserve visible ordering and keep context/media state mutations single-writer. */
+    private outboundQueue;
+    private readonly seenMessageIds;
+    private readonly delivery;
+    constructor(config: WechatAdapterConfig, options?: WechatAdapterOptions);
+    run(handler: ChannelMessageHandler, signal: AbortSignal): Promise<void>;
+    send(target: string, message: OutgoingMessage): Promise<void>;
+    private sendInOrder;
+    private sendItem;
+    private postWechatMessage;
+    private postWechatMessageWithRateLimitRetry;
+    private assertRateLimitCircuitClosed;
+    private clearContextToken;
+    private uploadImage;
+    private uploadFile;
+    private uploadVideo;
+    private uploadMedia;
+    private uploadCiphertext;
+    private normalizeInbound;
+    private toAttachment;
+    private downloadMedia;
+    private fetchWechatCdn;
+    private isDuplicate;
+    private forgetDuplicate;
+    private commitCursor;
+    private ensureState;
+    private persistState;
+    private baseInfo;
+    private post;
+    private notifyLifecycle;
+}
+/**
+ * Direct WeChat delivery for schedulers and notification workers. It reuses a
+ * live long-poll adapter when available and otherwise creates a one-shot
+ * adapter. Both routes share persisted context lookup, stale-context eviction,
+ * best-effort tokenless fallback, media upload, and response validation.
+ */
+export declare function sendWechatDirect(config: WechatAdapterConfig, target: string, message: OutgoingMessage, options?: WechatAdapterOptions): Promise<WechatDirectSendResult>;
+type QrStatus = "wait" | "scaned" | "confirmed" | "expired" | "scaned_but_redirect" | "need_verifycode" | "verify_code_blocked" | "binded_redirect";
+export interface WechatQrLoginOptions {
+    fetch?: typeof fetch;
+    sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    apiBaseUrl?: string;
+    botType?: string;
+    protocolVersion?: string;
+    localTokens?: string[];
+    allowUnsafeBaseUrl?: boolean;
+    onQrCode?: (url: string) => void | Promise<void>;
+    onStatus?: (status: QrStatus) => void;
+    requestVerificationCode?: () => Promise<string>;
+}
+export interface WechatQrLoginResult {
+    connected: boolean;
+    alreadyConnected?: boolean;
+    credentials?: WechatCredentials;
+}
+/** QR login flow compatible with Tencent's official ClawBot plugin protocol. */
+export declare function loginWechatWithQr(options?: WechatQrLoginOptions): Promise<WechatQrLoginResult>;