@zhin.js/adapter-weixin-ilink 1.0.0 → 1.1.0

package/lib/aes-ecb.d.ts

@@ -4,4 +4,3 @@ export declare function encryptAesEcb(plaintext: Buffer, key: Buffer): Buffer;
 export declare function decryptAesEcb(ciphertext: Buffer, key: Buffer): Buffer;
 /** Compute AES-128-ECB ciphertext size (PKCS7 padding to 16-byte boundary). */
 export declare function aesEcbPaddedSize(plaintextSize: number): number;
-//# sourceMappingURL=aes-ecb.d.ts.map

package/lib/aes-ecb.js

@@ -16,4 +16,3 @@ export function decryptAesEcb(ciphertext, key) {
 export function aesEcbPaddedSize(plaintextSize) {
     return Math.ceil((plaintextSize + 1) / 16) * 16;
 }
-//# sourceMappingURL=aes-ecb.js.map

package/lib/cdn-upload.d.ts

@@ -15,4 +15,3 @@ export declare function uploadBufferToCdn(params: {
 }): Promise<{
     downloadParam: string;
 }>;
-//# sourceMappingURL=cdn-upload.d.ts.map

package/lib/cdn-upload.js

@@ -70,4 +70,3 @@ export async function uploadBufferToCdn(params) {
     }
     return { downloadParam };
 }
-//# sourceMappingURL=cdn-upload.js.map

package/lib/cdn-url.d.ts

@@ -11,4 +11,3 @@ export declare function buildCdnUploadUrl(params: {
     uploadParam: string;
     filekey: string;
 }): string;
-//# sourceMappingURL=cdn-url.d.ts.map

package/lib/cdn-url.js

