@chainlesschain/personal-data-hub 0.1.0 → 0.2.1

package/lib/adapters/travel-ctrip/index.js

@@ -0,0 +1,151 @@
+/**
+ * Phase 9.3 — Ctrip (携程) order adapter.
+ *
+ * Ctrip has no official user export. Two input paths:
+ *   1. JSON dump from a 3rd-party scraper or user-curated file
+ *   2. Email order-confirmation events from Phase 5 (vault-side derive)
+ *
+ * Ctrip orders cover 4 sub-types: flight / hotel / train / cruise.
+ * We map each to the appropriate `vehicleType` in TravelRecord:
+ *   flight → "flight", hotel → "hotel", train → "train", cruise → "cruise"
+ */
+
+"use strict";
+
+const fs = require("node:fs");
+const { normalizeTravelRecord, parseChineseDateTime } = require("../travel-base");
+
+const NAME = "travel-ctrip";
+const VERSION = "0.5.0";
+
+class CtripAdapter {
+  constructor(opts = {}) {
+    if (!opts.account || !opts.account.email) {
+      throw new Error("CtripAdapter: opts.account.email required");
+    }
+    this.account = opts.account;
+    this._dataPath = opts.dataPath || null;
+
+    this.name = NAME;
+    this.version = VERSION;
+    this.capabilities = ["import:json", "parse:ctrip-orders"];
+    this.extractMode = "file-import";
+    this.rateLimits = {};
+    this.dataDisclosure = {
+      fields: [
+        "ctrip:orderId / type / fromCity / toCity / dates / passengerName / price / carrier",
+      ],
+      sensitivity: "medium",
+      legalGate: false,
+    };
+  }
+
+  async authenticate() {
+    return { ok: true, account: this.account.email };
+  }
+
+  async healthCheck() {
+    return { ok: true, lastChecked: Date.now() };
+  }
+
+  async *sync(opts = {}) {
+    const dataPath = opts.dataPath || this._dataPath;
+    if (!dataPath || !fs.existsSync(dataPath)) return;
+    const text = fs.readFileSync(dataPath, "utf-8");
+    let records;
+    try {
+      records = parseRecords(text);
+    } catch (err) {
+      throw new Error(`CtripAdapter: parse failed: ${err.message}`);
+    }
+    for (const r of records) {
+      yield {
+        adapter: NAME,
+        originalId: r.recordId,
+        capturedAt: r.bookedAt || r.departureMs || Date.now(),
+        payload: { record: r },
+      };
+    }
+  }
+
+  normalize(raw) {
+    if (!raw || !raw.payload || !raw.payload.record) {
+      throw new Error("CtripAdapter.normalize: raw.payload.record missing");
+    }
+    return normalizeTravelRecord(raw.payload.record, {
+      adapterName: NAME,
+      adapterVersion: VERSION,
+    });
+  }
+}
+
+const TYPE_MAP = {
+  flight: "flight",
+  airline: "flight",
+  hotel: "hotel",
+  train: "train",
+  cruise: "cruise",
+  bus: "bus",
+  car: "car",
+};
+
+function parseRecords(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (_e) {
+    // Try JSONL
+    raw = text
+      .split(/\r?\n/)
+      .filter((l) => l.trim().startsWith("{"))
+      .map((l) => JSON.parse(l));
+  }
+  const orders = Array.isArray(raw) ? raw : raw.orders || [];
+  return orders.map(orderToRecord).filter(Boolean);
+}
+
+function orderToRecord(o) {
+  if (!o || typeof o !== "object") return null;
+  const recordId = o.orderId || o.id || o.order_no;
+  if (!recordId) return null;
+  const type = (o.type || o.orderType || "").toLowerCase();
+  const vehicleType = TYPE_MAP[type] || "trip";
+
+  return {
+    vendorId: "ctrip",
+    recordId: String(recordId),
+    vehicleType,
+    from: o.fromCity || o.from_city || o.depCity
+      ? { city: o.fromCity || o.from_city || o.depCity }
+      : null,
+    to: o.toCity || o.to_city || o.arrCity || o.hotelCity
+      ? { city: o.toCity || o.to_city || o.arrCity || o.hotelCity }
+      : null,
+    departureMs: numberOrParse(o.departureTime || o.dep_time || o.checkIn || o.check_in),
+    arrivalMs: numberOrParse(o.arrivalTime || o.arr_time || o.checkOut || o.check_out),
+    carrier: o.carrier || o.airline || o.hotelName || o.hotel_name || "携程",
+    vehicleNumber: o.flightNumber || o.flight_no || o.trainNumber || o.train_no,
+    totalCost: o.price != null
+      ? { value: parseFloat(o.price), currency: o.currency || "CNY" }
+      : null,
+    traveler: o.passengerName || o.passenger || o.guestName || o.guest_name,
+    confirmationCode: o.confirmationCode || o.pnr || o.confirmation_no,
+    bookedAt: numberOrParse(o.bookedAt || o.order_time),
+    extras: {
+      type,
+      ...(o.hotel ? { hotel: o.hotel } : {}),
+      ...(o.nights != null ? { nights: o.nights } : {}),
+    },
+  };
+}
+
+function numberOrParse(v) {
+  if (Number.isFinite(v)) return v;
+  if (typeof v === "string") {
+    if (/^\d+$/.test(v) && v.length >= 10) return parseInt(v, 10);
+    return parseChineseDateTime(v);
+  }
+  return null;
+}
+
+module.exports = { CtripAdapter, parseRecords, TYPE_MAP, NAME, VERSION };

