chainlesschain 0.162.20 → 0.162.26

package/src/commands/__tests__/hub-bilibili-adb-sync.test.js

@@ -0,0 +1,350 @@
+/**
+ * Phase 1c — cc hub bilibili-adb-sync CLI command unit tests.
+ *
+ * Same _getHub test-seam pattern as hub-wechat.test.js: we synthesize a
+ * tiny fake hub whose `bilibiliAdbSync` method returns canned `{ok, ...}`
+ * shapes matching the real wiring contract.
+ *
+ * What we cover:
+ *  - Happy path (status=ok, all 4 counts) — human + JSON output
+ *  - Each typed failure reason emits the right inline tip + exit code 1
+ *  - Limits options are parsed + forwarded
+ *  - stagingDir / displayName forward
+ *  - Partial-result diagnostic (lastErrorCode) renders the warning line
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+
+import { _internal } from "../hub.js";
+
+let logSpy, errSpy;
+let prevExitCode;
+
+function fakeHub(syncResult) {
+  return {
+    bilibiliAdbSync: vi.fn(async (_opts) => syncResult),
+  };
+}
+
+const HAPPY_RESULT = {
+  ok: true,
+  report: {
+    adapter: "social-bilibili",
+    status: "ok",
+    rawCount: 42,
+    entityCounts: { events: 42, persons: 0, places: 0, items: 0, topics: 0 },
+    bilibili: {
+      uid: 1234567890,
+      eventCounts: {
+        history: 30,
+        favourite: 5,
+        dynamic: 2,
+        follow: 5,
+        total: 42,
+      },
+      lastErrorCode: 0,
+      lastErrorMessage: null,
+      cookieDiagnostic: { cookieCount: 5, hadEncrypted: false },
+      cleanupFailed: false,
+    },
+  },
+};
+
+beforeEach(() => {
+  logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+  errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+  prevExitCode = process.exitCode;
+  process.exitCode = 0;
+});
+
+afterEach(() => {
+  logSpy.mockRestore();
+  errSpy.mockRestore();
+  process.exitCode = prevExitCode;
+});
+
+describe("cc hub bilibili-adb-sync — happy path", () => {
+  it("prints human-readable summary by default", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdBilibiliAdbSync({ _getHub: async () => hub });
+    expect(hub.bilibiliAdbSync).toHaveBeenCalledOnce();
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/bilibili-adb-sync succeeded/);
+    expect(out).toMatch(/uid:.*1234567890/);
+    expect(out).toMatch(/history:\s+30/);
+    expect(out).toMatch(/favourite:\s+5/);
+    expect(out).toMatch(/dynamic:\s+2/);
+    expect(out).toMatch(/follow:\s+5/);
+    expect(out).toMatch(/total:\s+42/);
+    expect(out).toMatch(/status:\s+ok/);
+  });
+
+  it("prints JSON when --json", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdBilibiliAdbSync({
+      _getHub: async () => hub,
+      json: true,
+    });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    const parsed = JSON.parse(out);
+    expect(parsed.ok).toBe(true);
+    expect(parsed.report.bilibili.uid).toBe(1234567890);
+  });
+
+  it("renders partial-result warning when lastErrorCode != 0", async () => {
+    const result = JSON.parse(JSON.stringify(HAPPY_RESULT));
+    result.report.bilibili.lastErrorCode = -412;
+    result.report.bilibili.lastErrorMessage = "anti-spider";
+    const hub = fakeHub(result);
+    await _internal.cmdBilibiliAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/partial.*lastErrorCode=-412.*anti-spider/);
+  });
+
+  it("renders cleanup-failed note when reported", async () => {
+    const result = JSON.parse(JSON.stringify(HAPPY_RESULT));
+    result.report.bilibili.cleanupFailed = true;
+    const hub = fakeHub(result);
+    await _internal.cmdBilibiliAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/staging file cleanup failed/);
+  });
+});
+
+describe("cc hub bilibili-adb-sync — failure reasons", () => {
+  it("BRIDGE_UNAVAILABLE → exit 1 + install-platform-tools tip", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "BRIDGE_UNAVAILABLE",
+      message: "adb not found",
+    });
+    await _internal.cmdBilibiliAdbSync({ _getHub: async () => hub });
+    expect(process.exitCode).toBe(1);
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/bilibili-adb-sync failed.*BRIDGE_UNAVAILABLE/);
+    expect(out).toMatch(/Install Android Platform Tools/);
+  });
+
+  it("BILIBILI_NO_ROOT → exit 1 + root-required tip", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "BILIBILI_NO_ROOT",
+      message: "su returned uid=2000",
+    });
+    await _internal.cmdBilibiliAdbSync({ _getHub: async () => hub });
+    expect(process.exitCode).toBe(1);
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/BILIBILI_NO_ROOT/);
+    expect(out).toMatch(/root \+ Magisk required/);
+  });
+
+  it("BILIBILI_NOT_INSTALLED_OR_NEVER_LOGGED_IN → install-and-relog tip", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "BILIBILI_NOT_INSTALLED_OR_NEVER_LOGGED_IN",
+      message: "Cookies path not found",
+    });
+    await _internal.cmdBilibiliAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/Install Bilibili App on the phone/);
+  });
+
+  it("BILIBILI_COOKIES_INCOMPLETE → relog tip", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "BILIBILI_COOKIES_INCOMPLETE",
+      message: "missing buvid3",
+    });
+    await _internal.cmdBilibiliAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/Cookie file is missing required fields/);
+  });
+
+  it("unknown reason → generic failure message + exit 1", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "SYNC_FAILED",
+      message: "vault write failed",
+    });
+    await _internal.cmdBilibiliAdbSync({ _getHub: async () => hub });
+    expect(process.exitCode).toBe(1);
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/SYNC_FAILED/);
+    expect(out).toMatch(/vault write failed/);
+  });
+
+  it("--json on failure outputs full result", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "BILIBILI_NO_ROOT",
+      message: "su returned 2000",
+    });
+    await _internal.cmdBilibiliAdbSync({
+      _getHub: async () => hub,
+      json: true,
+    });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    const parsed = JSON.parse(out);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.reason).toBe("BILIBILI_NO_ROOT");
+  });
+});
+
+describe("cc hub bilibili-adb-sync — options forwarding", () => {
+  it("limit-* options become hub.limits object", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdBilibiliAdbSync({
+      _getHub: async () => hub,
+      limitHistory: "50",
+      limitFavourite: "10",
+      limitDynamic: "20",
+      limitFollow: "30",
+    });
+    const callArg = hub.bilibiliAdbSync.mock.calls[0][0];
+    expect(callArg.limits).toEqual({
+      history: 50,
+      favourite: 10,
+      dynamic: 20,
+      follow: 30,
+    });
+  });
+
+  it("no limit options → limits is undefined", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdBilibiliAdbSync({ _getHub: async () => hub });
+    const callArg = hub.bilibiliAdbSync.mock.calls[0][0];
+    expect(callArg.limits).toBeUndefined();
+  });
+
+  it("displayName + stagingDir are forwarded", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdBilibiliAdbSync({
+      _getHub: async () => hub,
+      displayName: "alice",
+      stagingDir: "/tmp/custom-staging",
+    });
+    const callArg = hub.bilibiliAdbSync.mock.calls[0][0];
+    expect(callArg.displayName).toBe("alice");
+    expect(callArg.stagingDir).toBe("/tmp/custom-staging");
+  });
+});
+
+describe("cc hub bilibili-adb-sync — _internal export", () => {
+  it("cmdBilibiliAdbSync is exported", () => {
+    expect(typeof _internal.cmdBilibiliAdbSync).toBe("function");
+  });
+});
+
+// ─── Phase 1e — cc hub bilibili-adb-doctor ──────────────────────────────
+
+const DOCTOR_HAPPY = {
+  ok: true,
+  uid: 1234567890,
+  extractedAt: 1716383021000,
+  cookieDiagnostic: { cookieCount: 5, hadEncrypted: false },
+};
+
+function fakeDoctorHub(result) {
+  return { bilibiliAdbDoctor: vi.fn(async () => result) };
+}
+
+describe("cc hub bilibili-adb-doctor — happy path", () => {
+  it("prints ready summary on success", async () => {
+    const hub = fakeDoctorHub(DOCTOR_HAPPY);
+    await _internal.cmdBilibiliAdbDoctor({ _getHub: async () => hub });
+    expect(hub.bilibiliAdbDoctor).toHaveBeenCalledOnce();
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/env ready to sync/);
+    expect(out).toMatch(/uid:.*1234567890/);
+    expect(out).toMatch(/cookies found:.*5/);
+    expect(out).toMatch(/Next: run.*bilibili-adb-sync/);
+  });
+
+  it("renders encrypted-rows warning when present", async () => {
+    const result = JSON.parse(JSON.stringify(DOCTOR_HAPPY));
+    result.cookieDiagnostic.hadEncrypted = true;
+    const hub = fakeDoctorHub(result);
+    await _internal.cmdBilibiliAdbDoctor({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/encrypted rows/);
+    expect(out).toMatch(/Android-Keystore-wrapped/);
+  });
+
+  it("--json outputs raw result", async () => {
+    const hub = fakeDoctorHub(DOCTOR_HAPPY);
+    await _internal.cmdBilibiliAdbDoctor({
+      _getHub: async () => hub,
+      json: true,
+    });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    const parsed = JSON.parse(out);
+    expect(parsed.ok).toBe(true);
+    expect(parsed.uid).toBe(1234567890);
+  });
+});
+
+describe("cc hub bilibili-adb-doctor — failure reasons", () => {
+  it("BRIDGE_UNAVAILABLE → exit 1 + install tip", async () => {
+    const hub = fakeDoctorHub({
+      ok: false,
+      reason: "BRIDGE_UNAVAILABLE",
+      message: "adb not found",
+    });
+    await _internal.cmdBilibiliAdbDoctor({ _getHub: async () => hub });
+    expect(process.exitCode).toBe(1);
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/BRIDGE_UNAVAILABLE/);
+    expect(out).toMatch(/install Android Platform Tools/);
+  });
+
+  it("BILIBILI_NO_ROOT → exit 1 + Magisk tip", async () => {
+    const hub = fakeDoctorHub({
+      ok: false,
+      reason: "BILIBILI_NO_ROOT",
+      message: "uid=2000",
+    });
+    await _internal.cmdBilibiliAdbDoctor({ _getHub: async () => hub });
+    expect(process.exitCode).toBe(1);
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/Magisk root/);
+  });
+
+  it("BILIBILI_NOT_INSTALLED_OR_NEVER_LOGGED_IN → install+login tip", async () => {
+    const hub = fakeDoctorHub({
+      ok: false,
+      reason: "BILIBILI_NOT_INSTALLED_OR_NEVER_LOGGED_IN",
+      message: "Cookies file missing",
+    });
+    await _internal.cmdBilibiliAdbDoctor({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/install Bilibili App.*log in/);
+  });
+
+  it("BILIBILI_COOKIES_INCOMPLETE → relog tip", async () => {
+    const hub = fakeDoctorHub({
+      ok: false,
+      reason: "BILIBILI_COOKIES_INCOMPLETE",
+      message: "missing buvid3",
+    });
+    await _internal.cmdBilibiliAdbDoctor({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/relog on the Bilibili App/);
+  });
+
+  it("BILIBILI_COOKIES_TRUNCATED → USB-replug tip", async () => {
+    const hub = fakeDoctorHub({
+      ok: false,
+      reason: "BILIBILI_COOKIES_TRUNCATED",
+      message: "decoded 50 bytes",
+    });
+    await _internal.cmdBilibiliAdbDoctor({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/unplug \+ replug USB/);
+  });
+});
+
+describe("cc hub bilibili-adb-doctor — _internal export", () => {
+  it("cmdBilibiliAdbDoctor is exported", () => {
+    expect(typeof _internal.cmdBilibiliAdbDoctor).toBe("function");
+  });
+});

package/src/commands/__tests__/hub-douyin-adb-sync.test.js

@@ -0,0 +1,199 @@
+/**
+ * Phase 2a — cc hub douyin-adb-sync CLI command unit tests.
+ *
+ * Mirrors hub-bilibili-adb-sync.test.js. Synthesizes a fake hub whose
+ * `douyinAdbSync` returns canned `{ok, ...}` shapes matching the wiring
+ * contract.
+ *
+ * Covers:
+ *  - Happy path: human + JSON
+ *  - 5 typed failure reasons each emit the right inline tip + exit 1
+ *  - Parser diagnostic warnings (msg / SIMPLE_USER missing)
+ *  - Options forwarding (uid / limit-messages / limit-contacts / staging-dir / display-name)
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+
+import { _internal } from "../hub.js";
+
+let logSpy, errSpy;
+let prevExitCode;
+
+function fakeHub(syncResult) {
+  return {
+    douyinAdbSync: vi.fn(async (_opts) => syncResult),
+  };
+}
+
+const HAPPY_RESULT = {
+  ok: true,
+  report: {
+    adapter: "social-douyin",
+    status: "ok",
+    rawCount: 12,
+    entityCounts: { events: 12, persons: 0, places: 0, items: 0, topics: 0 },
+    douyin: {
+      uid: "1234567890123456789",
+      eventCounts: { message: 10, contact: 2, total: 12 },
+      parserDiagnostic: {
+        hadMsgTable: true,
+        hadSimpleUserTable: true,
+        messageCount: 10,
+        contactCount: 2,
+      },
+      cleanupFailed: false,
+    },
+  },
+};
+
+beforeEach(() => {
+  logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+  errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+  prevExitCode = process.exitCode;
+  process.exitCode = 0;
+});
+
+afterEach(() => {
+  logSpy.mockRestore();
+  errSpy.mockRestore();
+  process.exitCode = prevExitCode;
+});
+
+describe("cc hub douyin-adb-sync — happy path", () => {
+  it("prints human-readable summary by default", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdDouyinAdbSync({ _getHub: async () => hub });
+    expect(hub.douyinAdbSync).toHaveBeenCalledOnce();
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/douyin-adb-sync succeeded/);
+    expect(out).toMatch(/uid:.*1234567890123456789/);
+    expect(out).toMatch(/messages:\s+10/);
+    expect(out).toMatch(/contacts:\s+2/);
+    expect(out).toMatch(/total:\s+12/);
+  });
+
+  it("--json outputs raw result", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdDouyinAdbSync({ _getHub: async () => hub, json: true });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    const parsed = JSON.parse(out);
+    expect(parsed.ok).toBe(true);
+    expect(parsed.report.douyin.uid).toBe("1234567890123456789");
+  });
+
+  it("renders missing-msg-table warning", async () => {
+    const result = JSON.parse(JSON.stringify(HAPPY_RESULT));
+    result.report.douyin.parserDiagnostic.hadMsgTable = false;
+    const hub = fakeHub(result);
+    await _internal.cmdDouyinAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/msg table not found/);
+  });
+
+  it("renders missing-SIMPLE_USER warning", async () => {
+    const result = JSON.parse(JSON.stringify(HAPPY_RESULT));
+    result.report.douyin.parserDiagnostic.hadSimpleUserTable = false;
+    const hub = fakeHub(result);
+    await _internal.cmdDouyinAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/SIMPLE_USER table not found/);
+  });
+});
+
+describe("cc hub douyin-adb-sync — failure reasons", () => {
+  it("BRIDGE_UNAVAILABLE → exit 1 + install tip", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "BRIDGE_UNAVAILABLE",
+      message: "adb not found",
+    });
+    await _internal.cmdDouyinAdbSync({ _getHub: async () => hub });
+    expect(process.exitCode).toBe(1);
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/Install Android Platform Tools/);
+  });
+
+  it("DOUYIN_NO_ROOT → exit 1 + Magisk tip", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "DOUYIN_NO_ROOT",
+      message: "uid=2000",
+    });
+    await _internal.cmdDouyinAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/Magisk root/);
+  });
+
+  it("DOUYIN_NOT_INSTALLED → install tip", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "DOUYIN_NOT_INSTALLED",
+      message: "dir missing",
+    });
+    await _internal.cmdDouyinAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/Install Douyin App on the phone/);
+  });
+
+  it("DOUYIN_NO_IM_DB → login+open-chat tip", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "DOUYIN_NO_IM_DB",
+      message: "no <uid>_im.db",
+    });
+    await _internal.cmdDouyinAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/Log in to Douyin App.*open any chat thread/);
+  });
+
+  it("DOUYIN_MULTIPLE_USERS → --uid tip", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "DOUYIN_MULTIPLE_USERS",
+      message: "multiple",
+    });
+    await _internal.cmdDouyinAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/--uid <19-digit>/);
+  });
+});
+
+describe("cc hub douyin-adb-sync — options forwarding", () => {
+  it("forwards --uid", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdDouyinAdbSync({
+      _getHub: async () => hub,
+      uid: "1234567890123456789",
+    });
+    expect(hub.douyinAdbSync.mock.calls[0][0].uid).toBe("1234567890123456789");
+  });
+
+  it("forwards limit-messages + limit-contacts → limits object", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdDouyinAdbSync({
+      _getHub: async () => hub,
+      limitMessages: "500",
+      limitContacts: "100",
+    });
+    const arg = hub.douyinAdbSync.mock.calls[0][0];
+    expect(arg.limits).toEqual({ messages: 500, contacts: 100 });
+  });
+
+  it("forwards display-name + staging-dir", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdDouyinAdbSync({
+      _getHub: async () => hub,
+      displayName: "alice",
+      stagingDir: "/tmp/x",
+    });
+    const arg = hub.douyinAdbSync.mock.calls[0][0];
+    expect(arg.displayName).toBe("alice");
+    expect(arg.stagingDir).toBe("/tmp/x");
+  });
+});
+
+describe("cc hub douyin-adb-sync — _internal export", () => {
+  it("cmdDouyinAdbSync is exported", () => {
+    expect(typeof _internal.cmdDouyinAdbSync).toBe("function");
+  });
+});