chainlesschain 0.162.14 → 0.162.16

package/src/lib/__tests__/cc-android-bridge.test.js

@@ -0,0 +1,245 @@
+"use strict";
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import bridgeDefault, {
+  invoke,
+  caps,
+  AndroidBridgeUnavailableError,
+  detectAndroid,
+  loadBridgeConfig,
+  _deps,
+} from "../cc-android-bridge.js";
+
+// ─── env restore helpers ──────────────────────────────────────────────
+
+const ENV_KEYS = [
+  "CC_ANDROID_BRIDGE_OVERRIDE",
+  "CC_ANDROID_BRIDGE_CONFIG_DIR",
+  "PREFIX",
+];
+let envSnapshot;
+let depsSnapshot;
+
+beforeEach(() => {
+  envSnapshot = {};
+  for (const k of ENV_KEYS) envSnapshot[k] = process.env[k];
+  depsSnapshot = {
+    detectAndroid: _deps.detectAndroid,
+    loadBridgeConfig: _deps.loadBridgeConfig,
+    fetch: _deps.fetch,
+    testInvoke: _deps.testInvoke,
+  };
+});
+
+afterEach(() => {
+  for (const k of ENV_KEYS) {
+    if (envSnapshot[k] === undefined) delete process.env[k];
+    else process.env[k] = envSnapshot[k];
+  }
+  _deps.detectAndroid = depsSnapshot.detectAndroid;
+  _deps.loadBridgeConfig = depsSnapshot.loadBridgeConfig;
+  _deps.fetch = depsSnapshot.fetch;
+  _deps.testInvoke = depsSnapshot.testInvoke;
+});
+
+// ─── detectAndroid ────────────────────────────────────────────────────
+
+describe("detectAndroid", () => {
+  it("returns false on non-Android host", () => {
+    delete process.env.CC_ANDROID_BRIDGE_OVERRIDE;
+    delete process.env.PREFIX;
+    // platform = "win32" / "linux" / "darwin" — none is "android"
+    expect(detectAndroid()).toBe(false);
+  });
+
+  it("returns true under CC_ANDROID_BRIDGE_OVERRIDE=1", () => {
+    process.env.CC_ANDROID_BRIDGE_OVERRIDE = "1";
+    expect(detectAndroid()).toBe(true);
+  });
+
+  it("returns true when PREFIX matches Termux Android prefix", () => {
+    delete process.env.CC_ANDROID_BRIDGE_OVERRIDE;
+    process.env.PREFIX = "/data/data/com.chainlesschain.android/files/usr";
+    expect(detectAndroid()).toBe(true);
+  });
+});
+
+// ─── loadBridgeConfig ─────────────────────────────────────────────────
+
+describe("loadBridgeConfig", () => {
+  it("returns null off-device with no PREFIX + no override dir", () => {
+    delete process.env.CC_ANDROID_BRIDGE_CONFIG_DIR;
+    delete process.env.PREFIX;
+    expect(loadBridgeConfig()).toBeNull();
+  });
+
+  it("returns parsed config from CC_ANDROID_BRIDGE_CONFIG_DIR", async () => {
+    const { mkdtempSync, writeFileSync, rmSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    const { tmpdir } = await import("node:os");
+
+    const dir = mkdtempSync(join(tmpdir(), "cc-bridge-cfg-"));
+    writeFileSync(join(dir, "port"), "12345\n", "utf-8");
+    writeFileSync(join(dir, "token"), "deadbeef\n", "utf-8");
+    process.env.CC_ANDROID_BRIDGE_CONFIG_DIR = dir;
+
+    const cfg = loadBridgeConfig();
+    expect(cfg).toEqual({
+      port: 12345,
+      token: "deadbeef",
+      baseUrl: "http://127.0.0.1:12345",
+    });
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("returns null when port file missing", async () => {
+    const { mkdtempSync, writeFileSync, rmSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    const { tmpdir } = await import("node:os");
+    const dir = mkdtempSync(join(tmpdir(), "cc-bridge-cfg-"));
+    writeFileSync(join(dir, "token"), "x", "utf-8");
+    process.env.CC_ANDROID_BRIDGE_CONFIG_DIR = dir;
+    expect(loadBridgeConfig()).toBeNull();
+    rmSync(dir, { recursive: true, force: true });
+  });
+});
+
+// ─── invoke ───────────────────────────────────────────────────────────
+
+describe("invoke — error paths", () => {
+  it("throws TypeError on empty method", async () => {
+    await expect(invoke("")).rejects.toThrow(TypeError);
+  });
+
+  it("rejects ANDROID_BRIDGE_NOT_AVAILABLE off-device", async () => {
+    delete process.env.CC_ANDROID_BRIDGE_OVERRIDE;
+    _deps.detectAndroid = () => false;
+    await expect(invoke("contacts.query")).rejects.toBeInstanceOf(
+      AndroidBridgeUnavailableError,
+    );
+  });
+
+  it("rejects when bridge config missing on-device", async () => {
+    delete process.env.CC_ANDROID_BRIDGE_OVERRIDE;
+    _deps.detectAndroid = () => true;
+    _deps.loadBridgeConfig = () => null;
+    await expect(invoke("contacts.query")).rejects.toMatchObject({
+      code: "ANDROID_BRIDGE_NOT_AVAILABLE",
+      reason: expect.stringContaining("bridge config missing"),
+    });
+  });
+
+  it("rejects on fetch network error", async () => {
+    delete process.env.CC_ANDROID_BRIDGE_OVERRIDE;
+    _deps.detectAndroid = () => true;
+    _deps.loadBridgeConfig = () => ({
+      port: 8237,
+      token: "x",
+      baseUrl: "http://127.0.0.1:8237",
+    });
+    _deps.fetch = vi.fn(async () => {
+      throw new Error("ECONNREFUSED");
+    });
+    await expect(invoke("contacts.query")).rejects.toMatchObject({
+      code: "ANDROID_BRIDGE_NOT_AVAILABLE",
+      reason: expect.stringContaining("ECONNREFUSED"),
+    });
+  });
+
+  it("rejects on non-2xx response", async () => {
+    delete process.env.CC_ANDROID_BRIDGE_OVERRIDE;
+    _deps.detectAndroid = () => true;
+    _deps.loadBridgeConfig = () => ({
+      port: 8237,
+      token: "x",
+      baseUrl: "http://127.0.0.1:8237",
+    });
+    _deps.fetch = vi.fn(async () => ({
+      ok: false,
+      status: 401,
+      text: async () => "",
+    }));
+    await expect(invoke("contacts.query")).rejects.toMatchObject({
+      reason: expect.stringContaining("HTTP 401"),
+    });
+  });
+});
+
+describe("invoke — happy path", () => {
+  it("POSTs /invoke with Bearer token + JSON body, returns parsed JSON", async () => {
+    delete process.env.CC_ANDROID_BRIDGE_OVERRIDE;
+    _deps.detectAndroid = () => true;
+    _deps.loadBridgeConfig = () => ({
+      port: 8237,
+      token: "secret-token",
+      baseUrl: "http://127.0.0.1:8237",
+    });
+    const fetchSpy = vi.fn(async (url, init) => ({
+      ok: true,
+      status: 200,
+      text: async () => JSON.stringify({ contacts: [{ name: "Alice" }] }),
+    }));
+    _deps.fetch = fetchSpy;
+
+    const result = await invoke("contacts.query", { since: 0 });
+    expect(result).toEqual({ contacts: [{ name: "Alice" }] });
+    expect(fetchSpy).toHaveBeenCalledOnce();
+    const [url, init] = fetchSpy.mock.calls[0];
+    expect(url).toBe("http://127.0.0.1:8237/invoke?method=contacts.query");
+    expect(init.method).toBe("POST");
+    expect(init.headers["Authorization"]).toBe("Bearer secret-token");
+    expect(init.headers["Content-Type"]).toBe("application/json");
+    expect(JSON.parse(init.body)).toEqual({ since: 0 });
+  });
+
+  it("uses testInvoke when CC_ANDROID_BRIDGE_OVERRIDE=1", async () => {
+    process.env.CC_ANDROID_BRIDGE_OVERRIDE = "1";
+    _deps.testInvoke = vi.fn(async (m, p) => ({ echo: m, ...p }));
+    const result = await invoke("foo.bar", { x: 1 });
+    expect(result).toEqual({ echo: "foo.bar", x: 1 });
+  });
+});
+
+// ─── caps ─────────────────────────────────────────────────────────────
+
+describe("caps", () => {
+  it("returns available=false off-device", () => {
+    delete process.env.CC_ANDROID_BRIDGE_OVERRIDE;
+    _deps.detectAndroid = () => false;
+    const r = caps();
+    expect(r.available).toBe(false);
+    expect(r.reason).toContain("not-on-android");
+  });
+
+  it("returns available=false when bridge server not started", () => {
+    delete process.env.CC_ANDROID_BRIDGE_OVERRIDE;
+    _deps.detectAndroid = () => true;
+    _deps.loadBridgeConfig = () => null;
+    const r = caps();
+    expect(r.available).toBe(false);
+    expect(r.reason).toContain("bridge-server-not-started");
+  });
+
+  it("returns available=true with port when bridge is up", () => {
+    delete process.env.CC_ANDROID_BRIDGE_OVERRIDE;
+    _deps.detectAndroid = () => true;
+    _deps.loadBridgeConfig = () => ({ port: 8237, token: "x" });
+    const r = caps();
+    expect(r.available).toBe(true);
+    expect(r.port).toBe(8237);
+  });
+});
+
+// ─── default export ───────────────────────────────────────────────────
+
+describe("default export", () => {
+  it("exposes invoke / caps / Error class / _deps", () => {
+    expect(bridgeDefault.invoke).toBe(invoke);
+    expect(bridgeDefault.caps).toBe(caps);
+    expect(bridgeDefault.AndroidBridgeUnavailableError).toBe(
+      AndroidBridgeUnavailableError,
+    );
+    expect(bridgeDefault._deps).toBe(_deps);
+  });
+});

package/src/lib/cc-android-bridge.js

@@ -1,38 +1,39 @@
 /**
  * cc-android-bridge — Node-side facade for the Android JNI bridge.
  *
- * Plan A Sub-Phase A6/A7 scaffold (see `docs/design/Personal_Data_Hub_Android_Standalone_Cc.md`
- * §4.2 + §6.1). The eventual native binding (`cc-android-bridge.node`,
- * loaded from `android-app/app/src/main/cpp/`) exposes Java/Kotlin APIs to
- * the in-APK Node runtime: ContentResolver query, PackageManager listings,
- * Runtime.exec / Shizuku / Magisk su, Accessibility node tree, SAF DocumentFile
- * read.
+ * Plan A Sub-Phase A6 (see `docs/design/Personal_Data_Hub_Android_Standalone_Cc.md`).
  *
- * **v0.1 status**: the native .node binding is NOT yet shipped. This file is
- * a pure stub — every `invoke()` call rejects with ANDROID_BRIDGE_NOT_AVAILABLE.
- * It exists so the `cc android …` commands and `system-data-android` adapter
- * (A7 / A8) can land + be unit-tested ahead of the JNI work. When A6 ships
- * the .node binding, this file's `loadNativeBinding()` will resolve the real
- * module; method dispatch is already wired.
+ * **A6a transport (current)**: HTTP localhost. The Android app starts a
+ * tiny HTTP server (CcAndroidBridgeServer.kt) at App.onCreate; this file
+ * reads the port + token written to filesDir/.chainlesschain/bridge/ and
+ * forwards `invoke(method, params)` as `POST /invoke?method=<kebab>` with
+ * the JSON params as body and `Authorization: Bearer <token>`.
+ *
+ * Why HTTP not JNI: the cc subprocess is a separate Linux process (per
+ * memory android_cc_subprocess_execve_via_mksh) — JNI cannot bridge
+ * process boundaries. HTTP localhost gives the same UX with zero NDK
+ * toolchain dependency. The .so + Unix-socket path stays on the roadmap
+ * (A6b) for the in-process feel but is not blocking the feature.
  *
  * Detection precedence (highest first):
- *   1. process.env.CC_ANDROID_BRIDGE_OVERRIDE === "1" — test override; bridge
- *      reports "available" and routes through `_deps.testInvoke` (which tests
- *      replace with a mock). Lets us exercise the command code paths without
- *      a real device.
+ *   1. process.env.CC_ANDROID_BRIDGE_OVERRIDE === "1" — test override
  *   2. process.platform === "android"
  *   3. process.env.PREFIX startsWith "/data/data/com.chainlesschain.android/"
  *      (Termux $PREFIX pattern in the bundled cc).
  *
- * Method names are kebab-case to match the `cc android <verb>` CLI surface,
- * not the underlying JNI signatures (those use Java camelCase). Mapping
- * happens in the future native binding.
+ * Bridge config discovery (Android only):
+ *   - filesDir/.chainlesschain/bridge/port  — "8237" etc.
+ *   - filesDir/.chainlesschain/bridge/token — 48-hex-char auth token
+ * filesDir resolves to `$PREFIX/..` (Termux convention: filesDir is the
+ * parent of usr/).
+ *
+ * Method names are kebab-case to match the `cc android <verb>` CLI surface.
  */
 
-import { createRequire } from "node:module";
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
 
 const ANDROID_PREFIX = "/data/data/com.chainlesschain.android/";
-const nodeRequire = createRequire(import.meta.url);
 
 export function detectAndroid() {
   if (process.env.CC_ANDROID_BRIDGE_OVERRIDE === "1") return true;
@@ -47,19 +48,40 @@ export function detectAndroid() {
 }
 
 /**
- * Lazy-load the native .node binding when we're actually on Android. Stays
- * null elsewhere. The binding is expected at:
- *   $APK/lib/<abi>/cc-android-bridge.node
- * resolved via require.resolve("cc-android-bridge").
- *
- * Wrapped in try so a missing binding (current state pre-A6) doesn't crash
- * the CLI on import — `invoke()` reports it as a runtime error instead.
+ * Locate the Android app's filesDir from inside the in-APK cc subprocess.
+ * Termux convention: $PREFIX = filesDir/usr → filesDir = dirname($PREFIX).
+ * Falls back to env var CC_ANDROID_BRIDGE_CONFIG_DIR (LAN / desktop case
+ * where caller has discovered the Android filesDir some other way).
+ */
+function resolveBridgeConfigDir() {
+  if (process.env.CC_ANDROID_BRIDGE_CONFIG_DIR) {
+    return process.env.CC_ANDROID_BRIDGE_CONFIG_DIR;
+  }
+  if (
+    typeof process.env.PREFIX === "string" &&
+    process.env.PREFIX.startsWith(ANDROID_PREFIX)
+  ) {
+    return join(dirname(process.env.PREFIX), ".chainlesschain", "bridge");
+  }
+  return null;
+}
+
+/**
+ * Read the port + token written by CcAndroidBridgeServer.start() in
+ * filesDir/.chainlesschain/bridge/. Returns null if either file is missing
+ * (server not started yet, or running off-device without override).
  */
-export function loadNativeBinding() {
-  if (!detectAndroid()) return null;
-  if (process.env.CC_ANDROID_BRIDGE_OVERRIDE === "1") return null;
+export function loadBridgeConfig() {
+  const dir = resolveBridgeConfigDir();
+  if (!dir) return null;
   try {
-    return nodeRequire("cc-android-bridge");
+    const portPath = join(dir, "port");
+    const tokenPath = join(dir, "token");
+    if (!existsSync(portPath) || !existsSync(tokenPath)) return null;
+    const port = parseInt(readFileSync(portPath, "utf-8").trim(), 10);
+    const token = readFileSync(tokenPath, "utf-8").trim();
+    if (!Number.isFinite(port) || port <= 0 || !token) return null;
+    return { port, token, baseUrl: `http://127.0.0.1:${port}` };
   } catch (_e) {
     return null;
   }
@@ -74,17 +96,17 @@ export class AndroidBridgeUnavailableError extends Error {
 }
 
 /**
- * Invoke a bridge method.
+ * Invoke a bridge method via the HTTP transport.
  *
- * @param {string} method — kebab-case method name (e.g. "contacts.query",
- *   "fs.read", "a11y.query", "app.list").
+ * @param {string} method — kebab-case method name (e.g. "contacts.query")
  * @param {object} [params]
- * @returns {Promise<any>}
+ * @returns {Promise<any>}  Parsed JSON response from the bridge.
  *
  * Rejects with AndroidBridgeUnavailableError when:
- *  - Not running on Android (and CC_ANDROID_BRIDGE_OVERRIDE != 1)
- *  - Running on Android but native binding failed to load
- *  - Method is not registered in the native binding
+ *  - Not running on Android and CC_ANDROID_BRIDGE_OVERRIDE != 1
+ *  - Running on Android but bridge config (port/token) missing
+ *  - HTTP request fails or server returns non-200
+ *  - Method name unknown (server returns {"error": "UNKNOWN_METHOD"})
  */
 export async function invoke(method, params = {}) {
   if (typeof method !== "string" || method.length === 0) {
@@ -93,7 +115,7 @@ export async function invoke(method, params = {}) {
     );
   }
 
-  // Test path — _deps.testInvoke replaced by harness.
+  // Test path — harness replaces _deps.testInvoke.
   if (
     process.env.CC_ANDROID_BRIDGE_OVERRIDE === "1" &&
     typeof _deps.testInvoke === "function"
@@ -107,23 +129,45 @@ export async function invoke(method, params = {}) {
     );
   }
 
-  const native = _deps.loadNativeBinding();
-  if (!native) {
+  const config = _deps.loadBridgeConfig();
+  if (!config) {
+    throw new AndroidBridgeUnavailableError(
+      "bridge config missing — CcAndroidBridgeServer not started? (filesDir/.chainlesschain/bridge/{port,token})",
+    );
+  }
+
+  const url = `${config.baseUrl}/invoke?method=${encodeURIComponent(method)}`;
+  let resp;
+  try {
+    resp = await _deps.fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.token}`,
+      },
+      body: JSON.stringify(params || {}),
+    });
+  } catch (e) {
     throw new AndroidBridgeUnavailableError(
-      "native binding cc-android-bridge.node missing — A6 JNI module not yet bundled",
+      `HTTP transport error: ${e && e.message ? e.message : String(e)}`,
     );
   }
-  if (typeof native.invoke !== "function") {
+  if (!resp.ok) {
+    throw new AndroidBridgeUnavailableError(`bridge HTTP ${resp.status}`);
+  }
+  const text = await resp.text();
+  try {
+    return JSON.parse(text);
+  } catch (e) {
     throw new AndroidBridgeUnavailableError(
-      "native binding loaded but does not export invoke()",
+      `bridge returned non-JSON: ${text.slice(0, 200)}`,
     );
   }
-  return await native.invoke(method, params);
 }
 
 /**
- * Check whether the bridge is usable right now without throwing.
- * Returns `{ available: boolean, reason?: string }`.
+ * Check whether the bridge is reachable right now without throwing.
+ * Returns `{ available: boolean, reason?: string, port?: number }`.
  */
 export function caps() {
   if (process.env.CC_ANDROID_BRIDGE_OVERRIDE === "1") {
@@ -135,22 +179,22 @@ export function caps() {
       reason: `not-on-android (platform=${process.platform})`,
     };
   }
-  const native = _deps.loadNativeBinding();
-  if (!native) {
+  const config = _deps.loadBridgeConfig();
+  if (!config) {
     return {
       available: false,
-      reason: "native-binding-missing (A6 pending)",
+      reason: "bridge-server-not-started (port/token files missing)",
     };
   }
-  return { available: true };
+  return { available: true, port: config.port };
 }
 
 // _deps injection seam (per [[feedback-vi-mock-cjs-interop]]). Tests reach in
-// and replace these to exercise both success + error paths without needing
-// a real Android device or the unloaded native binding.
+// and replace these to exercise success / error paths without a real device.
 export const _deps = {
   detectAndroid,
-  loadNativeBinding,
+  loadBridgeConfig,
+  fetch: globalThis.fetch.bind(globalThis),
   testInvoke: null,
 };
 

package/src/lib/personal-data-hub-aichat-wizard.js

@@ -19,14 +19,26 @@ import { readFileSync, writeFileSync, mkdirSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { createRequire } from "node:module";
 
-import {
-  DEFAULT_VENDOR_SPECS,
-  HttpClient,
-  CookieAuthSession,
-} from "@chainlesschain/personal-data-hub/adapters/ai-chat-history";
-
 const _require = createRequire(import.meta.url);
 
+// Lazy-load `@chainlesschain/personal-data-hub/adapters/ai-chat-history` —
+// older nested copies of the hub package (e.g. PDH 0.2.0 left in
+// `packages/cli/node_modules/@chainlesschain/personal-data-hub/` by a stale
+// install) lack this subpath export. A static ESM import would crash the
+// whole wiring chain at module load time; lazy `_require` lets the error
+// surface only when actually called, and tolerates an older nested copy as
+// long as Node's resolution eventually walks up to a version that exports
+// the subpath. See sibling lazy-load at line 217 / 228 for cookie-capture-
+// spec + wizard-controller (same defence).
+let _aichatModule = null;
+function _loadAichatModule() {
+  if (_aichatModule) return _aichatModule;
+  _aichatModule = _require(
+    "@chainlesschain/personal-data-hub/adapters/ai-chat-history",
+  );
+  return _aichatModule;
+}
+
 export const ACCOUNTS_FILE = "aichat-accounts.json";
 
 /**
@@ -99,16 +111,14 @@ export function createAccountsStore({ hubDir }) {
  * spec.validateCookie(). Kept duplicated so the cli build stays ESM-pure
  * without reaching into desktop-app-vue.
  */
-export function createVendorAdapterBridge({
-  specs = DEFAULT_VENDOR_SPECS,
-  _httpClientFactory,
-} = {}) {
+export function createVendorAdapterBridge({ specs, _httpClientFactory } = {}) {
   // DEFAULT_VENDOR_SPECS is shipped as a vendor-keyed object; tests pass an
   // array. Normalize to an array first so byVendor lookup works either way.
-  const arr = Array.isArray(specs)
-    ? specs
-    : specs && typeof specs === "object"
-      ? Object.values(specs)
+  const effectiveSpecs = specs ?? _loadAichatModule().DEFAULT_VENDOR_SPECS;
+  const arr = Array.isArray(effectiveSpecs)
+    ? effectiveSpecs
+    : effectiveSpecs && typeof effectiveSpecs === "object"
+      ? Object.values(effectiveSpecs)
       : null;
   if (!arr || arr.length === 0) {
     throw new Error("aichat-wizard-cli: specs required");
@@ -119,7 +129,10 @@ export function createVendorAdapterBridge({
   }
   const buildClient =
     _httpClientFactory ||
-    ((vendor, spec) => new HttpClient({ vendor, rateLimits: spec.rateLimits }));
+    ((vendor, spec) => {
+      const { HttpClient } = _loadAichatModule();
+      return new HttpClient({ vendor, rateLimits: spec.rateLimits });
+    });
 
   async function registerVendor(vendor, cookies, _opts = {}) {
     const spec = byVendor.get(vendor);
@@ -137,6 +150,7 @@ export function createVendorAdapterBridge({
         error: err.message,
       };
     }
+    const { CookieAuthSession } = _loadAichatModule();
     const session = new CookieAuthSession({
       vendor,
       cookies: _jarToArray(cookies),

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

@@ -45,6 +45,7 @@ const {
   EmailAdapter,
   AlipayBillAdapter,
   SystemDataAndroidAdapter,
+  BilibiliAdapter,
   EntityResolver,
   EntityResolverEmbeddingStage,
   EntityResolverLLMStage,
@@ -61,8 +62,13 @@ import {
 } from "./personal-data-hub-aichat-wizard.js";
 
 async function loadAIChatHealthChecker() {
-  const mod =
-    await import("@chainlesschain/personal-data-hub/adapters/ai-chat-history/health-checker");
+  // Composed-at-runtime specifier so vite import-analysis (which fails
+  // to resolve subpath exports for dynamic imports in vitest SSR mode)
+  // skips this — the static scanner only descends into string literals.
+  const spec =
+    "@chainlesschain/personal-data-hub" +
+    "/adapters/ai-chat-history/health-checker";
+  const mod = await import(spec);
   return (mod.default || mod).createAIChatHealthChecker;
 }
 
@@ -263,6 +269,22 @@ async function initHub() {
     // surface the absence via list-adapters.
   }
 
+  // A8 v0.1 (2026-05-22) — social adapters in snapshot mode. Stateless: the
+  // Android UI captures a cookie via in-app WebView, runs OkHttp against the
+  // platform's HTTP API, parses the JSON response, writes a snapshot JSON to
+  // filesDir/.chainlesschain/staging/, then calls `cc hub sync-adapter <name>
+  // --input <path> --json` via LocalCcRunner. The adapter reads the file and
+  // yields events; the same registry handles KG + RAG + vault writes — no
+  // desktop connection required (this is the desktop-independent path the
+  // user repeatedly asked about). Each adapter no-ops at boot when no
+  // snapshot has been produced yet.
+  try {
+    const bilibili = new BilibiliAdapter();
+    if (!registry.has(bilibili.name)) registry.register(bilibili);
+  } catch (_err) {
+    // Continue boot
+  }
+
   // Phase 6: auto-register persisted Alipay accounts.
   const alipayAccountsPath = join(hubDir, "alipay-accounts.json");
   const alipayAccounts = loadAlipayAccounts(alipayAccountsPath);

package/src/assets/web-panel/assets/index-BIRYt1of.js

@@ -1 +0,0 @@
-import{A as o}from"./Row-DjHxhH1L.js";import{S as t}from"./index-b8GbH2Yi.js";import"./responsiveObserve-Iida9fIn.js";import"./vendor-DhFY8mDK.js";import"./useFlexGapSupport-BiOsz4rc.js";import"./styleChecker-aI-gsQO8.js";import"./index-gUACAWbM.js";import"./icons-BOPtEWK4.js";const l=t(o);export{l as default};

package/src/assets/web-panel/assets/index-CZfySmWX.js

@@ -1 +0,0 @@
-import{C as o}from"./Col-DU9NoUIi.js";import{S as t}from"./index-b8GbH2Yi.js";import"./index-gUACAWbM.js";import"./vendor-DhFY8mDK.js";import"./icons-BOPtEWK4.js";const s=t(o);export{s as default};