package/lib/adapters/wechat/bootstrap.js

@@ -0,0 +1,146 @@
+/**
+ * Phase 12.6.7 — WeChat adapter bootstrap helper.
+ *
+ * Glues env-probe (12.6.4) → KeyProvider choice (12.6.1) → WechatAdapter
+ * instantiation (12.6.5) into one entry point so the IPC / WS / CLI
+ * layers don't each have to recreate the wiring.
+ *
+ * Decision matrix (mirrors `env-probe.decide`):
+ *   - probe.suggestedKeyProvider === "md5"   → MD5KeyProvider
+ *   - probe.suggestedKeyProvider === "frida" → FridaKeyProvider
+ *   - probe.suggestedKeyProvider === "unsupported" → no adapter created;
+ *     caller gets `{ ok: false, probe, reason }` and is expected to surface
+ *     `probe.reasons[]` to the user.
+ *
+ * Caller may force a specific provider via `opts.keyProviderOverride`
+ * (e.g. `"md5"` on a real device that env-probe misclassified, useful for
+ * the rare 8.0+ install where the user has the MD5 path working). The
+ * override skips the suggestion but the probe still runs and is returned
+ * for transparency.
+ *
+ * Returns shape (also see __tests__/adapters/wechat-bootstrap.test.js):
+ *
+ *   { ok: true,  adapter, keyProvider, probe }
+ *   { ok: false, reason: "ENV_UNSUPPORTED" | "MD5_NEEDS_WECHAT_DATA_PATH"
+ *                       | "FRIDA_NEEDS_WXID" | "ADAPTER_CTOR_FAILED",
+ *     probe, message? }
+ *
+ * Test seams:
+ *   - opts._probe          inject pre-computed probe (skip exec)
+ *   - opts._md5Provider    inject pre-built MD5KeyProvider instance
+ *   - opts._fridaProvider  inject pre-built FridaKeyProvider instance
+ *   - opts._WechatAdapter  swap the adapter constructor (default: real)
+ */
+"use strict";
+
+const { WechatAdapter } = require("./wechat-adapter");
+const { MD5KeyProvider } = require("./key-providers/md5-key-provider");
+const { FridaKeyProvider } = require("./key-providers/frida-key-provider");
+const { probe: realProbe } = require("./env-probe");
+
+/**
+ * @param {object} opts
+ * @param {object} opts.account              `{ uin, wxid? }` — adapter sees uin
+ * @param {string} [opts.dbPath]             local path to pulled EnMicroMsg.db
+ * @param {string} [opts.wechatDataPath]     local pulled /data/data/com.tencent.mm
+ *                                            (required when MD5KeyProvider is chosen)
+ * @param {object} [opts.fridaOpts]          forwarded to FridaKeyProvider ctor
+ *                                            (deviceId / packageName / timeoutMs)
+ * @param {string} [opts.keyProviderOverride] "md5" | "frida" — force selection
+ * @param {Function} [opts.exec]             exec seam forwarded to env-probe
+ * @param {object} [opts._probe]             pre-computed probe (test seam)
+ * @param {object} [opts._md5Provider]       (test seam)
+ * @param {object} [opts._fridaProvider]     (test seam)
+ * @param {Function} [opts._WechatAdapter]   (test seam)
+ * @returns {Promise<object>}
+ */
+async function bootstrapWechatAdapter(opts = {}) {
+  if (!opts || typeof opts !== "object") {
+    throw new Error("bootstrapWechatAdapter: opts required");
+  }
+  if (!opts.account || !opts.account.uin) {
+    throw new Error("bootstrapWechatAdapter: opts.account.uin required");
+  }
+
+  const probe = opts._probe || (await realProbe({ exec: opts.exec }));
+  const chosen = opts.keyProviderOverride || probe.suggestedKeyProvider;
+
+  if (chosen === "unsupported") {
+    return {
+      ok: false,
+      reason: "ENV_UNSUPPORTED",
+      message: (probe.reasons || []).join("; ") || "env-probe could not pick a viable KeyProvider",
+      probe,
+    };
+  }
+
+  // Pick / build KeyProvider
+  let keyProvider;
+  if (chosen === "md5") {
+    if (opts._md5Provider) {
+      keyProvider = opts._md5Provider;
+    } else {
+      if (!opts.wechatDataPath) {
+        return {
+          ok: false,
+          reason: "MD5_NEEDS_WECHAT_DATA_PATH",
+          message: "MD5KeyProvider requires opts.wechatDataPath (pulled /data/data/com.tencent.mm/)",
+          probe,
+        };
+      }
+      keyProvider = new MD5KeyProvider({
+        wechatDataPath: opts.wechatDataPath,
+        uin: opts.account.uin,
+      });
+    }
+  } else if (chosen === "frida") {
+    if (opts._fridaProvider) {
+      keyProvider = opts._fridaProvider;
+    } else {
+      // FridaKeyProvider doesn't strictly need wxid, but we surface a
+      // clear error here when the wire-level account looks incomplete.
+      if (!opts.account.uin) {
+        return {
+          ok: false,
+          reason: "FRIDA_NEEDS_WXID",
+          message: "FridaKeyProvider expects opts.account.uin for downstream adapter wiring",
+          probe,
+        };
+      }
+      keyProvider = new FridaKeyProvider({
+        deviceId: (opts.fridaOpts && opts.fridaOpts.deviceId) || probe.device.serial || null,
+        packageName: (opts.fridaOpts && opts.fridaOpts.packageName) || "com.tencent.mm",
+        timeoutMs: (opts.fridaOpts && opts.fridaOpts.timeoutMs) || 30_000,
+      });
+    }
+  } else {
+    return {
+      ok: false,
+      reason: "UNKNOWN_KEY_PROVIDER",
+      message: `Unknown keyProvider "${chosen}"`,
+      probe,
+    };
+  }
+
+  // Instantiate adapter
+  const AdapterCtor = opts._WechatAdapter || WechatAdapter;
+  let adapter;
+  try {
+    adapter = new AdapterCtor({
+      account: opts.account,
+      dbPath: opts.dbPath || null,
+      keyProvider,
+    });
+  } catch (err) {
+    return {
+      ok: false,
+      reason: "ADAPTER_CTOR_FAILED",
+      message: err && err.message ? err.message : String(err),
+      probe,
+    };
+  }
+
+  return { ok: true, adapter, keyProvider, probe };
+}
+
+module.exports = { bootstrapWechatAdapter };

