@chainlesschain/personal-data-hub 0.2.4 → 0.3.0

package/lib/adapters/system-data-android/adapter.js

@@ -23,11 +23,18 @@ const {
   ENTITY_TYPES,
   PERSON_SUBTYPES,
   ITEM_SUBTYPES,
+  EVENT_SUBTYPES,
   CAPTURED_BY,
 } = require("../../constants");
 
 const NAME = "system-data-android";
-const VERSION = "0.1.0";
+// v0.3.0 (2026-05-24): added kind="media-file" via bridge mode
+//   (host-adb-bridge media.list across 5 /sdcard categories). Metadata
+//   only — path/size/mtime/ext, no file content.
+// v0.2.0 (2026-05-24): added kind="sms" + kind="call" via bridge mode.
+//   Snapshot mode still v1 schema — sms/calls/media only land via
+//   bridge path until Android snapshot writer is updated to include them.
+const VERSION = "0.3.0";
 const SNAPSHOT_SCHEMA_VERSION = 1;
 
 // Stable per-source originalId — registry.putRawEvent rejects null originalId
@@ -48,6 +55,25 @@ function appOriginalId(a) {
     `unknown-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   return `android-app:${k}`;
 }
+function smsOriginalId(s) {
+  // Stable across re-syncs: use SMS _id from the system content provider.
+  const k = (s && s.id != null && String(s.id)) ||
+    `unknown-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  return `android-sms:${k}`;
+}
+function callOriginalId(c) {
+  // Stable across re-syncs: use call_log _id from the system content provider.
+  const k = (c && c.id != null && String(c.id)) ||
+    `unknown-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  return `android-call:${k}`;
+}
+function mediaOriginalId(m) {
+  // Full filesystem path is stable as long as the file isn't moved/renamed.
+  // Path is unique within the device.
+  const k = (m && typeof m.path === "string" && m.path) ||
+    `unknown-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  return `android-media:${k}`;
+}
 
 class SystemDataAndroidAdapter {
   constructor(opts = {}) {
@@ -56,6 +82,9 @@ class SystemDataAndroidAdapter {
     this.capabilities = [
       "sync:android-content-provider",
       "sync:android-package-manager",
+      "sync:android-sms",
+      "sync:android-call-log",
+      "sync:android-media-files",
     ];
     this.extractMode = "device-pull";
     this.rateLimits = { perDay: 24 };
@@ -63,10 +92,20 @@ class SystemDataAndroidAdapter {
       fields: [
         "contacts:displayName,phones,emails,starred,organization,photoUri",
         "installed_apps:packageName,label,versionName,versionCode,firstInstallTime,lastUpdateTime,isSystem",
+        "sms:id,address,body,date,dateSent,type,threadId,read,subject",
+        "callLog:id,number,name,duration,date,type,geocoded",
+        // Media is metadata-only — file content never leaves the device.
+        "media:path,size,mtimeMs,ext,category(photos|pictures|videos|downloads|documents)",
       ],
-      sensitivity: "medium",
+      sensitivity: "high",
       legalGate: false,
-      defaultInclude: { contacts: true, apps: true },
+      defaultInclude: {
+        contacts: true,
+        apps: true,
+        sms: true,
+        calls: true,
+        media: { photos: true, pictures: true, videos: true, downloads: true, documents: true },
+      },
     };
 
     // _deps for test injection — mirrors the pattern in cli-dev.md so test
@@ -191,6 +230,68 @@ class SystemDataAndroidAdapter {
         emitted += 1;
       }
     }
+
+    const includeSms = opts.include?.sms !== false;
+    if (includeSms) {
+      const res = await bridge.invoke("sms.query", {
+        since: Number.isInteger(opts.since) ? opts.since : undefined,
+      });
+      const arr = Array.isArray(res) ? res : Array.isArray(res?.sms) ? res.sms : [];
+      for (const s of arr) {
+        if (emitted >= limit) return;
+        yield {
+          kind: "sms",
+          originalId: smsOriginalId(s),
+          capturedAt,
+          payload: s,
+        };
+        emitted += 1;
+      }
+    }
+
+    const includeCalls = opts.include?.calls !== false;
+    if (includeCalls) {
+      const res = await bridge.invoke("call.query", {
+        since: Number.isInteger(opts.since) ? opts.since : undefined,
+      });
+      const arr = Array.isArray(res) ? res : Array.isArray(res?.calls) ? res.calls : [];
+      for (const c of arr) {
+        if (emitted >= limit) return;
+        yield {
+          kind: "call",
+          originalId: callOriginalId(c),
+          capturedAt,
+          payload: c,
+        };
+        emitted += 1;
+      }
+    }
+
+    // Media files — metadata only (path, size, mtime, ext). Never reads
+    // file content off the device. UI uses per-category include keys so
+    // a privacy-conscious user can keep photos but skip downloads, etc.
+    const MEDIA_CATEGORIES = ["photos", "pictures", "videos", "downloads", "documents"];
+    for (const cat of MEDIA_CATEGORIES) {
+      // Per-category include key: include.media.photos, include.media.videos, ...
+      // Top-level `include.media === false` disables ALL media in one switch.
+      if (opts.include?.media === false) break;
+      if (opts.include?.media?.[cat] === false) continue;
+      const res = await bridge.invoke("media.list", {
+        category: cat,
+        since: Number.isInteger(opts.since) ? opts.since : undefined,
+      });
+      const arr = Array.isArray(res) ? res : Array.isArray(res?.files) ? res.files : [];
+      for (const f of arr) {
+        if (emitted >= limit) return;
+        yield {
+          kind: "media-file",
+          originalId: mediaOriginalId(f),
+          capturedAt,
+          payload: f,
+        };
+        emitted += 1;
+      }
+    }
   }
 
   async *_syncViaSnapshot(opts) {
@@ -336,6 +437,122 @@ class SystemDataAndroidAdapter {
       };
     }
 
+    if (raw.kind === "sms") {
+      const p = raw.payload || {};
+      // SMS type from Android SDK Telephony.Sms (Inbox.MESSAGE_TYPE_*):
+      //   1 INBOX, 2 SENT, 3 DRAFT, 4 OUTBOX, 5 FAILED, 6 QUEUED
+      const direction = p.type === 2 || p.type === 4 ? "out" : "in";
+      const eventId = `event-android-sms-${p.id || raw.capturedAt}`;
+      const occurredAt = Number.isInteger(p.date) ? p.date : raw.capturedAt;
+      const bodyText = typeof p.body === "string" ? p.body : "";
+      const event = {
+        id: eventId,
+        type: ENTITY_TYPES.EVENT,
+        subtype: EVENT_SUBTYPES.MESSAGE,
+        occurredAt,
+        ingestedAt,
+        source: source(`android-sms:${p.id || raw.capturedAt}`),
+        actor: direction === "in" ? p.address : "self",
+        // Participants on the OTHER side of the message.
+        participants: p.address ? [p.address] : [],
+        // Validator (lib/schemas.js validateEvent) requires `content` to be
+        // a plain object — title/text/etc go INSIDE this object, not on the
+        // event root.
+        content: {
+          title: bodyText.length > 0
+            ? (bodyText.length > 80 ? bodyText.substring(0, 80) + "…" : bodyText)
+            : "(空短信)",
+          text: bodyText,
+        },
+      };
+      const extra = { direction, threadId: p.threadId };
+      if (typeof p.dateSent === "number") extra.dateSent = p.dateSent;
+      if (typeof p.read === "boolean") extra.read = p.read;
+      if (typeof p.subject === "string" && p.subject.length > 0) extra.subject = p.subject;
+      if (Number.isInteger(p.type)) extra.smsType = p.type;
+      event.extra = extra;
+
+      return { events: [event], persons: [], places: [], items: [], topics: [] };
+    }
+
+    if (raw.kind === "call") {
+      const p = raw.payload || {};
+      // Call type from Android SDK CallLog.Calls.TYPE:
+      //   1 INCOMING, 2 OUTGOING, 3 MISSED, 4 VOICEMAIL, 5 REJECTED, 6 BLOCKED
+      const direction = p.type === 2 ? "out" : "in";
+      const eventId = `event-android-call-${p.id || raw.capturedAt}`;
+      const occurredAt = Number.isInteger(p.date) ? p.date : raw.capturedAt;
+      const callTypeName =
+        p.type === 1 ? "incoming" :
+        p.type === 2 ? "outgoing" :
+        p.type === 3 ? "missed" :
+        p.type === 4 ? "voicemail" :
+        p.type === 5 ? "rejected" :
+        p.type === 6 ? "blocked" : "unknown";
+      const titleName =
+        (typeof p.name === "string" && p.name.trim().length > 0) ? p.name.trim() : (p.number || "未知号码");
+      const title =
+        `${callTypeName === "missed" ? "未接 " : ""}${callTypeName === "outgoing" ? "拨打 " : ""}${callTypeName === "incoming" ? "来电 " : ""}${titleName}`;
+      const event = {
+        id: eventId,
+        type: ENTITY_TYPES.EVENT,
+        subtype: EVENT_SUBTYPES.CALL,
+        occurredAt,
+        ingestedAt,
+        source: source(`android-call:${p.id || raw.capturedAt}`),
+        actor: direction === "in" ? p.number : "self",
+        participants: p.number ? [p.number] : [],
+        // Schema-required `content` object — title goes here, not on root.
+        content: { title },
+      };
+      if (Number.isInteger(p.duration) && p.duration > 0) {
+        event.durationMs = p.duration * 1000;
+      }
+      const extra = { direction, callType: callTypeName };
+      if (Number.isInteger(p.type)) extra.androidCallType = p.type;
+      if (typeof p.geocoded === "string" && p.geocoded.length > 0) extra.geocoded = p.geocoded;
+      if (typeof p.name === "string" && p.name.length > 0) extra.name = p.name;
+      event.extra = extra;
+
+      return { events: [event], persons: [], places: [], items: [], topics: [] };
+    }
+
+    if (raw.kind === "media-file") {
+      const p = raw.payload || {};
+      const path = typeof p.path === "string" ? p.path : "";
+      const fileName = path.includes("/") ? path.substring(path.lastIndexOf("/") + 1) : path;
+      // Category → item subtype + category string
+      let subtype = ITEM_SUBTYPES.OTHER;
+      let category = "media";
+      if (p.category === "photos" || p.category === "pictures" || p.category === "videos") {
+        subtype = ITEM_SUBTYPES.MEDIA;
+        category = p.category;
+      } else if (p.category === "documents") {
+        subtype = ITEM_SUBTYPES.DOCUMENT;
+        category = "documents";
+      } else if (p.category === "downloads") {
+        subtype = ITEM_SUBTYPES.OTHER;
+        category = "downloads";
+      }
+      const item = {
+        id: `item-android-media-${path}`,
+        type: ENTITY_TYPES.ITEM,
+        subtype,
+        name: fileName || "(无名)",
+        category,
+        ingestedAt,
+        source: source(`android-media:${path}`),
+        extra: {
+          path,
+          size: Number.isInteger(p.size) ? p.size : null,
+          mtimeMs: Number.isInteger(p.mtimeMs) ? p.mtimeMs : null,
+          ext: typeof p.ext === "string" ? p.ext : null,
+          androidCategory: p.category,
+        },
+      };
+      return { events: [], persons: [], places: [], items: [item], topics: [] };
+    }
+
     throw new Error(`system-data-android.normalize: unknown raw.kind=${raw.kind}`);
   }
 }

