@chipallen2/snazi 0.1.0

package/dist/channels/imessage.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imessageAdapter = void 0;
+const FDA_HINT = 'Grant Full Disk Access to your terminal (or the node binary) in ' +
+    'System Settings > Privacy & Security > Full Disk Access, then retry.';
+// Lazy require: only load chatdb (and thus better-sqlite3) when we actually
+// read on macOS. Keeps Windows/Linux installs free of the native dependency at
+// runtime — they never reach this code because availability() returns first.
+function chatdb() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require('../chatdb');
+}
+exports.imessageAdapter = {
+    id: 'imessage',
+    displayName: 'iMessage',
+    platforms: ['darwin'],
+    availability() {
+        if (process.platform !== 'darwin') {
+            return {
+                available: false,
+                reason: `iMessage can only be read on macOS (this host is ${process.platform}).`,
+            };
+        }
+        let probe;
+        try {
+            probe = chatdb().probeChatDb();
+        }
+        catch (e) {
+            // better-sqlite3 is an optional native dependency; if it failed to
+            // install (or load), report it cleanly instead of throwing.
+            return {
+                available: false,
+                reason: `iMessage backend unavailable: ${String(e instanceof Error ? e.message : e)}`,
+                detail: 'Reinstall to build the native better-sqlite3 module (needs Xcode Command Line Tools).',
+            };
+        }
+        if (probe.ok)
+            return { available: true };
+        return { available: false, reason: probe.reason, detail: FDA_HINT };
+    },
+    listInboundSenders(sinceMinutes) {
+        return chatdb().listInboundSenders(sinceMinutes);
+    },
+    readMessagesFrom(sender, sinceMinutes) {
+        return chatdb().readMessagesFrom(sender, sinceMinutes);
+    },
+};

package/dist/channels/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAdapter = getAdapter;
+exports.listAdapters = listAdapters;
+exports.resolveReadableAdapter = resolveReadableAdapter;
+const imessage_1 = require("./imessage");
+const ADAPTERS = new Map([imessage_1.imessageAdapter].map((a) => [a.id, a]));
+/** Look up a registered adapter by channel id, or undefined. */
+function getAdapter(id) {
+    return ADAPTERS.get(id);
+}
+/** Every registered adapter (in registration order). */
+function listAdapters() {
+    return [...ADAPTERS.values()];
+}
+/**
+ * Resolve a channel id to an adapter that can actually READ on this host.
+ * Never throws: returns a helpful `error` string when the channel is unknown
+ * or unavailable on this platform, so callers can surface it as JSON.
+ */
+function resolveReadableAdapter(channel) {
+    const adapter = getAdapter(channel);
+    if (!adapter) {
+        const known = listAdapters()
+            .map((a) => a.id)
+            .join(', ');
+        return {
+            error: `Unknown channel '${channel}'. Known channels: ${known || '(none)'}.`,
+        };
+    }
+    const availability = adapter.availability();
+    if (!availability.available) {
+        const detail = availability.detail ? ` ${availability.detail}` : '';
+        return {
+            error: `Channel '${channel}' is not available on this machine: ${availability.reason ?? 'unavailable'}.${detail}`,
+        };
+    }
+    return { adapter };
+}

package/dist/channels/types.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Channel adapter contract.
+ *
+ * A ChannelAdapter is the LOCAL message SOURCE for one medium (iMessage today;
+ * Gmail/Outlook/etc. later). It answers two questions for the gate:
+ *   - WHO messaged recently (`listInboundSenders`) — never content.
+ *   - WHAT one (already-approved) sender said (`readMessagesFrom`).
+ *
+ * Adapters also declare which OS platforms they can run on and self-report
+ * availability, so a channel that can't run here (e.g. iMessage on Windows)
+ * degrades to a clear message instead of a crash. The approval gate (api.ts)
+ * and the server list are channel-agnostic and live OUTSIDE this contract —
+ * adapters only provide the local source of messages, never the decision.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/chatdb.js

