chainlesschain 0.162.19 → 0.162.25

package/src/lib/host-adb-bridge.js

@@ -381,7 +381,71 @@ async function readSnapshot(params, opts) {
   return stdout;
 }
 
+/**
+ * Phase B0 — plugin point for platform-specific ADB methods.
+ *
+ * `opts.extensions` is an optional `{ [methodName]: handler }` map. Each
+ * handler is called as `handler(params, ctx)` where `ctx` exposes the
+ * shared ADB primitives so platform extensions don't re-implement
+ * device-picking or row-parsing:
+ *
+ *   ctx = {
+ *     adb,                    // (args, opts) => Promise<stdout>
+ *     pickDevice,             // (opts) => Promise<serial>
+ *     parseContentQueryRows,  // (stdout) => Array<{key:value}>
+ *   }
+ *
+ * Resolution order in `invoke(method, params)`:
+ *   1. Built-in method (the switch below)
+ *   2. Extension method from opts.extensions
+ *   3. Throw HostAdbBridgeUnavailableError
+ *
+ * Built-ins always win — extensions cannot shadow them. This guarantees
+ * the multipath plan's Phase 1+ per-platform extensions can't break the
+ * already-shipping system-data-android consumer.
+ *
+ * Example (Phase 1 will land for real):
+ *   const bridge = createHostAdbBridge({
+ *     extensions: {
+ *       "douyin.snapshot": async (params, { adb, pickDevice }) => {
+ *         const serial = await pickDevice();
+ *         const uid = params.uid;
+ *         const out = await adb(
+ *           ["shell", "su", "-c", `base64 /data/data/com.ss.android.ugc.aweme/databases/${uid}_im.db`],
+ *           { serial, timeoutMs: 60_000 },
+ *         );
+ *         return { snapshotBase64: out };
+ *       },
+ *     },
+ *   });
+ *   await bridge.invoke("douyin.snapshot", { uid: "1234567890" });
+ */
+const BUILTIN_METHODS = new Set([
+  "contacts.query",
+  "app.list",
+  "sms.query",
+  "call.query",
+  "media.list",
+  "snapshot.list",
+  "snapshot.read",
+]);
+
 export function createHostAdbBridge(opts = {}) {
+  const extensions = opts.extensions || {};
+  // Defense: warn (but allow) when an extension tries to shadow a
+  // built-in. Built-ins always win in dispatch — Phase B0 keeps this
+  // a soft warning so it surfaces in tests; we can upgrade to a hard
+  // throw in Phase 1 if any extension author actually attempts it.
+  for (const k of Object.keys(extensions)) {
+    if (BUILTIN_METHODS.has(k)) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        `host-adb-bridge: extension "${k}" shadows a built-in method and will be ignored at dispatch`,
+      );
+    }
+  }
+  const ctx = { adb, pickDevice, parseContentQueryRows };
+
   return {
     /**
      * SystemDataAndroidAdapter._bridgeAvailable() reads this; must be
@@ -393,6 +457,13 @@ export function createHostAdbBridge(opts = {}) {
     caps() {
       return { available: true };
     },
+    /**
+     * Diagnostic only — reflects extension method names registered for
+     * this bridge instance. Useful for `cc doctor`-style introspection.
+     */
+    extensionMethods() {
+      return Object.keys(extensions).filter((k) => !BUILTIN_METHODS.has(k));
+    },
     async invoke(method, params = {}) {
       switch (method) {
         case "contacts.query":
@@ -409,10 +480,15 @@ export function createHostAdbBridge(opts = {}) {
           return await listSnapshots(params, opts);
         case "snapshot.read":
           return await readSnapshot(params, opts);
-        default:
+        default: {
+          const ext = extensions[method];
+          if (typeof ext === "function") {
+            return await ext(params, ctx);
+          }
           throw new HostAdbBridgeUnavailableError(
             `method "${method}" not implemented by host-adb-bridge`,
           );
+        }
       }
     },
   };

package/src/lib/personal-data-hub-wiring.js

@@ -64,6 +64,12 @@ const {
   JdAdapter,
   MeituanAdapter,
   PinduoduoAdapter,
+  Train12306Adapter,
+  TaobaoAdapter,
+  CtripAdapter,
+  AmapAdapter,
+  TelegramAdapter,
+  WhatsAppAdapter,
   EntityResolver,
   EntityResolverEmbeddingStage,
   EntityResolverLLMStage,
@@ -147,6 +153,11 @@ export function resolveHubDir() {
 }
 
 async function initHub() {
+  // Phase 1c: hoisted so the hub-level `bilibiliAdbSync` method can reuse
+  // the same bridge instance the system-data-android adapter wires below.
+  // Single bridge per hub keeps `bilibili.cookies` extension state /
+  // adb path resolution / device picking consistent across callers.
+  let hostAdbBridge = null;
   const hubDir = resolveHubDir();
   mkdirSync(hubDir, { recursive: true });
   mkdirSync(join(hubDir, "keys"), { recursive: true });
@@ -204,9 +215,20 @@ async function initHub() {
   // and skip embedding+LLM stages entirely. Rule-stage still runs; the
   // resolve_queue picks up enqueued pairs later if a host with Ollama is
   // ever attached (e.g. desktop-side replay).
+  //
+  // 2026-05-25 — broadened the detection. The old startsWith("/data/data/
+  // com.chainlesschain.android") missed two cases:
+  //   1. /data/user/0/ — on Android 7+ (multi-user), context.filesDir
+  //      resolves under /data/user/0/<pkg>/ instead of /data/data/<pkg>/,
+  //      so the legacy startsWith never matched on real device.
+  //   2. Variant suffixes — com.chainlesschain.android.debug,
+  //      .staging, etc. all have a separate package id but should share
+  //      the in-APK skip behaviour.
+  // Match either path prefix + optional variant suffix in one regex; if
+  // the env override is set, honour it unconditionally.
   const isInAppAndroidCc =
     typeof process.env.PREFIX === "string" &&
-    process.env.PREFIX.startsWith("/data/data/com.chainlesschain.android");
+    /\/com\.chainlesschain\.android(\.[a-z]+)?\//.test(process.env.PREFIX);
   const skipEmbeddings =
     isInAppAndroidCc || process.env.CC_HUB_DISABLE_EMBEDDINGS === "1";
   try {
@@ -290,7 +312,33 @@ async function initHub() {
     // + caveats (Windows CRLF parse trap, 0/multi device, ENOENT).
     try {
       const { createHostAdbBridge } = await import("./host-adb-bridge.js");
-      const hostAdbBridge = createHostAdbBridge();
+      // Phase 1b: register `bilibili.cookies` extension so the Phase 1c
+      // collector can pull WebView cookies from the user's Android Bilibili
+      // App. The factory is a pure function — no side effects until the
+      // handler is invoked, so cost of always-registering is zero.
+      const { createBilibiliCookiesExtension } =
+        await import("@chainlesschain/personal-data-hub/adapters/social-bilibili-adb");
+      // Phase 2a: register `douyin.pull-im-db` extension so the
+      // douyinAdbSync hub method can pull <uid>_im.db cohort from the
+      // user's Android Douyin App.
+      const { createDouyinDbExtension } =
+        await import("@chainlesschain/personal-data-hub/adapters/social-douyin-adb");
+      // Phase 3a: register `weibo.cookies` extension for the Weibo
+      // C-path collector (m.weibo.cn cookies + 4 HTTP endpoints).
+      const { createWeiboCookiesExtension } =
+        await import("@chainlesschain/personal-data-hub/adapters/social-weibo-adb");
+      // Phase 3c: register `xhs.cookies` extension for the Xhs C-path
+      // collector (xiaohongshu.com cookies + 4 endpoints with X-S sign).
+      const { createXhsCookiesExtension } =
+        await import("@chainlesschain/personal-data-hub/adapters/social-xiaohongshu-adb");
+      hostAdbBridge = createHostAdbBridge({
+        extensions: {
+          "bilibili.cookies": createBilibiliCookiesExtension(),
+          "douyin.pull-im-db": createDouyinDbExtension(),
+          "weibo.cookies": createWeiboCookiesExtension(),
+          "xhs.cookies": createXhsCookiesExtension(),
+        },
+      });
       sda._deps.bridgeProvider = () => hostAdbBridge;
     } catch (_e) {
       // Bridge module missing or failed to load — leave snapshot-only.
@@ -387,14 +435,21 @@ async function initHub() {
   // reads it; no per-account credential needed at boot. Each wrapped in
   // its own try so one broken ctor doesn't cascade.
   //
-  // **Deferred** (need per-account credential — `<vendor>-accounts.json`
-  // loader infra similar to email/alipay/wechat, not yet built):
-  //   Train12306Adapter (opts.account.username)
-  //   CtripAdapter      (opts.account.email)
-  //   AmapAdapter       (opts.account.deviceId)
-  //   TaobaoAdapter     (opts.account.userId)
-  //   TelegramAdapter   (opts.account.userId)
-  //   WhatsAppAdapter   (opts.account.phone)
+  // **No more deferred adapters at boot** — 2026-05-25 final pass made all
+  // sqlite/device-pull adapters (Amap/Telegram/WhatsApp) ctor-optional:
+  // account.<x> dropped from required, inputPath alias added. The sqlite
+  // sync still requires the user to pre-extract the SQLite db (Telegram
+  // cache4.db unencrypted; WhatsApp msgstore.db needs WhatsApp Crypt key;
+  // Amap amap.db needs root ADB pull) — but the registry slot is now
+  // claimed so syncAdapter("<name>", path) routes correctly instead of
+  // "no adapter X" silent swallow. v0.2 followup: Android in-APK extractor
+  // for these 3 sqlite adapters (depends on root ADB / device-specific
+  // Crypt key recovery; previously blocked the whole code path before).
+  // Train12306Adapter moved out of deferred (v0.2 added snapshot mode —
+  // account.username OPTIONAL, see adapters/travel-12306/index.js:53-56);
+  // Android Kyfw12306LocalCollector ships snapshot JSON via
+  // ccRunner.syncAdapter("travel-12306", path) — must be registered here
+  // or cc returns "unknown adapter" + UI shows misleading "v0.2 补齐" hint.
   // Earlier oversight: v5.0.3.84 wired Telegram + WhatsApp here, but their
   // ctors throw without account args, so they were silently swallowed by
   // try/catch and never actually registered. Removed to make the list
@@ -411,6 +466,12 @@ async function initHub() {
     JdAdapter,
     MeituanAdapter,
     PinduoduoAdapter,
+    Train12306Adapter,
+    TaobaoAdapter,
+    CtripAdapter,
+    AmapAdapter,
+    TelegramAdapter,
+    WhatsAppAdapter,
   ]) {
     try {
       const adapter = new Cls();
@@ -420,6 +481,21 @@ async function initHub() {
     }
   }
 
+  // Phase 5.8 — email-imap snapshot mode (2026-05-25): Android
+  // EmailLocalCollector does Jakarta Mail IMAP fetch on-device + writes
+  // staging JSON; desktop EmailAdapter consumes it via snapshot path
+  // (no IMAP-account credential needed at boot). The user-driven
+  // `registerEmailAdapter` per-account flow still wires explicit IMAP
+  // sessions for desktop-direct IMAP fetch (different code path, both
+  // resolve `name === "email-imap"` — registry de-dups by name; the
+  // per-account flow wins when the user has registered an account).
+  try {
+    const emailSnapshot = new EmailAdapter({ snapshotMode: true });
+    if (!registry.has(emailSnapshot.name)) registry.register(emailSnapshot);
+  } catch (_err) {
+    // Continue boot even if snapshot ctor throws (shouldn't happen — no required opts)
+  }
+
   // Phase 6: auto-register persisted Alipay accounts.
   const alipayAccountsPath = join(hubDir, "alipay-accounts.json");
   const alipayAccounts = loadAlipayAccounts(alipayAccountsPath);
@@ -529,8 +605,12 @@ async function initHub() {
       if (!account || typeof account !== "object")
         throw new Error("account required");
       const adapter = new EmailAdapter({ account, ...opts });
+      // Phase 5.8 — if the boot-time snapshot stub claimed the "email-imap"
+      // slot, swap it out for this per-account IMAP adapter (user's explicit
+      // IMAP credentials should take priority over the Android-snapshot
+      // fallback). Both share `name === "email-imap"`.
       if (registry.has(adapter.name)) {
-        throw new Error(`adapter name "${adapter.name}" already registered`);
+        registry.unregister(adapter.name);
       }
       registry.register(adapter);
       const accounts = loadEmailAccounts(emailAccountsPath);
@@ -550,7 +630,16 @@ async function initHub() {
       const target = accounts.find((c) => c.account.email === emailAddress);
       const next = accounts.filter((c) => c.account.email !== emailAddress);
       saveEmailAccounts(emailAccountsPath, next);
-      if (target) registry.unregister("email-imap");
+      if (target) {
+        registry.unregister("email-imap");
+        // Phase 5.8 — restore the snapshot stub so Android sync paths still
+        // work after the user unregisters their explicit IMAP account.
+        try {
+          registry.register(new EmailAdapter({ snapshotMode: true }));
+        } catch (_err) {
+          // Defensive — snapshot ctor has no required opts so this shouldn't fail
+        }
+      }
       return { ok: true, removed: !!target };
     },
 
@@ -735,6 +824,254 @@ async function initHub() {
         lastSyncAt: row.lastSyncAt || null,
       }));
     },
+
+    // ─── Phase 1e — Bilibili C 路径 dry-run env probe ────────────────────
+    //
+    // "Doctor" mode mirrors `cc hub wechat doctor`: runs only the cookies-
+    // extraction half of the sync pipeline (no API calls, no vault writes)
+    // so the user can confirm root / Bilibili-installed / cookie-complete
+    // status before triggering a real sync. Same 9 typed reasons as
+    // bilibiliAdbSync — UI maps reasons to the same banners — but with
+    // an extra `cookieDiagnostic` payload on success so the doctor can
+    // print "found 5 of 5 cookies, no encrypted_value rows skipped, uid=N".
+    //
+    // Returns one of:
+    //   {ok: true, uid, extractedAt, cookieDiagnostic: {cookieCount, hadEncrypted}}
+    //   {ok: false, reason, message}  — same reason taxonomy as
+    //     bilibiliAdbSync; UI re-uses bilibiliReasonMessage()
+    async bilibiliAdbDoctor() {
+      if (!hostAdbBridge) {
+        return {
+          ok: false,
+          reason: "BRIDGE_UNAVAILABLE",
+          message:
+            "host-adb-bridge failed to initialize at hub boot — check `adb` is on PATH or set ADB_PATH env var",
+        };
+      }
+      try {
+        const result = await hostAdbBridge.invoke("bilibili.cookies");
+        return {
+          ok: true,
+          uid: result.uid,
+          extractedAt: result.extractedAt,
+          cookieDiagnostic: result.diagnostic || null,
+        };
+      } catch (err) {
+        const msg = err && err.message ? err.message : String(err);
+        const m = msg.match(/^(BILIBILI_[A-Z_]+)/);
+        return {
+          ok: false,
+          reason: m ? m[1] : "PROBE_FAILED",
+          message: msg,
+        };
+      }
+    },
+
+    // ─── Phase 1c — Bilibili C 路径 one-shot sync ────────────────────────
+    //
+    // Pulls cookies via the bilibili.cookies extension (P1a) → fetches
+    // history/favourite/dynamic/follow via BilibiliApiClient (P1b) → writes
+    // a snapshot JSON → calls registry.syncAdapter("social-bilibili") to
+    // ingest into the vault. Always cleans up the staging file even on
+    // error. Returns `{ok: true, report}` on success or
+    // `{ok: false, reason, message}` on failure with a stable typed reason
+    // string the UI can pattern-match (BILIBILI_NO_ROOT /
+    // BILIBILI_NOT_INSTALLED_OR_NEVER_LOGGED_IN / BILIBILI_COOKIES_INCOMPLETE
+    // / SYNC_FAILED / BRIDGE_UNAVAILABLE).
+    async bilibiliAdbSync(opts = {}) {
+      if (!hostAdbBridge) {
+        return {
+          ok: false,
+          reason: "BRIDGE_UNAVAILABLE",
+          message:
+            "host-adb-bridge failed to initialize at hub boot — check `adb` is on PATH or set ADB_PATH env var",
+        };
+      }
+      let collector;
+      try {
+        const mod =
+          await import("@chainlesschain/personal-data-hub/adapters/social-bilibili-adb");
+        collector = mod.default ? mod.default : mod;
+      } catch (err) {
+        return {
+          ok: false,
+          reason: "MODULE_LOAD_FAILED",
+          message: err && err.message ? err.message : String(err),
+        };
+      }
+      try {
+        const report = await collector.collectAndSync(
+          hostAdbBridge,
+          registry,
+          opts,
+        );
+        return { ok: true, report };
+      } catch (err) {
+        const msg = err && err.message ? err.message : String(err);
+        // Extract a typed reason prefix from the BILIBILI_* error codes
+        // the cookies-extension throws, falling back to SYNC_FAILED for
+        // anything from the API client / registry path.
+        const m = msg.match(/^(BILIBILI_[A-Z_]+)/);
+        return {
+          ok: false,
+          reason: m ? m[1] : "SYNC_FAILED",
+          message: msg,
+        };
+      }
+    },
+
+    // ─── Phase 2a — Douyin C 路径 one-shot sync ─────────────────────────
+    //
+    // Pulls <uid>_im.db cohort via the douyin.pull-im-db extension (P2a) →
+    // parses msg + SIMPLE_USER (abrignoni DFIR) → writes snapshot →
+    // syncAdapter("social-douyin") snapshot mode.
+    //
+    // 9 typed reason codes: BRIDGE_UNAVAILABLE / MODULE_LOAD_FAILED /
+    // DOUYIN_NO_ROOT / DOUYIN_NOT_INSTALLED / DOUYIN_NO_IM_DB /
+    // DOUYIN_MULTIPLE_USERS / DOUYIN_PULL_FAILED / DOUYIN_NOT_SQLITE /
+    // SYNC_FAILED.
+    async douyinAdbSync(opts = {}) {
+      if (!hostAdbBridge) {
+        return {
+          ok: false,
+          reason: "BRIDGE_UNAVAILABLE",
+          message:
+            "host-adb-bridge failed to initialize at hub boot — check `adb` is on PATH or set ADB_PATH env var",
+        };
+      }
+      let collector;
+      try {
+        const mod =
+          await import("@chainlesschain/personal-data-hub/adapters/social-douyin-adb");
+        collector = mod.default ? mod.default : mod;
+      } catch (err) {
+        return {
+          ok: false,
+          reason: "MODULE_LOAD_FAILED",
+          message: err && err.message ? err.message : String(err),
+        };
+      }
+      try {
+        const report = await collector.collectAndSync(
+          hostAdbBridge,
+          registry,
+          opts,
+        );
+        return { ok: true, report };
+      } catch (err) {
+        const msg = err && err.message ? err.message : String(err);
+        const m = msg.match(/^(DOUYIN_[A-Z_]+)/);
+        return {
+          ok: false,
+          reason: m ? m[1] : "SYNC_FAILED",
+          message: msg,
+        };
+      }
+    },
+
+    // ─── Phase 3a — Weibo C 路径 one-shot sync ──────────────────────────
+    //
+    // Pulls m.weibo.cn cookies via the weibo.cookies extension → fetchUid
+    // (/api/config — cookie has no inline UID) → 3 endpoints (posts /
+    // favourites / follows) → snapshot → syncAdapter("social-weibo")
+    // snapshot mode. **No WBI signing** (m.weibo.cn mobile API is
+    // sign-less).
+    //
+    // Typed reason codes: BRIDGE_UNAVAILABLE / MODULE_LOAD_FAILED /
+    // WEIBO_NO_ROOT / WEIBO_NOT_INSTALLED / WEIBO_COOKIES_EMPTY /
+    // WEIBO_COOKIES_TRUNCATED / WEIBO_NOT_SQLITE / WEIBO_COOKIES_INCOMPLETE /
+    // WEIBO_BASE64_PARSE / SYNC_FAILED.
+    async weiboAdbSync(opts = {}) {
+      if (!hostAdbBridge) {
+        return {
+          ok: false,
+          reason: "BRIDGE_UNAVAILABLE",
+          message:
+            "host-adb-bridge failed to initialize at hub boot — check `adb` is on PATH or set ADB_PATH env var",
+        };
+      }
+      let collector;
+      try {
+        const mod =
+          await import("@chainlesschain/personal-data-hub/adapters/social-weibo-adb");
+        collector = mod.default ? mod.default : mod;
+      } catch (err) {
+        return {
+          ok: false,
+          reason: "MODULE_LOAD_FAILED",
+          message: err && err.message ? err.message : String(err),
+        };
+      }
+      try {
+        const report = await collector.collectAndSync(
+          hostAdbBridge,
+          registry,
+          opts,
+        );
+        return { ok: true, report };
+      } catch (err) {
+        const msg = err && err.message ? err.message : String(err);
+        const m = msg.match(/^(WEIBO_[A-Z_]+)/);
+        return {
+          ok: false,
+          reason: m ? m[1] : "SYNC_FAILED",
+          message: msg,
+        };
+      }
+    },
+
+    // ─── Phase 3c — Xhs C 路径 one-shot sync ────────────────────────────
+    //
+    // Pulls xiaohongshu.com cookies via xhs.cookies extension → fetchMe
+    // (/user/me — no X-S) → 3 endpoints (notes/liked/follows, X-S signed)
+    // → snapshot → syncAdapter("social-xiaohongshu") snapshot mode.
+    //
+    // **X-S signing is best-effort** (~60% GET hit, <30% POST). Endpoint
+    // failures tolerated as partial results — lastErrorCode surfaces the
+    // 461 X-S rejection so UI can recommend "稍后重试".
+    //
+    // Typed reason codes: BRIDGE_UNAVAILABLE / MODULE_LOAD_FAILED /
+    // XHS_NO_ROOT / XHS_NOT_INSTALLED / XHS_COOKIES_EMPTY /
+    // XHS_COOKIES_TRUNCATED / XHS_NOT_SQLITE / XHS_COOKIES_INCOMPLETE /
+    // XHS_BASE64_PARSE / SYNC_FAILED.
+    async xhsAdbSync(opts = {}) {
+      if (!hostAdbBridge) {
+        return {
+          ok: false,
+          reason: "BRIDGE_UNAVAILABLE",
+          message:
+            "host-adb-bridge failed to initialize at hub boot — check `adb` is on PATH or set ADB_PATH env var",
+        };
+      }
+      let collector;
+      try {
+        const mod =
+          await import("@chainlesschain/personal-data-hub/adapters/social-xiaohongshu-adb");
+        collector = mod.default ? mod.default : mod;
+      } catch (err) {
+        return {
+          ok: false,
+          reason: "MODULE_LOAD_FAILED",
+          message: err && err.message ? err.message : String(err),
+        };
+      }
+      try {
+        const report = await collector.collectAndSync(
+          hostAdbBridge,
+          registry,
+          opts,
+        );
+        return { ok: true, report };
+      } catch (err) {
+        const msg = err && err.message ? err.message : String(err);
+        const m = msg.match(/^(XHS_[A-Z_]+)/);
+        return {
+          ok: false,
+          reason: m ? m[1] : "SYNC_FAILED",
+          message: msg,
+        };
+      }
+    },
   };
 }