package/lib/adapters/vscode/adapter.js

@@ -0,0 +1,285 @@
+"use strict";
+
+// VSCodeAdapter — pulls VSCode workspace history + global terminal history
+// from on-disk state. Desktop-local, zero network, no extension required.
+//
+// Sources (all under `%APPDATA%\Code\` on Win, equivalent on macOS/Linux):
+//   - User/workspaceStorage/<hash>/workspace.json  → each opened project
+//   - User/globalStorage/state.vscdb               → terminal command history
+//
+// Yields:
+//   kind="workspace"        → Item(LINK, category="code-project")
+//   kind="terminal-command" → Event(OTHER, content.title=cmd[0..80])
+//   kind="terminal-dir"     → Event(OTHER, content.title=cd <dir>)
+//
+// Caveat: terminal history has NO per-entry timestamp in VSCode — only a
+// single "snapshot updated" ts. We anchor every command/dir to that ts and
+// add `sourceIndex` to extra so callers can reconstruct order. Re-syncing
+// after a new command lands gives that command (and only that command) a
+// fresher snapshot ts.
+
+const path = require("node:path");
+
+const {
+  ENTITY_TYPES,
+  EVENT_SUBTYPES,
+  ITEM_SUBTYPES,
+  CAPTURED_BY,
+} = require("../../constants");
+
+const {
+  defaultVscodeRoot,
+  decodeFileUri,
+  readWorkspaces,
+  readTerminalHistory,
+} = require("./vscode-reader");
+
+const NAME = "vscode";
+const VERSION = "0.1.0";
+
+class VSCodeAdapter {
+  constructor(opts = {}) {
+    this.name = NAME;
+    this.version = VERSION;
+    this.capabilities = [
+      "sync:vscode-workspace-storage",
+      "sync:vscode-globalstorage-sqlite",
+    ];
+    this.extractMode = "file-import";
+    this.rateLimits = { perDay: 96 };
+    this.dataDisclosure = {
+      fields: [
+        "workspaces:hash,folderUri,folderPath,lastOpenedMs",
+        "terminal-commands:command,shellType,sourceIndex,snapshotTs",
+        "terminal-dirs:dir,shellType,sourceIndex,snapshotTs",
+      ],
+      sensitivity: "high",
+      legalGate: false,
+      defaultInclude: { workspaces: true, terminal: true },
+    };
+    this._deps = {
+      fs: require("node:fs"),
+      defaultRoot: defaultVscodeRoot,
+    };
+    this._rootOverride = typeof opts.vscodeRoot === "string" ? opts.vscodeRoot : null;
+  }
+
+  _resolveRoot(opts) {
+    if (typeof opts?.vscodeRoot === "string" && opts.vscodeRoot.length > 0) {
+      return opts.vscodeRoot;
+    }
+    if (this._rootOverride) return this._rootOverride;
+    return this._deps.defaultRoot();
+  }
+
+  async authenticate(ctx = {}) {
+    const root = this._resolveRoot(ctx);
+    if (!root) {
+      return {
+        ok: false,
+        reason: "VSCODE_ROOT_UNRESOLVED",
+        message: "no default VSCode root on this platform; pass opts.vscodeRoot",
+      };
+    }
+    const wsRoot = path.join(root, "User", "workspaceStorage");
+    const stateDb = path.join(root, "User", "globalStorage", "state.vscdb");
+    const wsExists = this._deps.fs.existsSync(wsRoot);
+    const stateExists = this._deps.fs.existsSync(stateDb);
+    if (!wsExists && !stateExists) {
+      return {
+        ok: false,
+        reason: "VSCODE_NOT_FOUND",
+        message: `no VSCode state at ${root} — install VS Code / open it at least once, or pass opts.vscodeRoot`,
+      };
+    }
+    return {
+      ok: true,
+      mode: "file-import",
+      vscodeRoot: root,
+      hasWorkspaces: wsExists,
+      hasTerminalHistory: stateExists,
+    };
+  }
+
+  async healthCheck() {
+    const root = this._resolveRoot({});
+    const ok =
+      !!root &&
+      (this._deps.fs.existsSync(path.join(root, "User", "workspaceStorage")) ||
+        this._deps.fs.existsSync(path.join(root, "User", "globalStorage", "state.vscdb")));
+    return { ok, lastChecked: Date.now() };
+  }
+
+  async *sync(opts = {}) {
+    const root = this._resolveRoot(opts);
+    if (!root) {
+      throw new Error("vscode.sync: no VSCode root resolved — pass opts.vscodeRoot");
+    }
+    const includeWorkspaces = opts.include?.workspaces !== false;
+    const includeTerminal = opts.include?.terminal !== false;
+    const limit = Number.isInteger(opts.limit) && opts.limit > 0 ? opts.limit : Infinity;
+    const capturedAt = Date.now();
+    let emitted = 0;
+
+    if (includeWorkspaces) {
+      for (const w of readWorkspaces(root, { fs: this._deps.fs, since: opts.since })) {
+        if (emitted >= limit) return;
+        yield {
+          kind: "workspace",
+          originalId: `vscode-workspace:${w.hash}`,
+          capturedAt,
+          payload: w,
+        };
+        emitted += 1;
+      }
+    }
+
+    if (includeTerminal) {
+      const hist = readTerminalHistory(root, { fs: this._deps.fs });
+      const cmdTs = Number.isInteger(hist.commandsTimestampMs)
+        ? hist.commandsTimestampMs
+        : capturedAt;
+      const dirTs = Number.isInteger(hist.dirsTimestampMs)
+        ? hist.dirsTimestampMs
+        : capturedAt;
+      if (opts.include?.terminalCommands !== false) {
+        for (const c of hist.commands) {
+          if (emitted >= limit) return;
+          if (Number.isInteger(opts.since) && cmdTs < opts.since) break;
+          yield {
+            kind: "terminal-command",
+            // Index disambiguates entries that re-occur with identical command
+            // text — keeps registry.putRawEvent's UNIQUE(source.originalId) happy.
+            originalId: `vscode-terminal-cmd:${c.sourceIndex}:${hashCommand(c.value)}`,
+            capturedAt,
+            payload: { ...c, snapshotTs: cmdTs },
+          };
+          emitted += 1;
+        }
+      }
+      if (opts.include?.terminalDirs !== false) {
+        for (const d of hist.dirs) {
+          if (emitted >= limit) return;
+          if (Number.isInteger(opts.since) && dirTs < opts.since) break;
+          yield {
+            kind: "terminal-dir",
+            originalId: `vscode-terminal-dir:${d.sourceIndex}:${hashCommand(d.value)}`,
+            capturedAt,
+            payload: { ...d, snapshotTs: dirTs },
+          };
+          emitted += 1;
+        }
+      }
+    }
+  }
+
+  normalize(raw) {
+    const ingestedAt = Date.now();
+    const source = (originalId) => ({
+      adapter: NAME,
+      adapterVersion: VERSION,
+      capturedAt: raw.capturedAt,
+      capturedBy: CAPTURED_BY.SQLITE,
+      originalId,
+    });
+
+    if (raw.kind === "workspace") {
+      const p = raw.payload || {};
+      const uri = p.folderUri || p.workspaceUri || `vscode-hash:${p.hash}`;
+      const name =
+        (p.folderPath && p.folderPath.split(/[\\/]/).filter(Boolean).pop()) ||
+        decodeFileUri(uri) ||
+        uri;
+      const item = {
+        id: `item-vscode-workspace-${p.hash}`,
+        type: ENTITY_TYPES.ITEM,
+        subtype: ITEM_SUBTYPES.LINK,
+        name: name || "(无名工程)",
+        category: "code-project",
+        ingestedAt,
+        source: source(`vscode-workspace:${p.hash}`),
+        extra: {
+          folderUri: p.folderUri || null,
+          workspaceUri: p.workspaceUri || null,
+          folderPath: p.folderPath || null,
+          lastOpenedMs: Number.isInteger(p.lastOpenedMs) ? p.lastOpenedMs : null,
+          editor: "vscode",
+        },
+      };
+      return { events: [], persons: [], places: [], items: [item], topics: [] };
+    }
+
+    if (raw.kind === "terminal-command") {
+      const p = raw.payload || {};
+      const cmd = typeof p.value === "string" ? p.value : "";
+      const event = {
+        id: `event-vscode-terminal-cmd-${p.sourceIndex}-${shortHash(cmd)}`,
+        type: ENTITY_TYPES.EVENT,
+        subtype: EVENT_SUBTYPES.OTHER,
+        occurredAt: Number.isInteger(p.snapshotTs) ? p.snapshotTs : raw.capturedAt,
+        ingestedAt,
+        source: source(raw.originalId),
+        actor: "self",
+        content: {
+          title: cmd.length > 80 ? cmd.substring(0, 80) + "…" : cmd,
+          text: cmd,
+        },
+        extra: {
+          kind: "terminal-command",
+          shellType: p.shellType || null,
+          sourceIndex: p.sourceIndex,
+          editor: "vscode",
+        },
+      };
+      return { events: [event], persons: [], places: [], items: [], topics: [] };
+    }
+
+    if (raw.kind === "terminal-dir") {
+      const p = raw.payload || {};
+      const dir = typeof p.value === "string" ? p.value : "";
+      const event = {
+        id: `event-vscode-terminal-dir-${p.sourceIndex}-${shortHash(dir)}`,
+        type: ENTITY_TYPES.EVENT,
+        subtype: EVENT_SUBTYPES.OTHER,
+        occurredAt: Number.isInteger(p.snapshotTs) ? p.snapshotTs : raw.capturedAt,
+        ingestedAt,
+        source: source(raw.originalId),
+        actor: "self",
+        content: {
+          title: `cd ${dir.length > 76 ? dir.substring(0, 76) + "…" : dir}`,
+          text: dir,
+        },
+        extra: {
+          kind: "terminal-dir",
+          shellType: p.shellType || null,
+          sourceIndex: p.sourceIndex,
+          editor: "vscode",
+        },
+      };
+      return { events: [event], persons: [], places: [], items: [], topics: [] };
+    }
+
+    throw new Error(`vscode.normalize: unknown raw.kind=${raw.kind}`);
+  }
+}
+
+// Cheap non-crypto hash for de-duping originalId + event id collisions.
+// Don't need cryptographic strength here — the registry UNIQUE constraint
+// gives the real guarantee.
+function hashCommand(s) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) {
+    h = ((h << 5) + h + s.charCodeAt(i)) >>> 0;
+  }
+  return h.toString(36);
+}
+
+function shortHash(s) {
+  return hashCommand(s).substring(0, 8);
+}
+
+module.exports = {
+  VSCodeAdapter,
+  VSCODE_NAME: NAME,
+  VSCODE_VERSION: VERSION,
+};

package/lib/adapters/vscode/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const {
+  VSCodeAdapter,
+  VSCODE_NAME,
+  VSCODE_VERSION,
+} = require("./adapter");
+const reader = require("./vscode-reader");
+
+module.exports = {
+  VSCodeAdapter,
+  VSCODE_NAME,
+  VSCODE_VERSION,
+  defaultVscodeRoot: reader.defaultVscodeRoot,
+  decodeFileUri: reader.decodeFileUri,
+  readWorkspaces: reader.readWorkspaces,
+  readTerminalHistory: reader.readTerminalHistory,
+};