chainlesschain 0.162.13 → 0.162.15

package/src/commands/__tests__/android.test.js

@@ -0,0 +1,260 @@
+/**
+ * `cc android` command + cc-android-bridge unit tests (Plan A A7 scaffold).
+ *
+ * These exercise the command routing without a real Android device. The
+ * `_deps` injection seam swaps the bridge module with a mock so we hit both
+ * the success path (bridge resolves) and error path (bridge throws
+ * AndroidBridgeUnavailableError, which on a real non-Android host is what
+ * actually happens).
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+
+import * as androidCmd from "../android.js";
+import * as bridge from "../../lib/cc-android-bridge.js";
+
+let logSpy, errSpy, exitSpy, jsonSpy;
+
+function withMockBridge(invokeResult) {
+  const mock = {
+    invoke: vi.fn(async (method, params) => {
+      if (invokeResult instanceof Error) throw invokeResult;
+      if (typeof invokeResult === "function")
+        return await invokeResult(method, params);
+      return invokeResult;
+    }),
+    caps: vi.fn(() => ({ available: true, reason: "mock" })),
+    AndroidBridgeUnavailableError: bridge.AndroidBridgeUnavailableError,
+  };
+  androidCmd._deps.bridge = mock;
+  return mock;
+}
+
+beforeEach(() => {
+  logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+  errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+  exitSpy = vi.spyOn(process, "exit").mockImplementation((code) => {
+    throw new Error(`__exit:${code}`);
+  });
+});
+
+afterEach(() => {
+  androidCmd._deps.bridge = bridge;
+  vi.restoreAllMocks();
+});
+
+// ─── cc-android-bridge ────────────────────────────────────────────────
+
+describe("cc-android-bridge", () => {
+  it("detectAndroid returns false on a vanilla non-Android host", () => {
+    // Test runs on win32 / linux / darwin — not android.
+    expect(bridge.detectAndroid()).toBe(false);
+  });
+
+  it("detectAndroid returns true under CC_ANDROID_BRIDGE_OVERRIDE=1", () => {
+    process.env.CC_ANDROID_BRIDGE_OVERRIDE = "1";
+    try {
+      expect(bridge.detectAndroid()).toBe(true);
+    } finally {
+      delete process.env.CC_ANDROID_BRIDGE_OVERRIDE;
+    }
+  });
+
+  it("invoke rejects with ANDROID_BRIDGE_NOT_AVAILABLE on non-Android host", async () => {
+    await expect(bridge.invoke("contacts.query", {})).rejects.toMatchObject({
+      code: "ANDROID_BRIDGE_NOT_AVAILABLE",
+    });
+  });
+
+  it("invoke routes through testInvoke when override is set", async () => {
+    process.env.CC_ANDROID_BRIDGE_OVERRIDE = "1";
+    const original = bridge._deps.testInvoke;
+    bridge._deps.testInvoke = vi.fn(async (m, p) => ({ echo: m, params: p }));
+    try {
+      const r = await bridge.invoke("foo.bar", { x: 1 });
+      expect(r).toEqual({ echo: "foo.bar", params: { x: 1 } });
+      expect(bridge._deps.testInvoke).toHaveBeenCalledWith("foo.bar", { x: 1 });
+    } finally {
+      bridge._deps.testInvoke = original;
+      delete process.env.CC_ANDROID_BRIDGE_OVERRIDE;
+    }
+  });
+
+  it("invoke rejects empty method", async () => {
+    await expect(bridge.invoke("")).rejects.toThrow(/non-empty string/);
+  });
+
+  it("caps reports unavailable on non-Android host", () => {
+    const c = bridge.caps();
+    expect(c.available).toBe(false);
+    expect(c.reason).toMatch(/not-on-android/);
+  });
+});
+
+// ─── cmd routing — bridge success path ─────────────────────────────────
+
+describe("cc android commands — success path (mocked bridge)", () => {
+  it("cmdCaps prints available when bridge.caps returns available", async () => {
+    withMockBridge({});
+    await androidCmd._cmds.cmdCaps({ json: true });
+    expect(logSpy).toHaveBeenCalled();
+    const out = logSpy.mock.calls[0][0];
+    expect(JSON.parse(out).available).toBe(true);
+  });
+
+  it("cmdContactsPull invokes contacts.query with --since", async () => {
+    const mock = withMockBridge({ ingested: 42, events: [] });
+    await androidCmd._cmds.cmdContactsPull({
+      json: true,
+      since: "1700000000000",
+    });
+    expect(mock.invoke).toHaveBeenCalledWith("contacts.query", {
+      since: 1700000000000,
+    });
+    const out = JSON.parse(logSpy.mock.calls[0][0]);
+    expect(out.ingested).toBe(42);
+  });
+
+  it("cmdSmsPull invokes sms.query", async () => {
+    const mock = withMockBridge({ ok: true });
+    await androidCmd._cmds.cmdSmsPull({ json: true });
+    expect(mock.invoke).toHaveBeenCalledWith("sms.query", { since: undefined });
+  });
+
+  it("cmdCallsPull invokes calls.query", async () => {
+    const mock = withMockBridge({ ok: true });
+    await androidCmd._cmds.cmdCallsPull({ json: true });
+    expect(mock.invoke).toHaveBeenCalledWith("calls.query", {
+      since: undefined,
+    });
+  });
+
+  it("cmdAppList passes includeSystem flag", async () => {
+    const mock = withMockBridge([{ pkg: "com.foo" }]);
+    await androidCmd._cmds.cmdAppList({ json: true, system: true });
+    expect(mock.invoke).toHaveBeenCalledWith("app.list", {
+      includeSystem: true,
+    });
+  });
+
+  it("cmdAppLaunch forwards pkg", async () => {
+    const mock = withMockBridge({ ok: true });
+    await androidCmd._cmds.cmdAppLaunch("com.tencent.mm", { json: true });
+    expect(mock.invoke).toHaveBeenCalledWith("app.launch", {
+      pkg: "com.tencent.mm",
+    });
+  });
+
+  it("cmdAppIntent parses --extra K=V repeatable", async () => {
+    const mock = withMockBridge({ ok: true });
+    await androidCmd._cmds.cmdAppIntent("com.foo", "VIEW", {
+      json: true,
+      extra: ["url=https://x", "id=42"],
+    });
+    expect(mock.invoke).toHaveBeenCalledWith("app.intent", {
+      pkg: "com.foo",
+      action: "VIEW",
+      extras: { url: "https://x", id: "42" },
+    });
+  });
+
+  it("cmdFsRead forwards SAF tree URI", async () => {
+    const mock = withMockBridge({ bytes: 100 });
+    await androidCmd._cmds.cmdFsRead(
+      "content://com.android.externalstorage.documents/tree/abc",
+      {
+        json: true,
+      },
+    );
+    expect(mock.invoke).toHaveBeenCalledWith("fs.read", {
+      target: "content://com.android.externalstorage.documents/tree/abc",
+    });
+  });
+
+  it("cmdFsList invokes fs.list", async () => {
+    const mock = withMockBridge([]);
+    await androidCmd._cmds.cmdFsList("/sdcard/Download/", { json: true });
+    expect(mock.invoke).toHaveBeenCalledWith("fs.list", {
+      target: "/sdcard/Download/",
+    });
+  });
+
+  it("cmdA11yQuery forwards --filter", async () => {
+    const mock = withMockBridge({ nodes: [] });
+    await androidCmd._cmds.cmdA11yQuery({ json: true, filter: "button" });
+    expect(mock.invoke).toHaveBeenCalledWith("a11y.query", {
+      filter: "button",
+    });
+  });
+
+  it("cmdA11yClick forwards nodeId", async () => {
+    const mock = withMockBridge({ ok: true });
+    await androidCmd._cmds.cmdA11yClick("node-7", { json: true });
+    expect(mock.invoke).toHaveBeenCalledWith("a11y.click", {
+      nodeId: "node-7",
+    });
+  });
+
+  it("cmdA11yType forwards text", async () => {
+    const mock = withMockBridge({ ok: true });
+    await androidCmd._cmds.cmdA11yType("hello", { json: true });
+    expect(mock.invoke).toHaveBeenCalledWith("a11y.type", { text: "hello" });
+  });
+
+  it("cmdShizukuExec forwards cmd", async () => {
+    const mock = withMockBridge({ stdout: "ok" });
+    await androidCmd._cmds.cmdShizukuExec("pm list packages", { json: true });
+    expect(mock.invoke).toHaveBeenCalledWith("shizuku.exec", {
+      cmd: "pm list packages",
+    });
+  });
+
+  it("cmdRootExec forwards cmd", async () => {
+    const mock = withMockBridge({ stdout: "" });
+    await androidCmd._cmds.cmdRootExec("ls /data/data", { json: true });
+    expect(mock.invoke).toHaveBeenCalledWith("root.exec", {
+      cmd: "ls /data/data",
+    });
+  });
+
+  it("cmdPerms forwards permission name", async () => {
+    const mock = withMockBridge({ granted: false });
+    await androidCmd._cmds.cmdPerms("READ_CONTACTS", { json: true });
+    expect(mock.invoke).toHaveBeenCalledWith("perms.check", {
+      name: "READ_CONTACTS",
+    });
+  });
+});
+
+// ─── cmd routing — bridge error path ──────────────────────────────────
+
+describe("cc android commands — error path", () => {
+  it("propagates ANDROID_BRIDGE_NOT_AVAILABLE as JSON when --json", async () => {
+    withMockBridge(
+      new bridge.AndroidBridgeUnavailableError("test-not-on-android"),
+    );
+    await expect(
+      androidCmd._cmds.cmdContactsPull({ json: true }),
+    ).rejects.toThrow(/__exit:1/);
+    const out = JSON.parse(logSpy.mock.calls[0][0]);
+    expect(out.code).toBe("ANDROID_BRIDGE_NOT_AVAILABLE");
+    expect(out.error).toMatch(/test-not-on-android/);
+  });
+
+  it("propagates error human-readable on non-JSON", async () => {
+    withMockBridge(new bridge.AndroidBridgeUnavailableError("nope"));
+    await expect(androidCmd._cmds.cmdSmsPull({ json: false })).rejects.toThrow(
+      /__exit:1/,
+    );
+    expect(errSpy).toHaveBeenCalled();
+  });
+
+  it("non-bridge errors still surface", async () => {
+    withMockBridge(new Error("network timeout"));
+    await expect(androidCmd._cmds.cmdAppList({ json: true })).rejects.toThrow(
+      /__exit:1/,
+    );
+    const out = JSON.parse(logSpy.mock.calls[0][0]);
+    expect(out.error).toMatch(/network timeout/);
+  });
+});

package/src/commands/__tests__/hub-wechat.test.js

@@ -41,19 +41,27 @@ function fakeHub(overrides = {}) {
         ...overrides.register,
       };
     }),
-    listWechatAccounts: vi.fn(() => overrides.list || [
-      {
-        uin: "1234567890",
-        dbPath: "/tmp/EnMicroMsg.db",
-        hasWechatDataPath: true,
-        chosenKeyProvider: "md5",
-        registeredAt: 1716280000000,
-        lastSyncAt: null,
-      },
-    ]),
+    listWechatAccounts: vi.fn(
+      () =>
+        overrides.list || [
+          {
+            uin: "1234567890",
+            dbPath: "/tmp/EnMicroMsg.db",
+            hasWechatDataPath: true,
+            chosenKeyProvider: "md5",
+            registeredAt: 1716280000000,
+            lastSyncAt: null,
+          },
+        ],
+    ),
     unregisterWechatAdapter: vi.fn(async (uin) => {
       if (!uin) return { ok: false, reason: "UIN_REQUIRED" };
-      return { ok: true, removed: uin === "1234567890", uin, ...overrides.unregister };
+      return {
+        ok: true,
+        removed: uin === "1234567890",
+        uin,
+        ...overrides.unregister,
+      };
     }),
   };
 }
@@ -106,9 +114,21 @@ describe("cc hub wechat register", () => {
       _internal.cmdWechatRegister({ _getHub: async () => hub, json: true }),
     ).rejects.toThrow(/process\.exit/);
     const allOut =
-      logSpy.mock.calls.map((c) => c.map((p) => (typeof p === "string" ? p : JSON.stringify(p))).join(" ")).join("\n") +
+      logSpy.mock.calls
+        .map((c) =>
+          c
+            .map((p) => (typeof p === "string" ? p : JSON.stringify(p)))
+            .join(" "),
+        )
+        .join("\n") +
       "\n" +
-      errSpy.mock.calls.map((c) => c.map((p) => (typeof p === "string" ? p : JSON.stringify(p))).join(" ")).join("\n");
+      errSpy.mock.calls
+        .map((c) =>
+          c
+            .map((p) => (typeof p === "string" ? p : JSON.stringify(p)))
+            .join(" "),
+        )
+        .join("\n");
     expect(allOut).toMatch(/--uin|uin/i);
   });
 
@@ -217,7 +237,9 @@ describe("cc hub wechat list", () => {
 describe("cc hub wechat unregister", () => {
   it("calls hub with uin + reports removed", async () => {
     const hub = fakeHub();
-    await _internal.cmdWechatUnregister("1234567890", { _getHub: async () => hub });
+    await _internal.cmdWechatUnregister("1234567890", {
+      _getHub: async () => hub,
+    });
     expect(hub.unregisterWechatAdapter).toHaveBeenCalledWith("1234567890");
     const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
     expect(out).toMatch(/removed wechat account.*1234567890/);
@@ -238,6 +260,155 @@ describe("cc hub wechat unregister", () => {
     });
     const out = logSpy.mock.calls.map((c) => c[0]).join("\n");
     const parsed = JSON.parse(out);
-    expect(parsed).toEqual(expect.objectContaining({ ok: true, removed: true, uin: "1234567890" }));
+    expect(parsed).toEqual(
+      expect.objectContaining({ ok: true, removed: true, uin: "1234567890" }),
+    );
+  });
+});
+
+// ─── Phase 12.9 — `cc hub wechat doctor` ──────────────────────────────
+
+describe("interpretWechatProbe (pure)", () => {
+  const { interpretWechatProbe } = _internal;
+
+  it("device unreachable → blocked + adb hint", () => {
+    const r = interpretWechatProbe({
+      device: { reachable: false },
+      wechat: {},
+      root: {},
+      frida: {},
+    });
+    expect(r.readiness).toBe("blocked");
+    expect(r.blockers.join(" ")).toMatch(/adb/);
+    expect(r.nextSteps.join(" ")).toMatch(/adb devices/);
+  });
+
+  it("WeChat not installed → blocked + install hint", () => {
+    const r = interpretWechatProbe({
+      device: { reachable: true },
+      wechat: { installed: false },
+      root: {},
+      frida: {},
+    });
+    expect(r.readiness).toBe("blocked");
+    expect(r.blockers.join(" ")).toMatch(/com\.tencent\.mm/);
+  });
+
+  it("WeChat < 8 + md5 path → ready with adb pull instructions", () => {
+    const r = interpretWechatProbe({
+      device: { reachable: true },
+      wechat: { installed: true, majorVersion: 7, versionName: "7.0.22" },
+      root: { detected: false },
+      frida: {},
+      suggestedKeyProvider: "md5",
+    });
+    expect(r.readiness).toBe("ready");
+    expect(r.nextSteps.some((s) => /adb pull/.test(s))).toBe(true);
+    expect(r.nextSteps.some((s) => /cc hub wechat register/.test(s))).toBe(
+      true,
+    );
+    // non-root warning when MD5 path lacks root (backup subset only)
+    expect(r.warnings.some((w) => /非 root|backup 子集/.test(w))).toBe(true);
+  });
+
+  it("WeChat ≥ 8 + no root → blocked with root requirement", () => {
+    const r = interpretWechatProbe({
+      device: { reachable: true },
+      wechat: { installed: true, majorVersion: 8, versionName: "8.0.45" },
+      root: { detected: false },
+      frida: { serverRunning: false },
+      suggestedKeyProvider: "frida",
+    });
+    expect(r.readiness).toBe("blocked");
+    expect(r.blockers.join(" ")).toMatch(/root/);
+    expect(r.nextSteps.join(" ")).toMatch(/Magisk/);
+  });
+
+  it("WeChat ≥ 8 + root + no frida → partial with setup pointer", () => {
+    const r = interpretWechatProbe({
+      device: { reachable: true },
+      wechat: { installed: true, majorVersion: 8, versionName: "8.0.45" },
+      root: { detected: true },
+      frida: { serverRunning: false },
+      suggestedKeyProvider: "frida",
+    });
+    expect(r.readiness).toBe("partial");
+    expect(r.blockers.join(" ")).toMatch(/Frida server/i);
+    expect(r.nextSteps.join(" ")).toMatch(/Frida_Setup/);
+  });
+
+  it("WeChat ≥ 8 + root + frida running → ready", () => {
+    const r = interpretWechatProbe({
+      device: { reachable: true },
+      wechat: { installed: true, majorVersion: 8, versionName: "8.0.45" },
+      root: { detected: true },
+      frida: { serverRunning: true, port: 27042 },
+      suggestedKeyProvider: "frida",
+    });
+    expect(r.readiness).toBe("ready");
+    expect(r.nextSteps.some((s) => /register/.test(s))).toBe(true);
+    expect(r.nextSteps.some((s) => /前台运行/.test(s))).toBe(true);
+  });
+
+  it("env-probe judges unsupported → blocked with reasons", () => {
+    const r = interpretWechatProbe({
+      device: { reachable: true },
+      wechat: { installed: true, majorVersion: 8, versionName: "8.0.50" },
+      root: { detected: true },
+      frida: { serverRunning: true },
+      suggestedKeyProvider: "unsupported",
+      reasons: [
+        "MMKV-only storage on this build — neither MD5 nor Frida path works",
+      ],
+    });
+    expect(r.readiness).toBe("blocked");
+    expect(r.blockers.join(" ")).toMatch(/MMKV-only/);
+  });
+});
+
+describe("cc hub wechat doctor", () => {
+  it("--json includes probe + doctor.readiness/blockers/nextSteps", async () => {
+    const hub = fakeHub();
+    await _internal.cmdWechatDoctor({ _getHub: async () => hub, json: true });
+    const out = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    const parsed = JSON.parse(out);
+    expect(parsed.probe).toEqual(
+      expect.objectContaining({ suggestedKeyProvider: "md5" }),
+    );
+    expect(parsed.doctor).toEqual(
+      expect.objectContaining({
+        readiness: "ready",
+        nextSteps: expect.any(Array),
+      }),
+    );
+  });
+
+  it("human-readable surfaces trap table reference + telemetry capture cmd", async () => {
+    const hub = fakeHub();
+    await _internal.cmdWechatDoctor({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/Doctor:/);
+    expect(out).toMatch(/READY|PARTIAL|BLOCKED/);
+    expect(out).toMatch(/fridaTelemetry/);
+    expect(out).toMatch(/trap table|§5\.1|Runbook/i);
+  });
+
+  it("device unreachable: omits telemetry capture section (no point if blocked)", async () => {
+    const hub = fakeHub({
+      probe: {
+        ok: false,
+        suggestedKeyProvider: "unsupported",
+        device: { reachable: false },
+        wechat: {},
+        root: {},
+        frida: {},
+        reasons: [],
+        warnings: [],
+      },
+    });
+    await _internal.cmdWechatDoctor({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/BLOCKED/);
+    expect(out).not.toMatch(/fridaTelemetry/);
   });
 });