chainlesschain 0.162.13 → 0.162.15

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/__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

@@ -0,0 +1,206 @@
+/**
+ * cc-android-bridge — Node-side facade for the Android JNI bridge.
+ *
+ * Plan A Sub-Phase A6 (see `docs/design/Personal_Data_Hub_Android_Standalone_Cc.md`).
+ *
+ * **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
+ *   2. process.platform === "android"
+ *   3. process.env.PREFIX startsWith "/data/data/com.chainlesschain.android/"
+ *      (Termux $PREFIX pattern in the bundled cc).
+ *
+ * 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 { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+
+const ANDROID_PREFIX = "/data/data/com.chainlesschain.android/";
+
+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;
+}
+
+/**
+ * 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 loadBridgeConfig() {
+  const dir = resolveBridgeConfigDir();
+  if (!dir) return null;
+  try {
+    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;
+  }
+}
+
+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 via the HTTP transport.
+ *
+ * @param {string} method — kebab-case method name (e.g. "contacts.query")
+ * @param {object} [params]
+ * @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 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) {
+    throw new TypeError(
+      "cc-android-bridge.invoke: method must be non-empty string",
+    );
+  }
+
+  // Test path — harness replaces _deps.testInvoke.
+  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 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(
+      `HTTP transport error: ${e && e.message ? e.message : String(e)}`,
+    );
+  }
+  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(
+      `bridge returned non-JSON: ${text.slice(0, 200)}`,
+    );
+  }
+}
+
+/**
+ * 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") {
+    return { available: true, reason: "test-override" };
+  }
+  if (!_deps.detectAndroid()) {
+    return {
+      available: false,
+      reason: `not-on-android (platform=${process.platform})`,
+    };
+  }
+  const config = _deps.loadBridgeConfig();
+  if (!config) {
+    return {
+      available: false,
+      reason: "bridge-server-not-started (port/token files missing)",
+    };
+  }
+  return { available: true, port: config.port };
+}
+
+// _deps injection seam (per [[feedback-vi-mock-cjs-interop]]). Tests reach in
+// and replace these to exercise success / error paths without a real device.
+export const _deps = {
+  detectAndroid,
+  loadBridgeConfig,
+  fetch: globalThis.fetch.bind(globalThis),
+  testInvoke: null,
+};
+
+export default {
+  invoke,
+  caps,
+  AndroidBridgeUnavailableError,
+  _deps,
+};