@chainlesschain/personal-data-hub 0.4.36 → 0.4.38

package/lib/adapter-guide.js

@@ -104,6 +104,7 @@ const DISPLAY_NAMES = Object.freeze({
   "gov-12123": "交管12123",
   "browser-history-chrome": "Chrome 浏览历史",
   "browser-history-edge": "Edge 浏览历史",
+  "browser-history-aosp": "MIUI/AOSP 浏览历史",
   "vscode": "VS Code",
   "win-recent": "Windows 最近使用",
   "git-activity": "Git 提交记录",

package/lib/adapters/browser-history-aosp/adapter.js

@@ -0,0 +1,171 @@
+"use strict";
+
+// BrowserHistoryAospAdapter — Android AOSP / MIUI stock Browser
+// (`com.android.browser` → `browser2.db`). The MIUI stock browser is the
+// default on Xiaomi/Redmi devices, so its history is a primary browsing-
+// interest source the Chrome/Edge adapters can't read (different schema).
+//
+// Reuses BrowserHistoryChromeAdapter.normalize() (BROWSE Event / LINK Item
+// shape → identical downstream analysis), but reads the AOSP `history` /
+// `bookmarks` tables directly: a single plaintext SQLite with epoch-MS
+// timestamps, NOT Chrome's urls/visits join with WebKit microseconds.
+//
+// Input is a path to a browser2.db pulled from the device (the contacts/
+// browser providers block `content query`, so collection is root-read +
+// pull, mirroring system-data-android). `opts.dbPath` (preferred) or
+// `opts.profilePath`; a directory is accepted and `browser2.db` looked up
+// inside it.
+//
+// Device-verified schema 2026-06-17, docs/internal/pdh-app-db-schemas.md.
+
+const path = require("node:path");
+
+const {
+  BrowserHistoryChromeAdapter,
+} = require("../browser-history-chrome/adapter");
+const reader = require("./aosp-db-reader");
+
+const NAME = "browser-history-aosp";
+const VERSION = "0.1.0";
+const DB_FILENAME = "browser2.db";
+
+class BrowserHistoryAospAdapter extends BrowserHistoryChromeAdapter {
+  constructor(opts = {}) {
+    super(opts);
+    // Parent set Chrome-shaped capabilities (json bookmarks) + profile fields;
+    // correct them for the AOSP SQLite-bookmarks / db-file layout.
+    this.capabilities = [
+      "sync:aosp-browser-history-sqlite",
+      "sync:aosp-browser-bookmarks-sqlite",
+    ];
+    this.dataDisclosure = {
+      ...this.dataDisclosure,
+      fields: ["history:url,title,visitTimeMs,visitCount", "bookmarks:url,name"],
+    };
+    this._dbPathOverride =
+      (typeof opts.dbPath === "string" && opts.dbPath) ||
+      (typeof opts.profilePath === "string" && opts.profilePath) ||
+      null;
+    this._deps.reader = reader;
+  }
+
+  // Virtual — called by the parent constructor; drives name/version/browser.
+  _browserConfig() {
+    return {
+      name: NAME,
+      version: VERSION,
+      browser: "aosp",
+      defaultProfileDir: () => null, // host has no AOSP browser; db is pulled
+    };
+  }
+
+  _resolveDbPath(opts = {}) {
+    const raw =
+      (typeof opts.dbPath === "string" && opts.dbPath) ||
+      (typeof opts.profilePath === "string" && opts.profilePath) ||
+      this._dbPathOverride;
+    if (!raw) return null;
+    // Accept either the file itself or a directory containing browser2.db.
+    try {
+      if (
+        this._deps.fs.existsSync(raw) &&
+        this._deps.fs.statSync(raw).isDirectory()
+      ) {
+        return path.join(raw, DB_FILENAME);
+      }
+    } catch (_e) {
+      // stat failed — fall through and treat `raw` as a file path
+    }
+    return raw;
+  }
+
+  async authenticate(ctx = {}) {
+    const dbPath = this._resolveDbPath(ctx);
+    if (!dbPath) {
+      return {
+        ok: false,
+        reason: "DB_PATH_UNRESOLVED",
+        message: `pass opts.dbPath pointing at a ${DB_FILENAME} pulled from the device`,
+      };
+    }
+    if (!this._deps.fs.existsSync(dbPath)) {
+      return {
+        ok: false,
+        reason: "DB_NOT_FOUND",
+        message: `no ${DB_FILENAME} at ${dbPath}`,
+      };
+    }
+    return { ok: true, mode: "file-import", dbPath };
+  }
+
+  async healthCheck() {
+    const dbPath = this._resolveDbPath({});
+    const ok = !!dbPath && this._deps.fs.existsSync(dbPath);
+    return { ok, lastChecked: Date.now() };
+  }
+
+  async *sync(opts = {}) {
+    const dbPath = this._resolveDbPath(opts);
+    if (!dbPath || !this._deps.fs.existsSync(dbPath)) {
+      throw new Error(
+        `${this.name}.sync: no ${DB_FILENAME} at ${dbPath || "?"} — set opts.dbPath`,
+      );
+    }
+
+    const includeHistory = opts.include?.history !== false;
+    const includeBookmarks = opts.include?.bookmarks !== false;
+    const limit =
+      Number.isInteger(opts.limit) && opts.limit > 0 ? opts.limit : Infinity;
+    const capturedAt = Date.now();
+    let emitted = 0;
+
+    if (includeHistory) {
+      let tmp = null;
+      try {
+        tmp = this._deps.reader.copyDbSnapshot(dbPath, { fs: this._deps.fs });
+        for (const v of this._deps.reader.readHistory(tmp, {
+          since: opts.since,
+          limit: Number.isFinite(limit) ? limit : undefined,
+        })) {
+          if (emitted >= limit) return;
+          yield {
+            kind: "visit",
+            originalId: `aosp-visit:${dbPath}:${v.visitId}`,
+            capturedAt,
+            payload: { ...v, profileDir: dbPath },
+          };
+          emitted += 1;
+        }
+      } finally {
+        if (tmp) this._deps.reader.cleanupDbSnapshot(tmp, { fs: this._deps.fs });
+      }
+    }
+
+    if (includeBookmarks) {
+      let tmp = null;
+      try {
+        tmp = this._deps.reader.copyDbSnapshot(dbPath, { fs: this._deps.fs });
+        for (const b of this._deps.reader.readBookmarks(tmp, {
+          fs: this._deps.fs,
+        })) {
+          if (emitted >= limit) return;
+          yield {
+            kind: "bookmark",
+            originalId: `aosp-bookmark:${dbPath}:${b.id || b.url}`,
+            capturedAt,
+            payload: { ...b, profileDir: dbPath },
+          };
+          emitted += 1;
+        }
+      } finally {
+        if (tmp) this._deps.reader.cleanupDbSnapshot(tmp, { fs: this._deps.fs });
+      }
+    }
+  }
+}
+
+module.exports = {
+  BrowserHistoryAospAdapter,
+  BROWSER_HISTORY_AOSP_NAME: NAME,
+  BROWSER_HISTORY_AOSP_VERSION: VERSION,
+};

package/lib/adapters/browser-history-aosp/aosp-db-reader.js

@@ -0,0 +1,197 @@
+"use strict";
+
+// AOSP / MIUI stock Browser reader (`com.android.browser` → `browser2.db`).
+//
+// Distinct schema from Chrome: a single PLAINTEXT `history` table with
+// epoch-MILLISECOND timestamps (no urls/visits join, no WebKit microseconds)
+// plus a `bookmarks` table. Device-verified 2026-06-17, see
+// docs/internal/pdh-app-db-schemas.md → "AOSP 浏览器 MIUI Browser".
+//
+// Columns vary slightly by ROM build, so every column is resolved via
+// `PRAGMA table_info` rather than hard-coded — the same defensive approach
+// the douyin/weibo on-device parsers use.
+
+const path = require("node:path");
+const os = require("node:os");
+const fs = require("node:fs");
+
+// Mirror chrome-db-reader.loadDatabase: prefer the multi-cipher build, fall
+// back to vanilla, and smoke-test instantiation (require() returns the JS
+// class even when the native binding is ABI-mismatched; `new` is what throws).
+let _cachedDatabaseClass = null;
+function loadDatabase() {
+  if (_cachedDatabaseClass) return _cachedDatabaseClass;
+  for (const mod of ["better-sqlite3-multiple-ciphers", "better-sqlite3"]) {
+    let cls;
+    try {
+      // eslint-disable-next-line global-require
+      cls = require(mod);
+    } catch (_e) {
+      continue; // require failed, try next candidate
+    }
+    try {
+      const probe = new cls(":memory:");
+      probe.close();
+      _cachedDatabaseClass = cls;
+      return cls;
+    } catch (_e) {
+      // ABI mismatch — try next candidate
+    }
+  }
+  throw new Error(
+    "aosp-db-reader: neither better-sqlite3-multiple-ciphers nor better-sqlite3 loaded — both ABI-mismatched",
+  );
+}
+
+// Scale a raw timestamp to epoch-ms by magnitude (seconds/ms/µs/ns). browser2.db
+// stores `date` in ms, but stay defensive against ROM variants.
+function normalizeEpochMs(t) {
+  if (t == null) return null;
+  const n = typeof t === "bigint" ? Number(t) : Number(t);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  if (n < 1e11) return Math.round(n * 1000); // seconds
+  if (n < 1e14) return Math.round(n); // milliseconds
+  if (n < 1e17) return Math.round(n / 1000); // microseconds
+  return Math.round(n / 1e6); // nanoseconds
+}
+
+// browser2.db is locked while the browser runs (and we usually read a
+// root-pulled copy anyway). Snapshot via copyFileSync, carrying WAL sidecars.
+function copyDbSnapshot(dbPath, opts = {}) {
+  const fsMod = opts.fs || fs;
+  if (!fsMod.existsSync(dbPath)) {
+    const err = new Error(`AOSP browser2.db not found at ${dbPath}`);
+    err.code = "AOSP_BROWSER_DB_NOT_FOUND";
+    throw err;
+  }
+  const tmp = path.join(
+    os.tmpdir(),
+    `pdh-aosp-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.db`,
+  );
+  fsMod.copyFileSync(dbPath, tmp);
+  for (const ext of ["-journal", "-wal", "-shm"]) {
+    const w = dbPath + ext;
+    if (fsMod.existsSync(w)) {
+      try {
+        fsMod.copyFileSync(w, tmp + ext);
+      } catch (_e) {
+        // Sidecar copy failure is non-fatal — we want the pre-WAL state.
+      }
+    }
+  }
+  return tmp;
+}
+
+function cleanupDbSnapshot(tmpPath, opts = {}) {
+  const fsMod = opts.fs || fs;
+  for (const ext of ["", "-journal", "-wal", "-shm"]) {
+    try {
+      fsMod.unlinkSync(tmpPath + ext);
+    } catch (_e) {
+      // best-effort
+    }
+  }
+}
+
+function pickCol(cols, candidates) {
+  const set = new Set(cols.map((c) => c.name));
+  for (const c of candidates) if (set.has(c)) return c;
+  return null;
+}
+
+// Yields history rows ascending by visit time so the registry watermark
+// (max occurredAt) advances monotonically across syncs. Shape matches what
+// BrowserHistoryChromeAdapter.normalize() consumes for kind="visit".
+function* readHistory(tmpPath, opts = {}) {
+  const since = Number.isInteger(opts.since) && opts.since > 0 ? opts.since : 0;
+  const limit =
+    Number.isInteger(opts.limit) && opts.limit > 0 ? opts.limit : 200_000;
+  const Database = loadDatabase();
+  const db = new Database(tmpPath, { readonly: true });
+  try {
+    const cols = db.prepare("PRAGMA table_info(history)").all();
+    if (cols.length === 0) return; // no history table in this DB
+    const idCol = pickCol(cols, ["_id", "id"]);
+    const urlCol = pickCol(cols, ["url"]);
+    const titleCol = pickCol(cols, ["title"]);
+    const dateCol = pickCol(cols, ["date", "created", "visit_time"]);
+    const visitsCol = pickCol(cols, ["visits", "visit_count"]);
+    if (!urlCol || !dateCol) return; // schema we don't recognise
+    const fields = [
+      `${idCol || "rowid"} AS hid`,
+      `${urlCol} AS url`,
+      `${titleCol || "NULL"} AS title`,
+      `${dateCol} AS date`,
+      `${visitsCol || "0"} AS visits`,
+    ];
+    const stmt = db.prepare(
+      `SELECT ${fields.join(", ")} FROM history
+       WHERE ${dateCol} > ?
+       ORDER BY ${dateCol} ASC
+       LIMIT ?`,
+    );
+    for (const r of stmt.iterate(since, limit)) {
+      yield {
+        visitId: r.hid,
+        url: typeof r.url === "string" ? r.url : "",
+        title: typeof r.title === "string" ? r.title : "",
+        visitTimeMs: normalizeEpochMs(r.date),
+        visitCount: Number.isInteger(r.visits) ? r.visits : 0,
+      };
+    }
+  } finally {
+    db.close();
+  }
+}
+
+// Yields bookmark leaves (folder=0, deleted=0). Shape matches what
+// BrowserHistoryChromeAdapter.normalize() consumes for kind="bookmark".
+function* readBookmarks(tmpPath, opts = {}) {
+  const Database = loadDatabase();
+  const db = new Database(tmpPath, { readonly: true });
+  try {
+    const cols = db.prepare("PRAGMA table_info(bookmarks)").all();
+    if (cols.length === 0) return; // no bookmarks table
+    const idCol = pickCol(cols, ["_id", "id"]);
+    const urlCol = pickCol(cols, ["url"]);
+    const titleCol = pickCol(cols, ["title"]);
+    const folderCol = pickCol(cols, ["folder"]);
+    const deletedCol = pickCol(cols, ["deleted"]);
+    const createdCol = pickCol(cols, ["created", "date"]);
+    if (!urlCol) return;
+    const where = [];
+    if (folderCol) where.push(`${folderCol} = 0`); // folder=0 → actual bookmark leaf
+    if (deletedCol) where.push(`${deletedCol} = 0`);
+    where.push(`${urlCol} IS NOT NULL AND ${urlCol} != ''`);
+    const fields = [
+      `${idCol || "rowid"} AS bid`,
+      `${urlCol} AS url`,
+      `${titleCol || "NULL"} AS title`,
+      `${createdCol || "NULL"} AS created`,
+    ];
+    const stmt = db.prepare(
+      `SELECT ${fields.join(", ")} FROM bookmarks WHERE ${where.join(" AND ")}`,
+    );
+    for (const r of stmt.all()) {
+      const url = typeof r.url === "string" ? r.url : "";
+      yield {
+        id: r.bid,
+        name: typeof r.title === "string" && r.title.length > 0 ? r.title : url,
+        url,
+        dateAddedMs: r.created != null ? normalizeEpochMs(r.created) : null,
+        folderPath: null, // browser2.db bookmarks are flat (no folder tree)
+      };
+    }
+  } finally {
+    db.close();
+  }
+}
+
+module.exports = {
+  loadDatabase,
+  normalizeEpochMs,
+  copyDbSnapshot,
+  cleanupDbSnapshot,
+  readHistory,
+  readBookmarks,
+};

package/lib/adapters/browser-history-aosp/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const {
+  BrowserHistoryAospAdapter,
+  BROWSER_HISTORY_AOSP_NAME,
+  BROWSER_HISTORY_AOSP_VERSION,
+} = require("./adapter");
+const reader = require("./aosp-db-reader");
+
+module.exports = {
+  BrowserHistoryAospAdapter,
+  BROWSER_HISTORY_AOSP_NAME,
+  BROWSER_HISTORY_AOSP_VERSION,
+  copyDbSnapshot: reader.copyDbSnapshot,
+  cleanupDbSnapshot: reader.cleanupDbSnapshot,
+  readHistory: reader.readHistory,
+  readBookmarks: reader.readBookmarks,
+  normalizeEpochMs: reader.normalizeEpochMs,
+};

package/lib/adapters/email-imap/templates/bill.js

@@ -127,9 +127,12 @@ async function extractBill(email, opts = {}) {
   if (billingPeriod && billingPeriod.start instanceof Date) {
     billingMonth = formatMonthKey(billingPeriod.start);
   } else if (dueDate instanceof Date) {
-    // "11 月对账单 due 12-25" → bill is for month BEFORE due
-    const prev = new Date(dueDate);
-    prev.setMonth(prev.getMonth() - 1);
+    // "11 月对账单 due 12-25" → bill is for month BEFORE due.
+    // Build from (year, month-1, 1): a naive setMonth(getMonth()-1) keeps the
+    // day, so a due-day of 29-31 overflows into the wrong month (Mar 31 − 1mo
+    // → Feb 31 → rolls to Mar 3 → wrong "-03" instead of "-02"). Month -1
+    // (January → December prior year) is handled correctly by the Date ctor.
+    const prev = new Date(dueDate.getFullYear(), dueDate.getMonth() - 1, 1);
     billingMonth = formatMonthKey(prev);
   } else {
     const m = (email.subject || "").match(/(\d{1,2})\s*月.*(?:对账单|月结|账单)/);

package/lib/analysis-skills/timeline.js

@@ -82,10 +82,15 @@ class TimelineSkill extends AnalysisSkill {
   }
 
   async run(options = {}) {
-    const window = this.resolveTimeWindow({
-      sinceDays: options.sinceDays ?? (options.since ? null : 7), // default 7d
-      ...options,
-    });
+    // Default to the last 7 days only when the caller gave no window at all.
+    // The old `{ sinceDays: …, ...options }` merge injected sinceDays:7 ahead
+    // of resolveTimeWindow's since > sinceDays > sinceMonths precedence, so an
+    // explicit `sinceMonths: N` was silently shadowed into a 7-day window.
+    const hasWindow =
+      (typeof options.since === "number" && options.since > 0) ||
+      (typeof options.sinceDays === "number" && options.sinceDays > 0) ||
+      (typeof options.sinceMonths === "number" && options.sinceMonths > 0);
+    const window = this.resolveTimeWindow(hasWindow ? options : { sinceDays: 7 });
     const limit = Number.isFinite(options.limit) && options.limit > 0
       ? Math.min(options.limit, 1000)
       : 100;

package/lib/index.js

@@ -113,6 +113,7 @@ const mobileExtractor = require("./mobile-extractor");
 const systemDataAndroid = require("./adapters/system-data-android");
 const browserHistoryChrome = require("./adapters/browser-history-chrome");
 const browserHistoryEdge = require("./adapters/browser-history-edge");
+const browserHistoryAosp = require("./adapters/browser-history-aosp");
 const vscodeAdapter = require("./adapters/vscode");
 const winRecentAdapter = require("./adapters/win-recent");
 const gitActivityAdapter = require("./adapters/git-activity");
@@ -398,6 +399,12 @@ module.exports = {
   BROWSER_HISTORY_EDGE_NAME: browserHistoryEdge.BROWSER_HISTORY_EDGE_NAME,
   BROWSER_HISTORY_EDGE_VERSION: browserHistoryEdge.BROWSER_HISTORY_EDGE_VERSION,
 
+  // AOSP / MIUI stock browser — different schema (browser2.db, ms timestamps),
+  // reuses the Chrome normalize() for an identical BROWSE Event / LINK Item shape.
+  BrowserHistoryAospAdapter: browserHistoryAosp.BrowserHistoryAospAdapter,
+  BROWSER_HISTORY_AOSP_NAME: browserHistoryAosp.BROWSER_HISTORY_AOSP_NAME,
+  BROWSER_HISTORY_AOSP_VERSION: browserHistoryAosp.BROWSER_HISTORY_AOSP_VERSION,
+
   // VS Code — workspace history + global terminal command/dir history.
   VSCodeAdapter: vscodeAdapter.VSCodeAdapter,
   VSCODE_NAME: vscodeAdapter.VSCODE_NAME,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chainlesschain/personal-data-hub",
-  "version": "0.4.36",
+  "version": "0.4.38",
   "description": "Personal Data Hub — UnifiedSchema + validators + KG ingest helpers for the data-back-to-the-individual middleware",
   "type": "commonjs",
   "main": "lib/index.js",