chainlesschain 0.162.19 → 0.162.25

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");
+  });
+});

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

@@ -0,0 +1,163 @@
+/**
+ * Phase 3a — cc hub weibo-adb-sync CLI command unit tests.
+ *
+ * Same _getHub test-seam pattern. Mirrors hub-bilibili / hub-douyin tests.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+
+import { _internal } from "../hub.js";
+
+let logSpy, errSpy;
+let prevExitCode;
+
+function fakeHub(syncResult) {
+  return { weiboAdbSync: vi.fn(async (_opts) => syncResult) };
+}
+
+const HAPPY_RESULT = {
+  ok: true,
+  report: {
+    adapter: "social-weibo",
+    status: "ok",
+    rawCount: 25,
+    entityCounts: { events: 25, persons: 0, places: 0, items: 0, topics: 0 },
+    weibo: {
+      uid: 1234567890,
+      eventCounts: { post: 15, favourite: 5, follow: 5, total: 25 },
+      lastErrorCode: 0,
+      lastErrorMessage: null,
+      cookieDiagnostic: { cookieCount: 6, hasSub: true, hadEncrypted: false },
+      uidFetchFailed: 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 weibo-adb-sync — happy path", () => {
+  it("prints human summary", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdWeiboAdbSync({ _getHub: async () => hub });
+    expect(hub.weiboAdbSync).toHaveBeenCalledOnce();
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/weibo-adb-sync succeeded/);
+    expect(out).toMatch(/uid:.*1234567890/);
+    expect(out).toMatch(/posts:\s+15/);
+    expect(out).toMatch(/favourites:\s+5/);
+    expect(out).toMatch(/follows:\s+5/);
+    expect(out).toMatch(/total:\s+25/);
+  });
+
+  it("--json outputs raw result", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdWeiboAdbSync({ _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.weibo.uid).toBe(1234567890);
+  });
+
+  it("renders uidFetchFailed warning when set", async () => {
+    const result = JSON.parse(JSON.stringify(HAPPY_RESULT));
+    result.report.weibo.uidFetchFailed = true;
+    result.report.weibo.lastErrorCode = -4;
+    result.report.weibo.uid = null;
+    const hub = fakeHub(result);
+    await _internal.cmdWeiboAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/api\/config returned login=false/);
+    expect(out).toMatch(/uid fetch failed/);
+  });
+});
+
+describe("cc hub weibo-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.cmdWeiboAdbSync({ _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("WEIBO_NO_ROOT → Magisk tip", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "WEIBO_NO_ROOT",
+      message: "uid=2000",
+    });
+    await _internal.cmdWeiboAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/Magisk root/);
+  });
+
+  it("WEIBO_NOT_INSTALLED → install tip", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "WEIBO_NOT_INSTALLED",
+      message: "Cookies path missing",
+    });
+    await _internal.cmdWeiboAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/Install Weibo App/);
+  });
+
+  it("WEIBO_COOKIES_INCOMPLETE → relog tip (SUB missing)", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "WEIBO_COOKIES_INCOMPLETE",
+      message: "missing SUB",
+    });
+    await _internal.cmdWeiboAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/SUB cookie missing.*relog/);
+  });
+});
+
+describe("cc hub weibo-adb-sync — options forwarding", () => {
+  it("forwards limit-post / limit-favourite / limit-follow", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdWeiboAdbSync({
+      _getHub: async () => hub,
+      limitPost: "50",
+      limitFavourite: "30",
+      limitFollow: "100",
+    });
+    const arg = hub.weiboAdbSync.mock.calls[0][0];
+    expect(arg.limits).toEqual({ post: 50, favourite: 30, follow: 100 });
+  });
+
+  it("forwards display-name + staging-dir", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdWeiboAdbSync({
+      _getHub: async () => hub,
+      displayName: "alice",
+      stagingDir: "/tmp/x",
+    });
+    const arg = hub.weiboAdbSync.mock.calls[0][0];
+    expect(arg.displayName).toBe("alice");
+    expect(arg.stagingDir).toBe("/tmp/x");
+  });
+});
+
+describe("cc hub weibo-adb-sync — _internal export", () => {
+  it("cmdWeiboAdbSync is exported", () => {
+    expect(typeof _internal.cmdWeiboAdbSync).toBe("function");
+  });
+});

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

@@ -0,0 +1,155 @@
+/**
+ * Phase 3c — cc hub xhs-adb-sync CLI command unit tests.
+ *
+ * Mirror of hub-weibo-adb-sync test. Covers meFetchFailed warning + 461
+ * partial-result warning (X-S signing best-effort).
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+
+import { _internal } from "../hub.js";
+
+let logSpy, errSpy;
+let prevExitCode;
+
+function fakeHub(syncResult) {
+  return { xhsAdbSync: vi.fn(async (_opts) => syncResult) };
+}
+
+const HAPPY_RESULT = {
+  ok: true,
+  report: {
+    adapter: "social-xiaohongshu",
+    status: "ok",
+    rawCount: 20,
+    entityCounts: { events: 20, persons: 0, places: 0, items: 0, topics: 0 },
+    xhs: {
+      userId: "5e8c8f7e1234abcdef",
+      nickname: "Alice",
+      eventCounts: { note: 15, liked: 3, follow: 2, total: 20 },
+      lastErrorCode: 0,
+      lastErrorMessage: null,
+      cookieDiagnostic: { cookieCount: 8, hadEncrypted: false },
+      meFetchFailed: 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 xhs-adb-sync — happy path", () => {
+  it("prints human summary with nickname", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdXhsAdbSync({ _getHub: async () => hub });
+    expect(hub.xhsAdbSync).toHaveBeenCalledOnce();
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/xhs-adb-sync succeeded/);
+    expect(out).toMatch(/userId:.*5e8c8f7e/);
+    expect(out).toMatch(/nickname:\s+Alice/);
+    expect(out).toMatch(/notes:\s+15/);
+    expect(out).toMatch(/liked:\s+3/);
+    expect(out).toMatch(/follows:\s+2/);
+    expect(out).toMatch(/total:\s+20/);
+  });
+
+  it("--json outputs raw result", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdXhsAdbSync({ _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.xhs.userId).toBe("5e8c8f7e1234abcdef");
+  });
+
+  it("renders meFetchFailed warning when set", async () => {
+    const result = JSON.parse(JSON.stringify(HAPPY_RESULT));
+    result.report.xhs.meFetchFailed = true;
+    result.report.xhs.lastErrorCode = -7;
+    result.report.xhs.userId = null;
+    const hub = fakeHub(result);
+    await _internal.cmdXhsAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/\/user\/me returned no user_id/);
+    expect(out).toMatch(/me fetch failed/);
+  });
+
+  it("renders X-S 461 partial-result warning", async () => {
+    const result = JSON.parse(JSON.stringify(HAPPY_RESULT));
+    result.report.xhs.lastErrorCode = 461;
+    result.report.xhs.lastErrorMessage = "X-S validation failed";
+    result.report.xhs.eventCounts.total = 5; // partial — only 5 events got through
+    const hub = fakeHub(result);
+    await _internal.cmdXhsAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/X-S 签名 best-effort/);
+    expect(out).toMatch(/lastErrorCode=461/);
+  });
+});
+
+describe("cc hub xhs-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.cmdXhsAdbSync({ _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("XHS_NO_ROOT → Magisk tip", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "XHS_NO_ROOT",
+      message: "uid=2000",
+    });
+    await _internal.cmdXhsAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/Magisk root/);
+  });
+
+  it("XHS_COOKIES_INCOMPLETE → a1/web_session tip", async () => {
+    const hub = fakeHub({
+      ok: false,
+      reason: "XHS_COOKIES_INCOMPLETE",
+      message: "missing a1",
+    });
+    await _internal.cmdXhsAdbSync({ _getHub: async () => hub });
+    const out = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(out).toMatch(/a1 \/ web_session cookie missing/);
+  });
+});
+
+describe("cc hub xhs-adb-sync — options forwarding", () => {
+  it("forwards limit-note / limit-liked / limit-follow", async () => {
+    const hub = fakeHub(HAPPY_RESULT);
+    await _internal.cmdXhsAdbSync({
+      _getHub: async () => hub,
+      limitNote: "20",
+      limitLiked: "15",
+      limitFollow: "50",
+    });
+    const arg = hub.xhsAdbSync.mock.calls[0][0];
+    expect(arg.limits).toEqual({ note: 20, liked: 15, follow: 50 });
+  });
+});
+
+describe("cc hub xhs-adb-sync — _internal export", () => {
+  it("cmdXhsAdbSync is exported", () => {
+    expect(typeof _internal.cmdXhsAdbSync).toBe("function");
+  });
+});