metame-cli 1.5.13 → 1.5.15

package/scripts/daemon-weixin-api.js

@@ -0,0 +1,266 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const DEFAULT_BASE_URL = 'https://ilinkai.weixin.qq.com';
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35000;
+const DEFAULT_API_TIMEOUT_MS = 15000;
+const DEFAULT_QR_POLL_TIMEOUT_MS = 35000;
+
+function ensureTrailingSlash(url) {
+  const text = String(url || '').trim();
+  return text.endsWith('/') ? text : `${text}/`;
+}
+
+function randomWechatUin() {
+  const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+  return Buffer.from(String(uint32), 'utf8').toString('base64');
+}
+
+function generateClientId() {
+  return `metame-weixin-${Date.now().toString(36)}-${crypto.randomBytes(6).toString('hex')}`;
+}
+
+function buildHeaders(body, opts = {}) {
+  const headers = {
+    'Content-Type': 'application/json',
+    'Content-Length': String(Buffer.byteLength(body || '', 'utf8')),
+    'X-WECHAT-UIN': randomWechatUin(),
+  };
+  if (opts.token) {
+    headers.AuthorizationType = 'ilink_bot_token';
+    headers.Authorization = `Bearer ${String(opts.token).trim()}`;
+  }
+  if (opts.routeTag !== undefined && opts.routeTag !== null && String(opts.routeTag).trim()) {
+    headers.SKRouteTag = String(opts.routeTag).trim();
+  }
+  if (opts.extraHeaders && typeof opts.extraHeaders === 'object') {
+    Object.assign(headers, opts.extraHeaders);
+  }
+  return headers;
+}
+
+function createAbortSignal(timeoutMs) {
+  if (!(timeoutMs > 0)) return { signal: undefined, cancel: () => {} };
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  return {
+    signal: controller.signal,
+    cancel: () => clearTimeout(timer),
+  };
+}
+
+function createWeixinApiClient(deps = {}) {
+  const fetchImpl = deps.fetchImpl || global.fetch;
+  const log = typeof deps.log === 'function' ? deps.log : () => {};
+  const baseInfo = deps.baseInfo || { channel_version: 'metame-weixin-bridge' };
+
+  if (typeof fetchImpl !== 'function') {
+    throw new Error('fetch implementation is required');
+  }
+
+  async function requestJson(params) {
+    const baseUrl = String(params.baseUrl || DEFAULT_BASE_URL).trim();
+    const endpoint = String(params.endpoint || '').replace(/^\/+/, '');
+    const body = JSON.stringify(params.body || {});
+    const url = new URL(endpoint, ensureTrailingSlash(baseUrl)).toString();
+    const aborter = createAbortSignal(params.timeoutMs);
+    try {
+      const response = await fetchImpl(url, {
+        method: params.method || 'POST',
+        headers: buildHeaders(body, {
+          token: params.token,
+          routeTag: params.routeTag,
+          extraHeaders: params.extraHeaders,
+        }),
+        body,
+        signal: aborter.signal,
+      });
+      const rawText = await response.text();
+      let parsed;
+      try {
+        parsed = rawText ? JSON.parse(rawText) : {};
+      } catch {
+        parsed = { rawText };
+      }
+      if (!response.ok) {
+        const err = new Error(`${params.label || endpoint} failed: ${response.status} ${response.statusText}`);
+        err.status = response.status;
+        err.response = parsed;
+        err.rawText = rawText;
+        throw err;
+      }
+      return { response, data: parsed, rawText };
+    } finally {
+      aborter.cancel();
+    }
+  }
+
+  async function getBotQrCode(params = {}) {
+    const baseUrl = String(params.baseUrl || DEFAULT_BASE_URL).trim();
+    const botType = String(params.botType || '3').trim();
+    const url = new URL(`ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(botType)}`, ensureTrailingSlash(baseUrl)).toString();
+    const aborter = createAbortSignal(params.timeoutMs || DEFAULT_API_TIMEOUT_MS);
+    try {
+      const response = await fetchImpl(url, {
+        headers: params.routeTag ? { SKRouteTag: String(params.routeTag).trim() } : {},
+        signal: aborter.signal,
+      });
+      const rawText = await response.text();
+      const data = rawText ? JSON.parse(rawText) : {};
+      if (!response.ok) {
+        const err = new Error(`get_bot_qrcode failed: ${response.status} ${response.statusText}`);
+        err.status = response.status;
+        err.response = data;
+        throw err;
+      }
+      return data;
+    } finally {
+      aborter.cancel();
+    }
+  }
+
+  async function getQrCodeStatus(params = {}) {
+    const baseUrl = String(params.baseUrl || DEFAULT_BASE_URL).trim();
+    const qrcode = String(params.qrcode || '').trim();
+    const url = new URL(`ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, ensureTrailingSlash(baseUrl)).toString();
+    const aborter = createAbortSignal(params.timeoutMs || DEFAULT_QR_POLL_TIMEOUT_MS);
+    try {
+      const response = await fetchImpl(url, {
+        headers: {
+          'iLink-App-ClientVersion': '1',
+          ...(params.routeTag ? { SKRouteTag: String(params.routeTag).trim() } : {}),
+        },
+        signal: aborter.signal,
+      });
+      const rawText = await response.text();
+      const data = rawText ? JSON.parse(rawText) : {};
+      if (!response.ok) {
+        const err = new Error(`get_qrcode_status failed: ${response.status} ${response.statusText}`);
+        err.status = response.status;
+        err.response = data;
+        throw err;
+      }
+      return data;
+    } catch (err) {
+      if (err && err.name === 'AbortError') return { status: 'wait' };
+      throw err;
+    } finally {
+      aborter.cancel();
+    }
+  }
+
+  async function getUpdates(params = {}) {
+    try {
+      const result = await requestJson({
+        label: 'getUpdates',
+        baseUrl: params.baseUrl,
+        endpoint: 'ilink/bot/getupdates',
+        token: params.token,
+        routeTag: params.routeTag,
+        timeoutMs: params.timeoutMs || DEFAULT_LONG_POLL_TIMEOUT_MS,
+        body: {
+          get_updates_buf: params.getUpdatesBuf || '',
+          base_info: baseInfo,
+        },
+      });
+      return result.data;
+    } catch (err) {
+      if (err && err.name === 'AbortError') {
+        return { ret: 0, msgs: [], get_updates_buf: params.getUpdatesBuf || '' };
+      }
+      throw err;
+    }
+  }
+
+  async function sendTextMessage(params = {}) {
+    if (!String(params.contextToken || '').trim()) {
+      throw new Error('contextToken is required');
+    }
+    const text = String(params.text || '');
+    const clientId = String(params.clientId || generateClientId()).trim();
+    const result = await requestJson({
+      label: 'sendMessage',
+      baseUrl: params.baseUrl,
+      endpoint: 'ilink/bot/sendmessage',
+      token: params.token,
+      routeTag: params.routeTag,
+      timeoutMs: params.timeoutMs || DEFAULT_API_TIMEOUT_MS,
+      body: {
+        msg: {
+          from_user_id: '',
+          to_user_id: String(params.toUserId || '').trim(),
+          client_id: clientId,
+          message_type: 2,
+          message_state: 2,
+          context_token: String(params.contextToken).trim(),
+          item_list: [
+            {
+              type: 1,
+              text_item: { text },
+            },
+          ],
+        },
+        base_info: baseInfo,
+      },
+    });
+    return result.data;
+  }
+
+  async function getConfig(params = {}) {
+    const result = await requestJson({
+      label: 'getConfig',
+      baseUrl: params.baseUrl,
+      endpoint: 'ilink/bot/getconfig',
+      token: params.token,
+      routeTag: params.routeTag,
+      timeoutMs: params.timeoutMs || DEFAULT_API_TIMEOUT_MS,
+      body: {
+        ilink_user_id: String(params.userId || '').trim(),
+        context_token: params.contextToken ? String(params.contextToken).trim() : undefined,
+        base_info: baseInfo,
+      },
+    });
+    return result.data;
+  }
+
+  async function sendTyping(params = {}) {
+    const result = await requestJson({
+      label: 'sendTyping',
+      baseUrl: params.baseUrl,
+      endpoint: 'ilink/bot/sendtyping',
+      token: params.token,
+      routeTag: params.routeTag,
+      timeoutMs: params.timeoutMs || DEFAULT_API_TIMEOUT_MS,
+      body: {
+        ilink_user_id: String(params.userId || '').trim(),
+        typing_ticket: String(params.typingTicket || '').trim(),
+        status: params.status,
+        base_info: baseInfo,
+      },
+    });
+    return result.data;
+  }
+
+  return {
+    DEFAULT_BASE_URL,
+    getBotQrCode,
+    getQrCodeStatus,
+    getUpdates,
+    sendTextMessage,
+    getConfig,
+    sendTyping,
+    _requestJson: requestJson,
+    _log: log,
+  };
+}
+
+module.exports = {
+  DEFAULT_BASE_URL,
+  DEFAULT_LONG_POLL_TIMEOUT_MS,
+  DEFAULT_API_TIMEOUT_MS,
+  DEFAULT_QR_POLL_TIMEOUT_MS,
+  createWeixinApiClient,
+  ensureTrailingSlash,
+  generateClientId,
+};

package/scripts/daemon-weixin-auth.js

@@ -0,0 +1,188 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { DEFAULT_BASE_URL } = require('./daemon-weixin-api');
+
+function createWeixinAuthStore(deps = {}) {
+  const HOME = deps.HOME || os.homedir();
+  const fsMod = deps.fs || fs;
+  const pathMod = deps.path || path;
+  const apiClient = deps.apiClient;
+  const log = typeof deps.log === 'function' ? deps.log : () => {};
+  const now = typeof deps.now === 'function' ? deps.now : () => new Date();
+  const sleep = typeof deps.sleep === 'function' ? deps.sleep : (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+  if (!apiClient) throw new Error('apiClient is required');
+
+  const baseDir = pathMod.join(HOME, '.metame', 'weixin');
+  const accountsDir = pathMod.join(baseDir, 'accounts');
+  const sessionsDir = pathMod.join(baseDir, 'sessions');
+  const indexFile = pathMod.join(baseDir, 'accounts.json');
+
+  function ensureDirs() {
+    fsMod.mkdirSync(accountsDir, { recursive: true });
+    fsMod.mkdirSync(sessionsDir, { recursive: true });
+  }
+
+  function normalizeAccountId(raw) {
+    return String(raw || '').trim().replace(/[^a-zA-Z0-9._@-]/g, '-');
+  }
+
+  function normalizeSessionKey(raw) {
+    const value = String(raw || '').trim();
+    if (!value) throw new Error('sessionKey is required');
+    if (!/^[a-zA-Z0-9._-]{1,80}$/.test(value)) {
+      throw new Error('invalid sessionKey: use 1-80 chars from [a-zA-Z0-9._-]');
+    }
+    return value;
+  }
+
+  function sessionPath(sessionKey) {
+    return pathMod.join(sessionsDir, `${normalizeSessionKey(sessionKey)}.json`);
+  }
+
+  function accountPath(accountId) {
+    return pathMod.join(accountsDir, `${normalizeAccountId(accountId)}.json`);
+  }
+
+  function readJson(filePath, fallback = null) {
+    try {
+      if (!fsMod.existsSync(filePath)) return fallback;
+      return JSON.parse(fsMod.readFileSync(filePath, 'utf8'));
+    } catch {
+      return fallback;
+    }
+  }
+
+  function writeJson(filePath, value) {
+    ensureDirs();
+    fsMod.writeFileSync(filePath, JSON.stringify(value, null, 2), 'utf8');
+    try {
+      fsMod.chmodSync(filePath, 0o600);
+    } catch {}
+  }
+
+  function listAccounts() {
+    const ids = readJson(indexFile, []);
+    return Array.isArray(ids) ? ids.filter(Boolean) : [];
+  }
+
+  function registerAccountId(accountId) {
+    const normalized = normalizeAccountId(accountId);
+    const next = listAccounts();
+    if (!next.includes(normalized)) next.push(normalized);
+    writeJson(indexFile, next);
+    return normalized;
+  }
+
+  function loadAccount(accountId) {
+    if (!accountId) return null;
+    return readJson(accountPath(accountId), null);
+  }
+
+  function saveAccount(accountId, payload) {
+    const normalized = registerAccountId(accountId);
+    const next = {
+      ...(loadAccount(normalized) || {}),
+      ...payload,
+      accountId: normalized,
+      savedAt: now().toISOString(),
+    };
+    writeJson(accountPath(normalized), next);
+    try {
+      fsMod.chmodSync(accountPath(normalized), 0o600);
+    } catch {}
+    return next;
+  }
+
+  function loadSession(sessionKey) {
+    return readJson(sessionPath(sessionKey), null);
+  }
+
+  function saveSession(sessionKey, payload) {
+    const normalized = normalizeSessionKey(sessionKey);
+    const next = {
+      ...(loadSession(normalized) || {}),
+      ...payload,
+      sessionKey: normalized,
+      savedAt: now().toISOString(),
+    };
+    writeJson(sessionPath(normalized), next);
+    return next;
+  }
+
+  async function startQrLogin(params = {}) {
+    const sessionKey = normalizeSessionKey(params.sessionKey || crypto.randomUUID());
+    const baseUrl = String(params.baseUrl || DEFAULT_BASE_URL).trim();
+    const botType = String(params.botType || '3').trim();
+    const routeTag = params.routeTag === undefined || params.routeTag === null ? null : String(params.routeTag).trim();
+    const qr = await apiClient.getBotQrCode({ baseUrl, botType, routeTag });
+    const session = saveSession(sessionKey, {
+      baseUrl,
+      botType,
+      routeTag,
+      qrcode: qr.qrcode,
+      qrcodeUrl: qr.qrcode_img_content,
+      startedAt: now().toISOString(),
+      rawStartResponse: qr,
+    });
+    log('INFO', `[WEIXIN] QR login started session=${sessionKey} bot_type=${botType}`);
+    return session;
+  }
+
+  async function waitForQrLogin(params = {}) {
+    const sessionKey = normalizeSessionKey(params.sessionKey || '');
+    const session = loadSession(sessionKey);
+    if (!session || !session.qrcode) throw new Error(`weixin session not found: ${sessionKey}`);
+    const timeoutMs = Math.max(Number(params.timeoutMs || 480000), 1000);
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const status = await apiClient.getQrCodeStatus({
+        baseUrl: session.baseUrl,
+        qrcode: session.qrcode,
+        routeTag: session.routeTag,
+      });
+      saveSession(sessionKey, { lastStatus: status.status || null, status });
+      if (status.status === 'confirmed') {
+        const accountId = normalizeAccountId(status.ilink_bot_id || '');
+        const account = saveAccount(accountId, {
+          token: status.bot_token,
+          baseUrl: status.baseurl || session.baseUrl,
+          userId: status.ilink_user_id || '',
+          botType: session.botType,
+          routeTag: session.routeTag,
+          linkedAt: now().toISOString(),
+        });
+        saveSession(sessionKey, { confirmedAt: now().toISOString(), accountId, status });
+        return { connected: true, account, status };
+      }
+      if (status.status === 'expired') {
+        return { connected: false, expired: true, status };
+      }
+      await sleep(params.pollIntervalMs || 1000);
+    }
+    return { connected: false, timeout: true };
+  }
+
+  return {
+    baseDir,
+    accountsDir,
+    sessionsDir,
+    listAccounts,
+    loadAccount,
+    saveAccount,
+    loadSession,
+    saveSession,
+    startQrLogin,
+    waitForQrLogin,
+    normalizeAccountId,
+    normalizeSessionKey,
+  };
+}
+
+module.exports = {
+  createWeixinAuthStore,
+};