@@ -0,0 +1,202 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unixMsToAppleNs = unixMsToAppleNs;
+exports.appleNsToDate = appleNsToDate;
+exports.chatDbPath = chatDbPath;
+exports.probeChatDb = probeChatDb;
+exports.listInboundSenders = listInboundSenders;
+exports.readMessagesFrom = readMessagesFrom;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const DEFAULT_CHAT_DB = path.join(os.homedir(), 'Library', 'Messages', 'chat.db');
+/**
+ * Resolve the chat.db path. Honors the `SNAZI_CHAT_DB` env var (if set and
+ * non-empty) so tests can point at a synthetic DB; otherwise the real
+ * ~/Library/Messages/chat.db. Read per-call so tests can set/unset freely.
+ */
+function getChatDbPath() {
+    const override = process.env.SNAZI_CHAT_DB;
+    if (override && override.trim() !== '')
+        return override;
+    return DEFAULT_CHAT_DB;
+}
+// Apple Cocoa epoch: 2001-01-01 in unix seconds.
+const APPLE_EPOCH = 978307200;
+/** Convert a unix-ms cutoff into Apple's nanosecond `message.date` units. */
+function unixMsToAppleNs(unixMs) {
+    return Math.floor((unixMs / 1000 - APPLE_EPOCH) * 1e9);
+}
+/** Convert Apple's `message.date` (ns) back into a JS Date. */
+function appleNsToDate(appleNs) {
+    return new Date((appleNs / 1e9 + APPLE_EPOCH) * 1000);
+}
+function openDb() {
+    const chatDb = getChatDbPath();
+    if (!fs.existsSync(chatDb)) {
+        throw new Error(`chat.db not found at ${chatDb}. Is this a Mac with Messages?`);
+    }
+    try {
+        return new better_sqlite3_1.default(chatDb, { readonly: true, fileMustExist: true });
+    }
+    catch (e) {
+        throw new Error(`Cannot open chat.db (${String(e)}). Grant your terminal Full Disk Access in System Settings > Privacy & Security.`);
+    }
+}
+/** The resolved chat.db path (honors SNAZI_CHAT_DB). Exposed for diagnostics. */
+function chatDbPath() {
+    return getChatDbPath();
+}
+/**
+ * Non-throwing readability probe used by the iMessage channel adapter's
+ * availability check. Returns `{ ok: true }` only if chat.db exists AND can be
+ * opened + queried read-only (i.e. Full Disk Access is granted). Otherwise
+ * returns a human-readable reason — never throws.
+ */
+function probeChatDb() {
+    const chatDb = getChatDbPath();
+    if (!fs.existsSync(chatDb)) {
+        return { ok: false, reason: `chat.db not found at ${chatDb}.` };
+    }
+    let db;
+    try {
+        db = new better_sqlite3_1.default(chatDb, { readonly: true, fileMustExist: true });
+        // A trivial query forces the file open: this is what fails without FDA.
+        db.prepare('SELECT 1').get();
+        return { ok: true };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            reason: `Cannot open chat.db at ${chatDb} (likely missing Full Disk Access): ${String(e instanceof Error ? e.message : e)}`,
+        };
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        catch {
+            // ignore close errors on a probe
+        }
+    }
+}
+// A 1:1 (direct) conversation is a chat with exactly ONE participant in
+// chat_handle_join. Group chats have 2+. We scope BOTH listing and reading to
+// these so "approve a person" means "their DMs" — never their group-chat
+// traffic. This also avoids leaking who's in your group threads.
+const DIRECT_CHATS_SQL = `
+  SELECT chat_id FROM chat_handle_join
+  GROUP BY chat_id HAVING COUNT(*) = 1
+`;
+/**
+ * Return distinct INBOUND senders in the window — WHO only, never WHAT.
+ * Scoped to 1:1 conversations (group chats are excluded).
+ * `sinceMinutes` is the lookback window in minutes.
+ */
+function listInboundSenders(sinceMinutes) {
+    const cutoffNs = unixMsToAppleNs(Date.now() - sinceMinutes * 60000);
+    const db = openDb();
+    try {
+        const rows = db
+            .prepare(`SELECT h.id AS sender, COUNT(*) AS cnt, MAX(m.date) AS latest
+         FROM message m
+         JOIN handle h ON m.handle_id = h.ROWID
+         JOIN chat_message_join cmj ON cmj.message_id = m.ROWID
+         WHERE m.is_from_me = 0 AND m.date > ?
+           AND cmj.chat_id IN (${DIRECT_CHATS_SQL})
+         GROUP BY h.id
+         ORDER BY latest DESC`)
+            .all(cutoffNs);
+        return rows.map((r) => ({
+            sender: r.sender,
+            message_count: r.cnt,
+            latest_at: appleNsToDate(r.latest).toISOString(),
+        }));
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Return actual message TEXT for ONE sender's 1:1 conversation in the window —
+ * BOTH directions (the sender's inbound messages AND the user's outbound replies),
+ * in chronological order, each tagged with its direction.
+ *
+ * Scoping is by CHAT, not by handle_id: we find the 1:1 chat(s) whose sole
+ * participant is `sender`, then return every message in those chats. This is
+ * deliberate — in a real chat.db, OUTBOUND messages have handle_id = 0 (they
+ * are NOT tagged with the recipient's handle), so a handle-only join would
+ * silently drop the user's own replies. Joining via the chat captures both sides
+ * correctly and keeps group-chat traffic out.
+ *
+ * Caller MUST have verified the sender is approved before calling this.
+ */
+function readMessagesFrom(sender, sinceMinutes) {
+    const cutoffNs = unixMsToAppleNs(Date.now() - sinceMinutes * 60000);
+    const db = openDb();
+    try {
+        const rows = db
+            .prepare(`SELECT m.date AS date, m.text AS text, m.is_from_me AS is_from_me
+         FROM message m
+         JOIN chat_message_join cmj ON cmj.message_id = m.ROWID
+         WHERE cmj.chat_id IN (
+                 SELECT chj.chat_id
+                 FROM chat_handle_join chj
+                 JOIN handle h ON h.ROWID = chj.handle_id
+                 WHERE chj.chat_id IN (${DIRECT_CHATS_SQL})
+                   AND h.id = ?
+               )
+           AND m.date > ? AND m.text IS NOT NULL
+         ORDER BY m.date ASC`)
+            .all(sender, cutoffNs);
+        return rows.map((r) => {
+            const fromMe = r.is_from_me === 1;
+            return {
+                date: appleNsToDate(r.date).toISOString(),
+                text: r.text,
+                from_me: fromMe,
+                direction: fromMe ? 'outgoing' : 'incoming',
+            };
+        });
+    }
+    finally {
+        db.close();
+    }
+}