chainlesschain 0.162.13 → 0.162.14

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/android.js

@@ -0,0 +1,284 @@
+/**
+ * `cc android` — Android-side data + control commands.
+ *
+ * Plan A Sub-Phase A7 scaffold. Exposes the bridge surface from
+ * `lib/cc-android-bridge.js` as commander subcommands. Method shapes mirror
+ * `docs/design/Personal_Data_Hub_Android_Standalone_Cc.md` §6.1.
+ *
+ * **v0.1 status**: native JNI bridge (`cc-android-bridge.node`) not yet
+ * bundled (A6 in progress). On non-Android hosts every command exits non-zero
+ * with `ANDROID_BRIDGE_NOT_AVAILABLE`. On Android with a missing binding,
+ * same error with a different reason string. This lets the surface land and
+ * be tested ahead of the JNI shipping work.
+ *
+ * All commands support `--json` for scripting and exit non-zero on error.
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import * as bridgeModule from "../lib/cc-android-bridge.js";
+
+function printJson(obj) {
+  console.log(JSON.stringify(obj, null, 2));
+}
+
+function fail(err, asJson) {
+  const msg = err && err.message ? err.message : String(err);
+  const code = err && err.code ? err.code : null;
+  if (asJson) {
+    printJson({ error: msg, code });
+  } else {
+    logger.error(chalk.red(`✗ ${msg}`));
+  }
+  process.exit(1);
+}
+
+async function run(method, params, options) {
+  try {
+    const result = await _deps.bridge.invoke(method, params);
+    if (options.json) {
+      printJson(result);
+    } else {
+      console.log(JSON.stringify(result, null, 2));
+    }
+  } catch (err) {
+    fail(err, options.json);
+  }
+}
+
+// ─── caps ────────────────────────────────────────────────────────────
+
+async function cmdCaps(options) {
+  const capsResult = _deps.bridge.caps();
+  if (options.json) {
+    printJson(capsResult);
+    return;
+  }
+  if (capsResult.available) {
+    logger.log(chalk.green("✓ android bridge available"));
+  } else {
+    logger.log(
+      chalk.yellow(`⚠ android bridge unavailable: ${capsResult.reason}`),
+    );
+  }
+}
+
+// ─── contacts / sms / calls — P1 ContentResolver ─────────────────────
+
+function cmdContactsPull(options) {
+  return run(
+    "contacts.query",
+    { since: options.since ? Number(options.since) : undefined },
+    options,
+  );
+}
+function cmdSmsPull(options) {
+  return run(
+    "sms.query",
+    { since: options.since ? Number(options.since) : undefined },
+    options,
+  );
+}
+function cmdCallsPull(options) {
+  return run(
+    "calls.query",
+    { since: options.since ? Number(options.since) : undefined },
+    options,
+  );
+}
+
+// ─── app — PackageManager ────────────────────────────────────────────
+
+function cmdAppList(options) {
+  return run("app.list", { includeSystem: !!options.system }, options);
+}
+function cmdAppLaunch(pkg, options) {
+  return run("app.launch", { pkg }, options);
+}
+function cmdAppIntent(pkg, action, options) {
+  const extras = {};
+  if (Array.isArray(options.extra)) {
+    for (const kv of options.extra) {
+      const idx = kv.indexOf("=");
+      if (idx > 0) extras[kv.slice(0, idx)] = kv.slice(idx + 1);
+    }
+  }
+  return run("app.intent", { pkg, action, extras }, options);
+}
+
+// ─── fs — SAF / sandbox ──────────────────────────────────────────────
+
+function cmdFsRead(target, options) {
+  return run("fs.read", { target }, options);
+}
+function cmdFsList(target, options) {
+  return run("fs.list", { target }, options);
+}
+
+// ─── a11y — Accessibility Service ────────────────────────────────────
+
+function cmdA11yQuery(options) {
+  return run("a11y.query", { filter: options.filter }, options);
+}
+function cmdA11yClick(nodeId, options) {
+  return run("a11y.click", { nodeId }, options);
+}
+function cmdA11yType(text, options) {
+  return run("a11y.type", { text }, options);
+}
+
+// ─── shizuku / root ──────────────────────────────────────────────────
+
+function cmdShizukuExec(cmd, options) {
+  return run("shizuku.exec", { cmd }, options);
+}
+function cmdRootExec(cmd, options) {
+  return run("root.exec", { cmd }, options);
+}
+
+// ─── perms ────────────────────────────────────────────────────────────
+
+function cmdPerms(name, options) {
+  return run("perms.check", { name }, options);
+}
+
+// ─── Commander wire-up ───────────────────────────────────────────────
+
+export function registerAndroidCommand(program) {
+  const android = program
+    .command("android")
+    .description(
+      "Android-native bridge: ContentResolver / SAF / Accessibility / Shizuku / root (Plan A A7)",
+    );
+
+  android
+    .command("caps")
+    .description("Probe what bridge capabilities are available on this device")
+    .option("--json", "Output JSON")
+    .action(cmdCaps);
+
+  const contacts = android
+    .command("contacts")
+    .description("ContentResolver: contacts");
+  contacts
+    .command("pull")
+    .description("Pull contacts (READ_CONTACTS runtime permission required)")
+    .option("--since <ms>", "Watermark — only newer entries")
+    .option("--json", "Output JSON")
+    .action(cmdContactsPull);
+
+  const sms = android.command("sms").description("ContentResolver: SMS");
+  sms
+    .command("pull")
+    .description("Pull SMS (READ_SMS runtime permission required)")
+    .option("--since <ms>", "Watermark")
+    .option("--json", "Output JSON")
+    .action(cmdSmsPull);
+
+  const calls = android
+    .command("calls")
+    .description("ContentResolver: call log");
+  calls
+    .command("pull")
+    .description("Pull call log (READ_CALL_LOG runtime permission required)")
+    .option("--since <ms>", "Watermark")
+    .option("--json", "Output JSON")
+    .action(cmdCallsPull);
+
+  const app = android
+    .command("app")
+    .description("PackageManager: app inventory + Intent");
+  app
+    .command("list")
+    .description("List installed packages")
+    .option("--system", "Include system packages")
+    .option("--json", "Output JSON")
+    .action(cmdAppList);
+  app
+    .command("launch <pkg>")
+    .description("Launch app by package id (default activity)")
+    .option("--json", "Output JSON")
+    .action(cmdAppLaunch);
+  app
+    .command("intent <pkg> <action>")
+    .description("Fire an Intent at <pkg> with <action>")
+    .option(
+      "--extra <kv...>",
+      "Repeatable extras as KEY=VAL (e.g. --extra foo=bar --extra n=1)",
+    )
+    .option("--json", "Output JSON")
+    .action(cmdAppIntent);
+
+  const fs = android.command("fs").description("SAF / sandbox filesystem");
+  fs.command("read <target>")
+    .description("Read file (sandbox path OR SAF tree URI)")
+    .option("--json", "Output JSON")
+    .action(cmdFsRead);
+  fs.command("list <target>")
+    .description("List directory")
+    .option("--json", "Output JSON")
+    .action(cmdFsList);
+
+  const a11y = android.command("a11y").description("Accessibility Service");
+  a11y
+    .command("query")
+    .description("Dump current screen's node tree")
+    .option("--filter <css>", "css-like filter")
+    .option("--json", "Output JSON")
+    .action(cmdA11yQuery);
+  a11y
+    .command("click <nodeId>")
+    .description("Click a node")
+    .option("--json", "Output JSON")
+    .action(cmdA11yClick);
+  a11y
+    .command("type <text>")
+    .description("Type text into focused field")
+    .option("--json", "Output JSON")
+    .action(cmdA11yType);
+
+  const shizuku = android
+    .command("shizuku")
+    .description("Shizuku ADB-like privileges");
+  shizuku
+    .command("exec <cmd>")
+    .description("Run shell via Shizuku")
+    .option("--json", "Output JSON")
+    .action(cmdShizukuExec);
+
+  const root = android.command("root").description("Magisk root su");
+  root
+    .command("exec <cmd>")
+    .description("Run shell as root")
+    .option("--json", "Output JSON")
+    .action(cmdRootExec);
+
+  android
+    .command("perms <name>")
+    .description("Check (and request) a runtime permission")
+    .option("--json", "Output JSON")
+    .action(cmdPerms);
+}
+
+// _deps injection seam — tests reach in and replace `bridge` with a mock so
+// the cmd* functions exercise the routing code without a real bridge.
+export const _deps = { bridge: bridgeModule };
+
+// Test-only exports.
+export const _cmds = {
+  cmdCaps,
+  cmdContactsPull,
+  cmdSmsPull,
+  cmdCallsPull,
+  cmdAppList,
+  cmdAppLaunch,
+  cmdAppIntent,
+  cmdFsRead,
+  cmdFsList,
+  cmdA11yQuery,
+  cmdA11yClick,
+  cmdA11yType,
+  cmdShizukuExec,
+  cmdRootExec,
+  cmdPerms,
+};

package/src/commands/hub.js

@@ -191,6 +191,9 @@ async function cmdSyncAdapter(name, options) {
     if (options.since) opts.since = Number(options.since);
     if (options.until) opts.until = Number(options.until);
     if (options.limit) opts.limit = Number(options.limit);
+    // Plan A v0.1 — system-data-android needs a snapshot file path. Generic
+    // pass-through so other input-driven adapters reuse the same flag.
+    if (options.input) opts.inputPath = String(options.input);
     const report = await hub.registry.syncAdapter(name, opts);
     if (spinner) spinner.succeed(`synced ${name}`);
     if (options.json) {
@@ -566,13 +569,25 @@ async function cmdWechatEnvProbe(options) {
       return;
     }
     logger.log(chalk.bold("WeChat env-probe:"));
-    logger.log(`  ${probe.ok ? chalk.green("✓") : chalk.red("✗")} suggested: ${chalk.cyan(probe.suggestedKeyProvider)}`);
-    logger.log(`  device: ${probe.device.reachable ? chalk.green("reachable") : chalk.red("unreachable")}${probe.device.serial ? " (" + probe.device.serial + ")" : ""} abi=${probe.device.abi || "?"}`);
-    logger.log(`  root: ${probe.root.detected ? chalk.green("yes") : chalk.gray("no")} magisk=${probe.root.magiskInstalled ? "yes" : "no"}`);
-    logger.log(`  frida-server: ${probe.frida.serverRunning ? chalk.green("running") : chalk.gray("not running")}${probe.frida.port ? " :" + probe.frida.port : ""}`);
-    logger.log(`  wechat: ${probe.wechat.installed ? chalk.green(probe.wechat.versionName) : chalk.gray("not installed")}`);
-    for (const reason of probe.reasons || []) logger.log(`  · ${chalk.gray(reason)}`);
-    for (const w of probe.warnings || []) logger.log(`  ${chalk.yellow("!")} ${chalk.yellow(w)}`);
+    logger.log(
+      `  ${probe.ok ? chalk.green("✓") : chalk.red("✗")} suggested: ${chalk.cyan(probe.suggestedKeyProvider)}`,
+    );
+    logger.log(
+      `  device: ${probe.device.reachable ? chalk.green("reachable") : chalk.red("unreachable")}${probe.device.serial ? " (" + probe.device.serial + ")" : ""} abi=${probe.device.abi || "?"}`,
+    );
+    logger.log(
+      `  root: ${probe.root.detected ? chalk.green("yes") : chalk.gray("no")} magisk=${probe.root.magiskInstalled ? "yes" : "no"}`,
+    );
+    logger.log(
+      `  frida-server: ${probe.frida.serverRunning ? chalk.green("running") : chalk.gray("not running")}${probe.frida.port ? " :" + probe.frida.port : ""}`,
+    );
+    logger.log(
+      `  wechat: ${probe.wechat.installed ? chalk.green(probe.wechat.versionName) : chalk.gray("not installed")}`,
+    );
+    for (const reason of probe.reasons || [])
+      logger.log(`  · ${chalk.gray(reason)}`);
+    for (const w of probe.warnings || [])
+      logger.log(`  ${chalk.yellow("!")} ${chalk.yellow(w)}`);
   } catch (err) {
     fail(null, err, options.json);
   }
@@ -589,16 +604,21 @@ async function cmdWechatRegister(options) {
       dbPath: options.db || null,
       wechatDataPath: options.wechatDataPath || null,
       keyProviderOverride: options.forceProvider || null,
-      fridaOpts: options.fridaDeviceId ? { deviceId: options.fridaDeviceId } : null,
+      fridaOpts: options.fridaDeviceId
+        ? { deviceId: options.fridaDeviceId }
+        : null,
     });
     if (options.json) {
       printJson(r);
       return;
     }
     if (!r.ok) {
-      logger.error(chalk.red(`✗ ${r.reason || "register failed"}: ${r.message || ""}`));
+      logger.error(
+        chalk.red(`✗ ${r.reason || "register failed"}: ${r.message || ""}`),
+      );
       if (r.probe) {
-        for (const reason of r.probe.reasons || []) logger.error(chalk.gray("  · " + reason));
+        for (const reason of r.probe.reasons || [])
+          logger.error(chalk.gray("  · " + reason));
       }
       process.exit(1);
     }
@@ -624,7 +644,9 @@ async function cmdWechatList(options) {
     }
     logger.log(chalk.bold("Registered WeChat accounts:"));
     for (const row of rows) {
-      logger.log(`  • uin=${chalk.cyan(row.uin)} provider=${row.chosenKeyProvider || "?"} db=${row.dbPath || "(none)"} regAt=${row.registeredAt ? new Date(row.registeredAt).toISOString() : "?"}`);
+      logger.log(
+        `  • uin=${chalk.cyan(row.uin)} provider=${row.chosenKeyProvider || "?"} db=${row.dbPath || "(none)"} regAt=${row.registeredAt ? new Date(row.registeredAt).toISOString() : "?"}`,
+      );
     }
   } catch (err) {
     fail(null, err, options.json);
@@ -644,8 +666,12 @@ async function cmdWechatUnregister(uin, options) {
       logger.error(chalk.red(`✗ ${r.reason || "unregister failed"}`));
       process.exit(1);
     }
-    if (r.removed) logger.log(chalk.green(`✓ removed wechat account (uin=${uin})`));
-    else logger.log(chalk.gray(`(uin=${uin} was not registered — nothing removed)`));
+    if (r.removed)
+      logger.log(chalk.green(`✓ removed wechat account (uin=${uin})`));
+    else
+      logger.log(
+        chalk.gray(`(uin=${uin} was not registered — nothing removed)`),
+      );
   } catch (err) {
     fail(null, err, options.json);
   }
@@ -712,6 +738,10 @@ export function registerHubCommand(program) {
     .option("--since <ms>", "Override watermark — sync from this unix-ms")
     .option("--until <ms>", "Stop at this unix-ms")
     .option("--limit <n>", "Cap ingested events")
+    .option(
+      "--input <path>",
+      "Path to a snapshot file produced by a UI layer (system-data-android, etc.)",
+    )
     .option("--json", "Output JSON")
     .action(cmdSyncAdapter);
 
@@ -833,7 +863,9 @@ export function registerHubCommand(program) {
 
   wechat
     .command("env-probe")
-    .description("Probe attached Android device for adb / root / frida-server / WeChat version")
+    .description(
+      "Probe attached Android device for adb / root / frida-server / WeChat version",
+    )
     .option("--json", "Output JSON")
     .action(cmdWechatEnvProbe);
 
@@ -844,9 +876,15 @@ export function registerHubCommand(program) {
     )
     .requiredOption("--uin <id>", "WeChat numeric UIN (≤ 8.0) or wxid (8.0+)")
     .option("--db <path>", "Local path to the already-pulled EnMicroMsg.db")
-    .option("--wechat-data-path <dir>", "Local pulled /data/data/com.tencent.mm/ tree (required for md5 path)")
+    .option(
+      "--wechat-data-path <dir>",
+      "Local pulled /data/data/com.tencent.mm/ tree (required for md5 path)",
+    )
     .option("--force-provider <md5|frida>", "Override env-probe suggestion")
-    .option("--frida-device-id <id>", "Frida device id (defaults to first USB device)")
+    .option(
+      "--frida-device-id <id>",
+      "Frida device id (defaults to first USB device)",
+    )
     .option("--json", "Output JSON")
     .action(cmdWechatRegister);
 
@@ -858,7 +896,9 @@ export function registerHubCommand(program) {
 
   wechat
     .command("unregister <uin>")
-    .description("Remove a registered WeChat account (does not touch vault data)")
+    .description(
+      "Remove a registered WeChat account (does not touch vault data)",
+    )
     .option("--json", "Output JSON")
     .action(cmdWechatUnregister);
 }