chainlesschain 0.162.13 → 0.162.14

package/src/gateways/ws/personal-data-hub-protocol.js

@@ -24,6 +24,9 @@ import {
 import { getAIChatWizard } from "../../lib/personal-data-hub-aichat-wizard.js";
 import { existsSync, unlinkSync, readdirSync } from "node:fs";
 import { join } from "node:path";
+import pdhPkg from "@chainlesschain/personal-data-hub";
+
+const { ingestSystemDataAndroidSnapshot } = pdhPkg;
 
 async function withHub(fn) {
   try {
@@ -42,6 +45,22 @@ export const PERSONAL_DATA_HUB_HANDLERS = {
       return await hub.engine.ask(msg.question, msg.options || {});
     }),
 
+  // Path Y: prompt context only, no LLM call. Lets web-shell / mobile host
+  // its own inference (Volcengine Doubao, OpenRouter, etc.) while keeping
+  // vault retrieval centralized.
+  "personal-data-hub.retrieve-context": async (msg) =>
+    withHub(async (hub) => {
+      if (!hub.engine) throw new Error("Analysis engine unavailable");
+      return await hub.engine.retrieveContext(msg.question, msg.options || {});
+    }),
+
+  // Path C: phone-collected ContentResolver + PackageManager snapshot →
+  // staging file → syncAdapter(system-data-android). Returns SyncReport.
+  "personal-data-hub.ingest-system-data-android": async (msg) =>
+    withHub(
+      async (hub) => await ingestSystemDataAndroidSnapshot(hub, msg.snapshot),
+    ),
+
   "personal-data-hub.stats": async () =>
     withHub((hub) => ({
       vault: hub.vault.stats(),
@@ -219,14 +238,15 @@ export const PERSONAL_DATA_HUB_HANDLERS = {
     withHub(async (hub) => await hub.probeWechatEnv()),
 
   "personal-data-hub.register-wechat": async (msg) =>
-    withHub(async (hub) =>
-      await hub.registerWechatAdapter({
-        account: msg.account,
-        dbPath: msg.dbPath,
-        wechatDataPath: msg.wechatDataPath,
-        fridaOpts: msg.fridaOpts,
-        keyProviderOverride: msg.keyProviderOverride,
-      }),
+    withHub(
+      async (hub) =>
+        await hub.registerWechatAdapter({
+          account: msg.account,
+          dbPath: msg.dbPath,
+          wechatDataPath: msg.wechatDataPath,
+          fridaOpts: msg.fridaOpts,
+          keyProviderOverride: msg.keyProviderOverride,
+        }),
     ),
 
   "personal-data-hub.unregister-wechat": async (msg) =>

package/src/index.js

@@ -16,6 +16,7 @@ import { registerChatCommand } from "./commands/chat.js";
 import { registerAskCommand } from "./commands/ask.js";
 import { registerLlmCommand } from "./commands/llm.js";
 import { registerHubCommand } from "./commands/hub.js";
+import { registerAndroidCommand } from "./commands/android.js";
 import {
   registerAgentCommand,
   registerSubAgentV2Command,
@@ -407,6 +408,7 @@ export function createProgram(opts = {}) {
   registerAskCommand(program);
   registerLlmCommand(program);
   registerHubCommand(program);
+  registerAndroidCommand(program);
   registerAgentCommand(program);
   registerSubAgentV2Command(program);
   registerExecBackendV2Command(program);

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

@@ -0,0 +1,162 @@
+/**
+ * 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.
+ *
+ * **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.
+ *
+ * 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.
+ *   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.
+ */
+
+import { createRequire } from "node:module";
+
+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;
+  if (process.platform === "android") return true;
+  if (
+    typeof process.env.PREFIX === "string" &&
+    process.env.PREFIX.startsWith(ANDROID_PREFIX)
+  ) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * 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.
+ */
+export function loadNativeBinding() {
+  if (!detectAndroid()) return null;
+  if (process.env.CC_ANDROID_BRIDGE_OVERRIDE === "1") return null;
+  try {
+    return nodeRequire("cc-android-bridge");
+  } catch (_e) {
+    return null;
+  }
+}
+
+export class AndroidBridgeUnavailableError extends Error {
+  constructor(reason) {
+    super(`ANDROID_BRIDGE_NOT_AVAILABLE: ${reason}`);
+    this.code = "ANDROID_BRIDGE_NOT_AVAILABLE";
+    this.reason = reason;
+  }
+}
+
+/**
+ * Invoke a bridge method.
+ *
+ * @param {string} method — kebab-case method name (e.g. "contacts.query",
+ *   "fs.read", "a11y.query", "app.list").
+ * @param {object} [params]
+ * @returns {Promise<any>}
+ *
+ * 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
+ */
+export async function invoke(method, params = {}) {
+  if (typeof method !== "string" || method.length === 0) {
+    throw new TypeError(
+      "cc-android-bridge.invoke: method must be non-empty string",
+    );
+  }
+
+  // Test path — _deps.testInvoke replaced by harness.
+  if (
+    process.env.CC_ANDROID_BRIDGE_OVERRIDE === "1" &&
+    typeof _deps.testInvoke === "function"
+  ) {
+    return await _deps.testInvoke(method, params);
+  }
+
+  if (!_deps.detectAndroid()) {
+    throw new AndroidBridgeUnavailableError(
+      `not running on Android (platform=${process.platform})`,
+    );
+  }
+
+  const native = _deps.loadNativeBinding();
+  if (!native) {
+    throw new AndroidBridgeUnavailableError(
+      "native binding cc-android-bridge.node missing — A6 JNI module not yet bundled",
+    );
+  }
+  if (typeof native.invoke !== "function") {
+    throw new AndroidBridgeUnavailableError(
+      "native binding loaded but does not export invoke()",
+    );
+  }
+  return await native.invoke(method, params);
+}
+
+/**
+ * Check whether the bridge is usable right now without throwing.
+ * Returns `{ available: boolean, reason?: string }`.
+ */
+export function caps() {
+  if (process.env.CC_ANDROID_BRIDGE_OVERRIDE === "1") {
+    return { available: true, reason: "test-override" };
+  }
+  if (!_deps.detectAndroid()) {
+    return {
+      available: false,
+      reason: `not-on-android (platform=${process.platform})`,
+    };
+  }
+  const native = _deps.loadNativeBinding();
+  if (!native) {
+    return {
+      available: false,
+      reason: "native-binding-missing (A6 pending)",
+    };
+  }
+  return { available: true };
+}
+
+// _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.
+export const _deps = {
+  detectAndroid,
+  loadNativeBinding,
+  testInvoke: null,
+};
+
+export default {
+  invoke,
+  caps,
+  AndroidBridgeUnavailableError,
+  _deps,
+};

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

@@ -44,6 +44,7 @@ const {
   generateKeyHex,
   EmailAdapter,
   AlipayBillAdapter,
+  SystemDataAndroidAdapter,
   EntityResolver,
   EntityResolverEmbeddingStage,
   EntityResolverLLMStage,
@@ -95,6 +96,28 @@ let _hub = null;
 let _initPromise = null;
 let _bm25 = null;
 
+// LLM override — see file header. Default cli-side hub uses a direct
+// OllamaClient; when the desktop main process embeds this wiring via
+// ws-cli-loader it can inject a CcLLMAdapter (wrapping LLMManager) so the
+// SAME wiring honors the user's active provider (volcengine / anthropic /
+// etc.) instead of hard-binding Ollama. Must be set BEFORE the first
+// getHub() call — initHub() reads it synchronously at the LLM-wiring step.
+let _llmOverride = null;
+
+/**
+ * Override the default cli-side OllamaClient with a caller-supplied LLM
+ * client conforming to the hub's LLMClient contract ({ chat, name, isLocal }).
+ *
+ * Used by desktop-app-vue web-shell's ws-cli-loader bootstrap: see
+ * desktop-app-vue/src/main/web-shell/ws-cli-loader.js. Calling this on
+ * an already-initialized hub does NOT swap the live LLM — the override only
+ * applies on the next fresh initHub(). Restart the process if you need to
+ * change provider mid-session.
+ */
+export function setHubLLMOverride(llm) {
+  _llmOverride = llm || null;
+}
+
 export function resolveHubDir() {
   return join(getElectronUserDataDir(), ".chainlesschain", "hub");
 }
@@ -115,12 +138,16 @@ async function initHub() {
   const vault = new LocalVault({ path: join(hubDir, "vault.db"), key });
   vault.open();
 
-  // LLM: standalone OllamaClient — connects to localhost:11434.
-  // Override via env CC_HUB_OLLAMA_URL / CC_HUB_OLLAMA_MODEL.
-  const llm = new OllamaClient({
-    baseUrl: process.env.CC_HUB_OLLAMA_URL || "http://localhost:11434",
-    model: process.env.CC_HUB_OLLAMA_MODEL || "qwen2.5:7b-instruct",
-  });
+  // LLM: prefer caller-injected override (desktop web-shell wires CcLLMAdapter
+  // wrapping LLMManager so PDH honors the user's saved active provider).
+  // Fallback to standalone OllamaClient — connects to localhost:11434.
+  // Override the fallback via env CC_HUB_OLLAMA_URL / CC_HUB_OLLAMA_MODEL.
+  const llm =
+    _llmOverride ||
+    new OllamaClient({
+      baseUrl: process.env.CC_HUB_OLLAMA_URL || "http://localhost:11434",
+      model: process.env.CC_HUB_OLLAMA_MODEL || "qwen2.5:7b-instruct",
+    });
 
   // KG sink — direct ESM import works here.
   let kgSink = null;
@@ -147,20 +174,33 @@ async function initHub() {
 
   // Phase 8 — EntityResolver pipeline
   const entityResolver = new EntityResolver({ vault });
+  // Plan A v0.1 — in-APK Android cc has no Ollama on localhost:11434.
+  // Every embedding call would TCP-timeout (measured: ~60s extra per sync
+  // on Xiaomi 24115RA8EC 2026-05-21). Detect Termux $PREFIX for our APK
+  // 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).
+  const isInAppAndroidCc =
+    typeof process.env.PREFIX === "string" &&
+    process.env.PREFIX.startsWith("/data/data/com.chainlesschain.android");
+  const skipEmbeddings =
+    isInAppAndroidCc || process.env.CC_HUB_DISABLE_EMBEDDINGS === "1";
   try {
-    if (llm) {
+    if (llm && !skipEmbeddings) {
       const llmStage = new EntityResolverLLMStage({
         llm,
         acceptNonLocal: false,
       });
       entityResolver._llmStage = llmStage.asStageFn();
     }
-    const embeddingStage = new EntityResolverEmbeddingStage({
-      ollamaUrl: process.env.CC_HUB_OLLAMA_URL || "http://localhost:11434",
-      model: process.env.CC_HUB_OLLAMA_EMBED_MODEL || "nomic-embed-text",
-      vault,
-    });
-    entityResolver._embeddingStage = embeddingStage.asStageFn();
+    if (!skipEmbeddings) {
+      const embeddingStage = new EntityResolverEmbeddingStage({
+        ollamaUrl: process.env.CC_HUB_OLLAMA_URL || "http://localhost:11434",
+        model: process.env.CC_HUB_OLLAMA_EMBED_MODEL || "nomic-embed-text",
+        vault,
+      });
+      entityResolver._embeddingStage = embeddingStage.asStageFn();
+    }
   } catch (_err) {
     // Fall back to rule-only — registry still works
   }
@@ -210,6 +250,19 @@ async function initHub() {
     }
   }
 
+  // Plan A v0.1 — Android on-device system-data adapter. Stateless: the UI
+  // produces a snapshot JSON via ContentResolver/PackageManager and passes
+  // its path through opts.inputPath at sync-time, so registration is a
+  // one-shot wire here. Safe to register on every host (no-op until a sync
+  // call provides inputPath); future hosts may filter by platform if useful.
+  try {
+    const sda = new SystemDataAndroidAdapter();
+    if (!registry.has(sda.name)) registry.register(sda);
+  } catch (_err) {
+    // Boot must continue even if the adapter fails to register; cc hub will
+    // surface the absence via list-adapters.
+  }
+
   // Phase 6: auto-register persisted Alipay accounts.
   const alipayAccountsPath = join(hubDir, "alipay-accounts.json");
   const alipayAccounts = loadAlipayAccounts(alipayAccountsPath);
@@ -442,7 +495,11 @@ async function initHub() {
 
     async registerWechatAdapter(opts = {}) {
       if (!opts || !opts.account || !opts.account.uin) {
-        return { ok: false, reason: "UIN_REQUIRED", message: "opts.account.uin required" };
+        return {
+          ok: false,
+          reason: "UIN_REQUIRED",
+          message: "opts.account.uin required",
+        };
       }
       let r;
       try {
@@ -476,7 +533,8 @@ async function initHub() {
         account: { uin: opts.account.uin },
         dbPath: opts.dbPath || null,
         wechatDataPath: opts.wechatDataPath || null,
-        chosenKeyProvider: r.keyProvider && r.keyProvider.name ? r.keyProvider.name : null,
+        chosenKeyProvider:
+          r.keyProvider && r.keyProvider.name ? r.keyProvider.name : null,
         registeredAt: Date.now(),
         lastSyncAt: null,
       });
@@ -500,9 +558,7 @@ async function initHub() {
       }
       const wechatAccountsPath = join(hubDir, "wechat-accounts.json");
       const accounts = loadWechatAccounts(wechatAccountsPath);
-      const target = accounts.find(
-        (c) => c.account && c.account.uin === uin,
-      );
+      const target = accounts.find((c) => c.account && c.account.uin === uin);
       const next = accounts.filter(
         (c) => !(c.account && c.account.uin === uin),
       );

package/src/lib/web-ui-server.js

@@ -1211,7 +1211,8 @@ function findWebPanelDist(staticDir) {
     return fs.existsSync(path.join(staticDir, "index.html")) ? staticDir : null;
   }
   // 1. Source tree: packages/web-panel/dist/
-  const sourceDist = path.resolve(__dirname, "../../web-panel/dist");
+  // __dirname = packages/cli/src/lib/ so we need three "../" to reach packages/.
+  const sourceDist = path.resolve(__dirname, "../../../web-panel/dist");
   if (fs.existsSync(path.join(sourceDist, "index.html"))) {
     return sourceDist;
   }

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

@@ -1 +0,0 @@
-import{A as o}from"./Row-oGWRbk6g.js";import{S as t}from"./index-BDSZDDb2.js";import"./responsiveObserve-DLLx5VvS.js";import"./vendor-DhFY8mDK.js";import"./useFlexGapSupport-B8gAhiRC.js";import"./styleChecker-CbrNybTt.js";import"./index-BZluCuTH.js";import"./icons-BOPtEWK4.js";const l=t(o);export{l as default};

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

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