package/lib/adapters/wechat/content-parser.js

@@ -0,0 +1,326 @@
+/**
+ * Phase 12 v0.5 — WeChat message.content parser.
+ *
+ * Frida-INDEPENDENT — operates on decrypted message rows AFTER db-reader
+ * has done its job. Pure string/XML parsing.
+ *
+ * Handles the 6 common message types per `Adapter_WeChat_SQLCipher.md` §4.4:
+ *   type=1   text
+ *   type=3   image (XML w/ cdnUrl/md5/imgPath)
+ *   type=34  voice .amr (XML w/ voiceLength/fileName)
+ *   type=43  video (XML w/ cdnUrl)
+ *   type=47  GIF/emoji (XML w/ md5/filename)
+ *   type=49  composite — nested <appmsg type="N">, sub-types:
+ *            2 image, 3 music, 4 video, 5 link, 6 file, 8 GIF,
+ *            17 location, 19 forwarded, 21 redpacket, 33/36 mini-program,
+ *            51 channel video
+ *   type=10000 system message
+ *
+ * Output is always `{ kind, text, structured }`:
+ *   - kind: short string ("text" / "image" / "voice" / "link" / etc.)
+ *   - text: human-readable summary (for vault content.text)
+ *   - structured: parsed fields (for vault content.extra)
+ *
+ * Group-message prefix `<wxid_xxx>:\n` is stripped + returned in
+ * `structured.senderWxid` so the message text stays clean.
+ */
+
+"use strict";
+
+const TYPE_NAMES = {
+  1: "text",
+  3: "image",
+  34: "voice",
+  42: "card",
+  43: "video",
+  47: "emoji",
+  48: "location",
+  49: "appmsg",
+  50: "voipcall",
+  10000: "system",
+};
+
+const APPMSG_SUBTYPES = {
+  1: "text-link",
+  2: "image-share",
+  3: "music",
+  4: "video",
+  5: "link",
+  6: "file",
+  8: "gif",
+  17: "location-share",
+  19: "forwarded",
+  21: "redpacket",
+  33: "miniprogram",
+  36: "miniprogram",
+  51: "channel-video",
+};
+
+/**
+ * Top-level: parse a WeChat message row's content + type.
+ *
+ * @param {object} row  { content, type, isSend, talker, ... }
+ * @returns {{ kind, text, structured }}
+ */
+function parseContent(row) {
+  if (!row || typeof row !== "object") {
+    return { kind: "unknown", text: "", structured: {} };
+  }
+  const type = Number(row.type);
+  const isGroup = isGroupTalker(row.talker);
+  const rawContent = typeof row.content === "string" ? row.content : "";
+
+  // Strip group sender prefix
+  let groupSenderWxid = null;
+  let body = rawContent;
+  if (isGroup) {
+    const m = /^([a-zA-Z0-9_-]+):\n/.exec(rawContent);
+    if (m) {
+      groupSenderWxid = m[1];
+      body = rawContent.slice(m[0].length);
+    }
+  }
+
+  let result;
+  switch (type) {
+    case 1:
+      result = parseText(body);
+      break;
+    case 3:
+      result = parseImage(body);
+      break;
+    case 34:
+      result = parseVoice(body);
+      break;
+    case 42:
+      result = parseCard(body);
+      break;
+    case 43:
+      result = parseVideo(body);
+      break;
+    case 47:
+      result = parseEmoji(body);
+      break;
+    case 48:
+      result = parseLocation(body);
+      break;
+    case 49:
+      result = parseAppMsg(body);
+      break;
+    case 50:
+      result = parseVoipCall(body);
+      break;
+    case 10000:
+      result = parseSystem(body);
+      break;
+    default:
+      result = {
+        kind: TYPE_NAMES[type] || `type-${type}`,
+        text: body.slice(0, 200),
+        structured: { type, body: body.slice(0, 1000) },
+      };
+  }
+
+  if (groupSenderWxid) {
+    result.structured = { ...result.structured, senderWxid: groupSenderWxid };
+  }
+  return result;
+}
+
+// ─── per-type parsers ────────────────────────────────────────────────────
+
+function parseText(body) {
+  return { kind: "text", text: body, structured: {} };
+}
+
+function parseImage(body) {
+  const meta = parseXmlAttrs(body, "img");
+  return {
+    kind: "image",
+    text: "[图片]",
+    structured: {
+      cdnUrl: meta.cdnbigimgurl || meta.cdnmidimgurl || null,
+      md5: meta.md5 || null,
+      length: meta.length ? parseInt(meta.length, 10) : null,
+    },
+  };
+}
+
+function parseVoice(body) {
+  const meta = parseXmlAttrs(body, "voicemsg");
+  return {
+    kind: "voice",
+    text: "[语音]",
+    structured: {
+      fileName: meta.clientmsgid || null,
+      voiceLength: meta.voicelength ? parseInt(meta.voicelength, 10) : null,
+      fileType: meta.fromusername || null,
+    },
+  };
+}
+
+function parseCard(body) {
+  const meta = parseXmlAttrs(body, "msg");
+  return {
+    kind: "card",
+    text: `[名片] ${meta.nickname || meta.username || ""}`,
+    structured: {
+      nickname: meta.nickname || null,
+      username: meta.username || null,
+      province: meta.province || null,
+      city: meta.city || null,
+    },
+  };
+}
+
+function parseVideo(body) {
+  const meta = parseXmlAttrs(body, "videomsg");
+  return {
+    kind: "video",
+    text: "[视频]",
+    structured: {
+      cdnUrl: meta.cdnvideourl || null,
+      length: meta.length ? parseInt(meta.length, 10) : null,
+      playLength: meta.playlength ? parseInt(meta.playlength, 10) : null,
+    },
+  };
+}
+
+function parseEmoji(body) {
+  const meta = parseXmlAttrs(body, "emoji");
+  return {
+    kind: "emoji",
+    text: "[表情]",
+    structured: { md5: meta.md5 || null, type: meta.type || null },
+  };
+}
+
+function parseLocation(body) {
+  const meta = parseXmlAttrs(body, "location");
+  return {
+    kind: "location",
+    text: `[位置] ${meta.label || meta.poiname || ""}`,
+    structured: {
+      x: meta.x ? parseFloat(meta.x) : null,
+      y: meta.y ? parseFloat(meta.y) : null,
+      label: meta.label || null,
+      poiName: meta.poiname || null,
+    },
+  };
+}
+
+function parseAppMsg(body) {
+  // Type 49: <msg><appmsg type="N"><...subtype-specific...></appmsg></msg>
+  const appType = extractAppMsgType(body);
+  const subtype = APPMSG_SUBTYPES[appType] || `appmsg-${appType}`;
+  const title = extractTag(body, "title");
+  const desc = extractTag(body, "des");
+  const url = extractTag(body, "url");
+
+  const structured = {
+    appType,
+    subtype,
+    title: title || null,
+    desc: desc || null,
+    url: url || null,
+  };
+
+  // Redpacket-specific
+  if (appType === 21) {
+    structured.redPacketTitle = title;
+  }
+  // File-specific
+  if (appType === 6) {
+    structured.fileName = title;
+    structured.fileSize = extractTag(body, "totallen");
+  }
+  // Mini program
+  if (appType === 33 || appType === 36) {
+    structured.miniProgramName = extractTag(body, "sourcedisplayname")
+      || extractTag(body, "weappiconurl") || title;
+  }
+
+  const text = title ? `[${subtype}] ${title}` : `[${subtype}]`;
+  return { kind: subtype, text, structured };
+}
+
+function parseVoipCall(body) {
+  return {
+    kind: "voipcall",
+    text: "[通话]",
+    structured: { raw: body.slice(0, 500) },
+  };
+}
+
+function parseSystem(body) {
+  return {
+    kind: "system",
+    text: body.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim().slice(0, 300),
+    structured: {},
+  };
+}
+
+// ─── helpers ────────────────────────────────────────────────────────────
+
+/**
+ * Parse XML attributes of a named tag into a flat key-value map.
+ * E.g. <img attr1="v1" attr2="v2" /> → { attr1: "v1", attr2: "v2" }.
+ * Returns {} when the tag isn't found.
+ */
+function parseXmlAttrs(xml, tagName) {
+  if (typeof xml !== "string" || xml.length === 0) return {};
+  const re = new RegExp(`<${tagName}\\b([^>]*)`, "i");
+  const m = re.exec(xml);
+  if (!m) return {};
+  const attrsText = m[1];
+  const out = {};
+  const attrRe = /(\w+)\s*=\s*"([^"]*)"/g;
+  let am;
+  while ((am = attrRe.exec(attrsText)) !== null) {
+    out[am[1].toLowerCase()] = am[2];
+  }
+  return out;
+}
+
+/**
+ * Pull the text content of a tag: <title>X</title> → "X".
+ */
+function extractTag(xml, tagName) {
+  if (typeof xml !== "string") return null;
+  const re = new RegExp(`<${tagName}(?:\\s[^>]*)?>([\\s\\S]*?)<\\/${tagName}>`, "i");
+  const m = re.exec(xml);
+  if (!m) return null;
+  return decodeXmlEntities(m[1].trim());
+}
+
+function extractAppMsgType(xml) {
+  if (typeof xml !== "string") return -1;
+  const re = /<appmsg\s+[^>]*type\s*=\s*"(\d+)"|<type>(\d+)<\/type>/i;
+  const m = re.exec(xml);
+  if (!m) return -1;
+  return parseInt(m[1] || m[2], 10);
+}
+
+function decodeXmlEntities(s) {
+  return String(s)
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#(\d+);/g, (_, n) => String.fromCharCode(parseInt(n, 10)));
+}
+
+function isGroupTalker(talker) {
+  // Group chat talker IDs end with @chatroom
+  return typeof talker === "string" && talker.endsWith("@chatroom");
+}
+
+module.exports = {
+  parseContent,
+  parseXmlAttrs,
+  extractTag,
+  extractAppMsgType,
+  isGroupTalker,
+  TYPE_NAMES,
+  APPMSG_SUBTYPES,
+};