@@ -11,4 +11,3 @@ export function buildCdnDownloadUrl(encryptedQueryParam, cdnBaseUrl) {
 export function buildCdnUploadUrl(params) {
     return `${params.cdnBaseUrl}/upload?encrypted_query_param=${encodeURIComponent(params.uploadParam)}&filekey=${encodeURIComponent(params.filekey)}`;
 }
-//# sourceMappingURL=cdn-url.js.map

package/lib/client.d.ts

@@ -0,0 +1,34 @@
+import type { WeixinIlinkCredentials } from './credentials.js';
+import type { WeixinConfigManager } from './ilink-config-cache.js';
+import type { ResolvedWeixinIlinkConfig } from './protocol.js';
+import { sendMessageWeixin } from './weixin-send.js';
+/** Direct iLink API client backed by the Endpoint's live authenticated session. */
+export declare class WeixinIlinkClient {
+    readonly config: ResolvedWeixinIlinkConfig;
+    private readonly resolveCredentials;
+    private readonly resolveConfigManager;
+    private readonly sendTextImpl;
+    constructor(config: ResolvedWeixinIlinkConfig, resolveCredentials: () => WeixinIlinkCredentials | null, resolveConfigManager: () => WeixinConfigManager | undefined, sendTextImpl: typeof sendMessageWeixin);
+    get credentials(): WeixinIlinkCredentials;
+    get authenticated(): boolean;
+    get apiBaseUrl(): string;
+    get cdnBaseUrl(): string;
+    contextToken(userId: string): string | undefined;
+    sendText(to: string, text: string): Promise<{
+        messageId: string;
+    }>;
+    sendMedia(to: string, filePath: string, text?: string): Promise<{
+        messageId: string;
+    }>;
+    sendTyping(userId: string, status: number): Promise<boolean>;
+}
+export type WeixinIlinkClientEventMap = Record<string, unknown>;
+declare module '@zhin.js/feature-kit' {
+    interface AdapterClientRegistry {
+        readonly 'weixin-ilink': {
+            readonly client: WeixinIlinkClient;
+            readonly events: WeixinIlinkClientEventMap;
+        };
+    }
+}
+export declare const weixinIlinkClient: import("@zhin.js/adapter").EndpointClientToken<WeixinIlinkClient, WeixinIlinkClientEventMap>;

package/lib/client.js

@@ -0,0 +1,72 @@
+import { getContextToken } from './context-store.js';
+import { sendTyping } from './ilink-api.js';
+import { sendWeixinMediaFile } from './weixin-send-media.js';
+import { defineEndpointClient } from 'zhin.js/adapter';
+/** Direct iLink API client backed by the Endpoint's live authenticated session. */
+export class WeixinIlinkClient {
+    config;
+    resolveCredentials;
+    resolveConfigManager;
+    sendTextImpl;
+    constructor(config, resolveCredentials, resolveConfigManager, sendTextImpl) {
+        this.config = config;
+        this.resolveCredentials = resolveCredentials;
+        this.resolveConfigManager = resolveConfigManager;
+        this.sendTextImpl = sendTextImpl;
+    }
+    get credentials() {
+        const credentials = this.resolveCredentials();
+        if (!credentials?.botToken)
+            throw new Error('weixin-ilink client not authenticated');
+        return credentials;
+    }
+    get authenticated() {
+        return Boolean(this.resolveCredentials()?.botToken);
+    }
+    get apiBaseUrl() {
+        return this.resolveCredentials()?.baseUrl ?? this.config.baseUrl;
+    }
+    get cdnBaseUrl() {
+        return this.config.cdnBaseUrl;
+    }
+    contextToken(userId) {
+        return getContextToken(this.config.id, userId);
+    }
+    async sendText(to, text) {
+        const contextToken = this.contextToken(to);
+        if (!contextToken)
+            throw new Error(`missing context_token for peer ${to}`);
+        return this.sendTextImpl({
+            to,
+            text,
+            opts: { baseUrl: this.apiBaseUrl, token: this.credentials.botToken, contextToken },
+        });
+    }
+    async sendMedia(to, filePath, text = '') {
+        const contextToken = this.contextToken(to);
+        if (!contextToken)
+            throw new Error(`missing context_token for peer ${to}`);
+        return sendWeixinMediaFile({
+            filePath,
+            to,
+            text,
+            opts: { baseUrl: this.apiBaseUrl, token: this.credentials.botToken, contextToken },
+            cdnBaseUrl: this.cdnBaseUrl,
+        });
+    }
+    async sendTyping(userId, status) {
+        const manager = this.resolveConfigManager();
+        if (!this.authenticated || !manager)
+            return false;
+        const cfg = await manager.getForUser(userId, this.contextToken(userId));
+        if (!cfg.typingTicket)
+            return false;
+        await sendTyping({
+            baseUrl: this.apiBaseUrl,
+            token: this.credentials.botToken,
+            body: { ilink_user_id: userId, typing_ticket: cfg.typingTicket, status },
+        });
+        return true;
+    }
+}
+export const weixinIlinkClient = defineEndpointClient('weixin-ilink');

package/lib/context-store.d.ts

@@ -1,2 +1 @@
-export { setContextToken, getContextToken, restoreContextTokens, clearContextTokensForAccount, bodyFromItemList, isMediaItem, } from "./weixin-inbound.js";
-//# sourceMappingURL=context-store.d.ts.map
+export { setContextToken, getContextToken, listContextTokenUserIds, restoreContextTokens, clearContextTokensForAccount, flushContextTokenPersist, bodyFromItemList, isMediaItem, } from "./weixin-inbound.js";

package/lib/context-store.js

@@ -1,2 +1 @@
-export { setContextToken, getContextToken, restoreContextTokens, clearContextTokensForAccount, bodyFromItemList, isMediaItem, } from "./weixin-inbound.js";
-//# sourceMappingURL=context-store.js.map
+export { setContextToken, getContextToken, listContextTokenUserIds, restoreContextTokens, clearContextTokensForAccount, flushContextTokenPersist, bodyFromItemList, isMediaItem, } from "./weixin-inbound.js";

package/lib/credentials.d.ts

@@ -6,10 +6,9 @@ export interface WeixinIlinkCredentials {
     updatedAt?: string;
 }
 export declare function resolveStateDir(): string;
-export declare function credentialsPath(botName: string): string;
-export declare function loadCredentials(botName: string): WeixinIlinkCredentials | null;
-export declare function saveCredentials(botName: string, creds: WeixinIlinkCredentials): void;
-export declare function syncBufPath(botName: string): string;
-export declare function loadSyncBuf(botName: string): string;
-export declare function saveSyncBuf(botName: string, buf: string): void;
-//# sourceMappingURL=credentials.d.ts.map
+export declare function credentialsPath(endpointId: string): string;
+export declare function loadCredentials(endpointId: string): WeixinIlinkCredentials | null;
+export declare function saveCredentials(endpointId: string, creds: WeixinIlinkCredentials): void;
+export declare function syncBufPath(endpointId: string): string;
+export declare function loadSyncBuf(endpointId: string): string;
+export declare function saveSyncBuf(endpointId: string, buf: string): void;

package/lib/credentials.js

@@ -6,11 +6,11 @@ export function resolveStateDir() {
         ? path.join(process.env.ZHIN_DATA_DIR, "weixin-ilink")
         : DEFAULT_DATA_DIR;
 }
-export function credentialsPath(botName) {
-    return path.join(resolveStateDir(), `${botName}.json`);
+export function credentialsPath(endpointId) {
+    return path.join(resolveStateDir(), `${endpointId}.json`);
 }
-export function loadCredentials(botName) {
-    const file = credentialsPath(botName);
+export function loadCredentials(endpointId) {
+    const file = credentialsPath(endpointId);
     try {
         if (!fs.existsSync(file))
             return null;
@@ -24,16 +24,16 @@ export function loadCredentials(botName) {
         return null;
     }
 }
-export function saveCredentials(botName, creds) {
-    const file = credentialsPath(botName);
+export function saveCredentials(endpointId, creds) {
+    const file = credentialsPath(endpointId);
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, JSON.stringify({ ...creds, updatedAt: new Date().toISOString() }, null, 2), "utf-8");
 }
-export function syncBufPath(botName) {
-    return path.join(resolveStateDir(), `${botName}.sync-buf`);
+export function syncBufPath(endpointId) {
+    return path.join(resolveStateDir(), `${endpointId}.sync-buf`);
 }
-export function loadSyncBuf(botName) {
-    const file = syncBufPath(botName);
+export function loadSyncBuf(endpointId) {
+    const file = syncBufPath(endpointId);
     try {
         return fs.existsSync(file) ? fs.readFileSync(file, "utf-8") : "";
     }
@@ -41,9 +41,8 @@ export function loadSyncBuf(botName) {
         return "";
     }
 }
-export function saveSyncBuf(botName, buf) {
-    const file = syncBufPath(botName);
+export function saveSyncBuf(endpointId, buf) {
+    const file = syncBufPath(endpointId);
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, buf, "utf-8");
 }
-//# sourceMappingURL=credentials.js.map

package/lib/endpoint.d.ts

@@ -0,0 +1,37 @@
+import { Endpoint } from 'zhin.js/adapter';
+import type { EndpointControl, EndpointManagement, EndpointSendRequest } from 'zhin.js/adapter';
+import type { CapabilityId } from 'zhin.js';
+import { getUpdates, notifyStart, notifyStop } from './ilink-api.js';
+import { type WeixinIlinkCredentials } from './credentials.js';
+import { sendMessageWeixin } from './weixin-send.js';
+import { type ResolvedWeixinIlinkConfig, type WeixinMessageWithMedia } from './protocol.js';
+import { WeixinIlinkClient } from './client.js';
+export type WeixinIlinkSendText = typeof sendMessageWeixin;
+export type WeixinIlinkNotifyStart = typeof notifyStart;
+export type WeixinIlinkNotifyStop = typeof notifyStop;
+export type WeixinIlinkGetUpdates = typeof getUpdates;
+export interface WeixinIlinkEndpointOptions {
+    readonly id: CapabilityId;
+    readonly config: ResolvedWeixinIlinkConfig;
+    readonly resolveCredentials?: (config: ResolvedWeixinIlinkConfig, signal?: AbortSignal) => Promise<WeixinIlinkCredentials>;
+    /** Test / internal: override network side effects. */
+    readonly notifyStart?: WeixinIlinkNotifyStart;
+    readonly notifyStop?: WeixinIlinkNotifyStop;
+    readonly getUpdates?: WeixinIlinkGetUpdates;
+    readonly sendText?: WeixinIlinkSendText;
+}
+export declare class WeixinIlinkEndpoint extends Endpoint<WeixinIlinkClient> {
+    #private;
+    readonly client: WeixinIlinkClient;
+    readonly management: EndpointManagement;
+    readonly control: EndpointControl;
+    constructor(options: WeixinIlinkEndpointOptions);
+    get hasCredentials(): boolean;
+    start(): Promise<void>;
+    open(): void;
+    close(): void;
+    stop(): Promise<void>;
+    send({ conversation, payload }: EndpointSendRequest): Promise<string>;
+    /** Test / internal: admit a parsed message when the endpoint is open. */
+    admit(msg: WeixinMessageWithMedia): void;
+}