@chronicle.app/imessage 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrew Louis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# @chronicle.app/imessage
+
+Read `chat.db` with `ImessageExtractor`, then emit MessageAction/Message records with `ImessageTransformer`. `input` defaults to the macOS Messages database; use a consistent backup for exported data. The connection is read-only via built-in `node:sqlite`. Date windows are exclusive, records newest-first, and `limit: 0` means unlimited.
+
+Automatic iCloud account and AddressBook enrichment comes from `@chronicle.app/icloud`. `includeContactNames: false` skips contacts. An explicit `account` object (or null) lets callers describe exported data without host account lookup. Transformer config can inject `lookupContact` for exported contacts. Missing permissions/account/contact data fall back to source-local identity and unlabelled participants.
+
+Attachments are local file references with MIME metadata, not copied bytes. Missing files are skipped. Attributed-body decoding retains the existing heuristic; it is not a complete typedstream decoder. Raw records preserve the source blob, and large integer timestamps are decimal strings so serialization is safe.
+
+Tests use synthetic Messages and AddressBook databases, account command fixtures, and temporary attachment files. They do not read personal messages or contacts.

package/dist/connectors/ImessageExtractor.d.ts

@@ -0,0 +1,19 @@
+import { Record } from '@chronicle.app/etl';
+import { SqliteExtractor } from '@chronicle.app/etl-sqlite';
+import ImessageTransformer from './ImessageTransformer.js';
+export declare class ImessageExtractor extends SqliteExtractor<typeof ImessageExtractor> {
+    static recordTypes: string[];
+    static source: string;
+    static description: string;
+    static delivery: "local";
+    static strategy: string;
+    static default: boolean;
+    static schema: any;
+    static defaultTransformer: typeof ImessageTransformer;
+    extract(): AsyncGenerator<Record>;
+    private queryMessages;
+    private loadChats;
+    private loadAttachments;
+    private processAttributedBody;
+}
+//# sourceMappingURL=ImessageExtractor.d.ts.map

package/dist/connectors/ImessageExtractor.js

@@ -0,0 +1,177 @@
+import { SqliteExtractor, iosToUnixTimestamp, timeRangeConditions, APPLE_EPOCH_OFFSET_SECONDS, } from '@chronicle.app/etl-sqlite';
+import { getICloudAccount } from '@chronicle.app/icloud';
+import ImessageTransformer from './ImessageTransformer.js';
+import { z } from 'zod';
+export class ImessageExtractor extends SqliteExtractor {
+    static recordTypes = ['messages'];
+    static source = 'imessage';
+    static description = 'Messages and attachments from chat.db';
+    static delivery = 'local';
+    static strategy = 'app-db';
+    static default = true;
+    static schema = SqliteExtractor.schema.omit({ input: true }).extend({
+        input: z
+            .string()
+            .default(`${process.env.HOME}/Library/Messages/chat.db`)
+            .describe('The path to the iMessage sqlite database'),
+        includeContactNames: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe('Include contact names from AddressBook (default: true)'),
+        account: z
+            .object({
+            accountID: z.string(),
+            email: z.string(),
+            displayName: z.string(),
+            dsid: z.string().optional(),
+        })
+            .nullable()
+            .optional(),
+    });
+    static defaultTransformer = ImessageTransformer;
+    async *extract() {
+        const chats = this.loadChats();
+        const rows = this.queryMessages();
+        const attachments = this.loadAttachments();
+        // Get real iCloud account info automatically
+        const realIcloudAccount = this.config.account === undefined ? await getICloudAccount() : this.config.account;
+        for (const row of rows) {
+            const attributedBody = this.processAttributedBody(row.attributedBody);
+            const timestamp = iosToUnixTimestamp(Number.parseInt(row.date, 10));
+            const participants = chats[row.chat_id] || [];
+            const messageAttachments = attachments[row.ROWID] || [];
+            yield this.createRecord(row, {
+                attributedBody,
+                timestamp,
+                messageId: row.ROWID,
+                guid: row.guid,
+                service: row.service,
+                isFromMe: row.is_from_me,
+                handleId: row.handle_id,
+                handleIdText: row.handle_id_text,
+                participants,
+                attachments: messageAttachments,
+                myIcloudAccount: realIcloudAccount,
+                includeContactNames: this.config.includeContactNames,
+            });
+        }
+    }
+    queryMessages() {
+        let sql = `
+      SELECT
+        m.ROWID, m.guid, m.text, m.service, m.date, m.is_from_me, m.handle_id,
+        m.attributedBody, h.id as handle_id_text, h.service as handle_service,
+        cm.chat_id
+      FROM
+        message AS m
+        LEFT OUTER JOIN handle AS h ON m.handle_id = h.ROWID
+        INNER JOIN chat_message_join AS cm ON m.ROWID = cm.message_id`;
+        // chat.db stores message.date as nanoseconds since the Apple epoch
+        const { conditions, values } = timeRangeConditions('m.date', this.config, {
+            convert: date => (BigInt(date.getTime()) * 1000000n -
+                BigInt(APPLE_EPOCH_OFFSET_SECONDS) * 1000000000n).toString(),
+        });
+        if (conditions.length > 0) {
+            sql += ` WHERE ${conditions.join(' AND ')}`;
+        }
+        sql += ` ORDER BY m.date DESC`;
+        const effectiveLimit = this.getEffectiveLimit();
+        if (effectiveLimit !== null) {
+            sql += ` LIMIT ?`;
+            values.push(effectiveLimit);
+        }
+        const stmt = this.db.prepare(sql);
+        stmt.setReadBigInts(true);
+        return stmt
+            .all(...values)
+            .map(row => Object.fromEntries(Object.entries(row).map(([key, value]) => [
+            key,
+            typeof value === 'bigint'
+                ? key === 'date' || value > BigInt(Number.MAX_SAFE_INTEGER)
+                    ? value.toString()
+                    : Number(value)
+                : value,
+        ])));
+    }
+    loadChats() {
+        const sql = `
+      SELECT ch.chat_id, h.ROWID as handle_rowid, h.id, h.service as handle_service
+      FROM chat_handle_join AS ch
+      INNER JOIN handle AS h ON ch.handle_id = h.ROWID
+      INNER JOIN chat AS c ON ch.chat_id = c.ROWID
+    `;
+        const stmt = this.db.prepare(sql);
+        const results = stmt.all();
+        // Group handles by chat_id
+        const chats = {};
+        for (const row of results) {
+            const chatId = row.chat_id;
+            if (!chats[chatId]) {
+                chats[chatId] = [];
+            }
+            chats[chatId].push({
+                handleRowid: row.handle_rowid,
+                id: row.id,
+                service: row.handle_service,
+            });
+        }
+        return chats;
+    }
+    loadAttachments() {
+        const sql = `
+      SELECT 
+        maj.message_id,
+        a.ROWID as attachment_id,
+        a.guid,
+        a.filename,
+        a.mime_type,
+        a.uti,
+        a.total_bytes,
+        a.transfer_name,
+        a.is_outgoing
+      FROM message_attachment_join AS maj
+      INNER JOIN attachment AS a ON maj.attachment_id = a.ROWID
+      WHERE a.filename IS NOT NULL
+    `;
+        const stmt = this.db.prepare(sql);
+        const results = stmt.all();
+        // Group attachments by message_id
+        const attachments = {};
+        for (const row of results) {
+            const messageId = row.message_id;
+            if (!attachments[messageId]) {
+                attachments[messageId] = [];
+            }
+            attachments[messageId].push({
+                attachmentId: row.attachment_id,
+                guid: row.guid,
+                filename: row.filename,
+                mimeType: row.mime_type,
+                uti: row.uti,
+                totalBytes: row.total_bytes,
+                transferName: row.transfer_name,
+                isOutgoing: row.is_outgoing,
+            });
+        }
+        return attachments;
+    }
+    processAttributedBody(attributedBody) {
+        if (!attributedBody)
+            return '';
+        attributedBody = (typeof attributedBody === 'string'
+            ? Buffer.from(attributedBody, 'binary')
+            : Buffer.from(attributedBody)).toString('utf8');
+        if (attributedBody.includes('NSNumber')) {
+            attributedBody = attributedBody.split('NSNumber')[0];
+            if (attributedBody.includes('NSString')) {
+                attributedBody = attributedBody.split('NSString')[1];
+                if (attributedBody.includes('NSDictionary')) {
+                    attributedBody = attributedBody.split('NSDictionary')[0];
+                    attributedBody = attributedBody.slice(6, -12);
+                }
+            }
+        }
+        return attributedBody;
+    }
+}

package/dist/connectors/ImessageTransformer.d.ts

@@ -0,0 +1,43 @@
+import { ChronicleTransformer, Record } from '@chronicle.app/etl';
+import { ActionAndChildren } from '@chronicle.app/schema';
+export default class ImessageTransformer extends ChronicleTransformer {
+    static source: string;
+    transform(record: Record): Promise<ActionAndChildren[]>;
+    private buildMessageAction;
+    private buildMessage;
+    private buildParticipants;
+    /**
+     * One chat participant as an Agent in the service's identity namespace
+     * (`icloud` for iMessage, `phone` for SMS), keyed on the handle exactly as
+     * chat.db stores it — an email address or a phone number; no sourceId, since
+     * the database carries no DSID. Linked by `sameAs` to the email identities the
+     * same handle is known by, so the participant collapses with the person the
+     * email plugin saw.
+     */
+    private buildParticipantAgent;
+    /**
+     * The `email`-namespace identities this participant is: the handle itself when
+     * it is an email address (iMessage addresses people by their iCloud email),
+     * plus every email on the AddressBook card the handle resolves to when contact
+     * lookup is on. Each is a full entity-reference node keyed the way the email
+     * plugin keys its own agents — `Agent` / `email` / the address as written, no
+     * case folding on either side — so the fold merges the two through the shared
+     * keyset. Only identifiers the source actually carries; one address spelled
+     * more than once keeps its first spelling.
+     */
+    private emailIdentities;
+    private buildMyIdentity;
+    private buildMyPhoneIdentity;
+    private determineAgentAndRecipients;
+    private getServiceSource;
+    private getAgentSource;
+    private normalizedBody;
+    private processAttachments;
+    private getMimeTypeFromExtension;
+    /** First 16 bytes of a file — enough for every signature in sniffMimeType. */
+    private readLeadingBytes;
+    /** Last-resort detection from magic bytes (e.g. rich-link previews with dyn.* UTIs). */
+    private sniffMimeType;
+    private resolveAttachmentPath;
+}
+//# sourceMappingURL=ImessageTransformer.d.ts.map

package/dist/connectors/ImessageTransformer.js

@@ -0,0 +1,321 @@
+import { ChronicleTransformer, normalizePhoneNumber, createMediaObject, } from '@chronicle.app/etl';
+import { lookupContact, buildICloudPersonSchema } from '@chronicle.app/icloud';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export default class ImessageTransformer extends ChronicleTransformer {
+    static source = 'imessage';
+    async transform(record) {
+        const actions = [];
+        if (record.extraction.recordType === 'messages') {
+            actions.push(...(await this.buildMessageAction(record)));
+        }
+        return actions;
+    }
+    async buildMessageAction(record) {
+        const service = this.getServiceSource(record.context.service);
+        const participants = this.buildParticipants(record);
+        const myIdentity = await this.buildMyIdentity(record);
+        const { agent, recipients } = this.determineAgentAndRecipients(record, participants, myIdentity);
+        const obj = {
+            '@type': 'MessageAction',
+            timestamp: new Date(record.context.timestamp),
+            source: service,
+            sourceId: record.context.guid, // Use GUID instead of ROWID
+            '@key': ['source', 'sourceId', '@type'],
+            object: this.buildMessage(record, recipients),
+            agent,
+        };
+        return [obj];
+    }
+    buildMessage(record, recipients) {
+        const messageSource = this.getServiceSource(record.context.service);
+        const message = {
+            '@type': 'Message',
+            '@key': ['@type', 'source', 'sourceId'],
+            source: messageSource, // Use service-based source (sms or imessage)
+            sourceId: record.context.guid, // Use GUID for message identity
+            body: this.normalizedBody(record),
+        };
+        // Add recipients if available
+        if (recipients.length > 0) {
+            message.recipient = recipients;
+        }
+        // Add attachments using contains property (following Bluesky pattern)
+        const attachments = record.context.attachments || [];
+        if (attachments.length > 0) {
+            message.contains = this.processAttachments(attachments);
+        }
+        return message;
+    }
+    buildParticipants(record) {
+        const agentSource = this.getAgentSource(record.context.service);
+        const chatParticipants = record.context.participants || [];
+        return chatParticipants.map(participant => this.buildParticipantAgent(record, agentSource, participant.id));
+    }
+    /**
+     * One chat participant as an Agent in the service's identity namespace
+     * (`icloud` for iMessage, `phone` for SMS), keyed on the handle exactly as
+     * chat.db stores it — an email address or a phone number; no sourceId, since
+     * the database carries no DSID. Linked by `sameAs` to the email identities the
+     * same handle is known by, so the participant collapses with the person the
+     * email plugin saw.
+     */
+    buildParticipantAgent(record, agentSource, handle) {
+        const contact = record.context.includeContactNames
+            ? (this.config.lookupContact ?? lookupContact)(handle)
+            : null;
+        const sameAs = this.emailIdentities(handle, contact);
+        return {
+            '@type': 'Agent',
+            source: agentSource,
+            handle,
+            name: contact?.fullName,
+            '@key': ['@type', 'source', 'handle'],
+            ...(sameAs.length > 0 ? { sameAs } : {}),
+        };
+    }
+    /**
+     * The `email`-namespace identities this participant is: the handle itself when
+     * it is an email address (iMessage addresses people by their iCloud email),
+     * plus every email on the AddressBook card the handle resolves to when contact
+     * lookup is on. Each is a full entity-reference node keyed the way the email
+     * plugin keys its own agents — `Agent` / `email` / the address as written, no
+     * case folding on either side — so the fold merges the two through the shared
+     * keyset. Only identifiers the source actually carries; one address spelled
+     * more than once keeps its first spelling.
+     */
+    emailIdentities(handle, contact) {
+        const candidates = [...(handle.includes('@') ? [handle] : []), ...(contact?.emails ?? [])];
+        const seen = new Set();
+        const emails = [];
+        for (const email of candidates) {
+            const key = email.trim().toLowerCase();
+            if (!key || seen.has(key))
+                continue;
+            seen.add(key);
+            emails.push(email);
+        }
+        return emails.map(email => ({
+            '@type': 'Agent',
+            source: 'email',
+            handle: email,
+            '@key': ['@type', 'source', 'handle'],
+        }));
+    }
+    async buildMyIdentity(record) {
+        const { service } = record.context;
+        const agentSource = this.getAgentSource(service);
+        const identity = agentSource === 'icloud'
+            ? (await buildICloudPersonSchema(record.context.myIcloudAccount))
+            : this.buildMyPhoneIdentity(record);
+        // Tag the account owner as self. The iCloud branch (buildICloudPersonSchema)
+        // already self-tags, so add `@me` only when it isn't already present.
+        const sameAs = identity?.sameAs ?? [];
+        return { ...identity, sameAs: sameAs.includes('@me') ? sameAs : [...sameAs, '@me'] };
+    }
+    buildMyPhoneIdentity(record) {
+        // Try to find my phone number by matching my iCloud email in AddressBook
+        if (record?.context?.myIcloudAccount?.email && record?.context?.includeContactNames) {
+            const myContact = (this.config.lookupContact ?? lookupContact)(record.context.myIcloudAccount.email);
+            if (myContact?.phoneNumbers && myContact.phoneNumbers.length > 0) {
+                // Found my contact with phone numbers - use the first one (normalized)
+                const normalizedPhone = normalizePhoneNumber(myContact.phoneNumbers[0]);
+                if (normalizedPhone) {
+                    return {
+                        '@type': 'Person',
+                        source: 'phone',
+                        handle: normalizedPhone,
+                        '@key': ['@type', 'source', 'handle'],
+                    };
+                }
+            }
+        }
+        // Fallback when we can't determine my phone number
+        // Still need a unique identifier - use iCloud email as fallback handle
+        const fallbackHandle = record?.context?.myIcloudAccount?.email;
+        if (fallbackHandle) {
+            return {
+                '@type': 'Person',
+                source: 'phone',
+                handle: fallbackHandle, // Use iCloud email as unique identifier
+                '@key': ['@type', 'source', 'handle'],
+            };
+        }
+        // Last resort - no unique info available
+        return {
+            '@type': 'Person',
+            source: 'phone',
+            '@key': ['@type', 'source'],
+        };
+    }
+    determineAgentAndRecipients(record, participants, myIdentity) {
+        const isFromMe = record.context.isFromMe === 1;
+        if (isFromMe) {
+            // I sent the message - I'm the agent, everyone else are recipients
+            const recipients = myIdentity.handle
+                ? participants.filter(p => p.handle !== myIdentity.handle)
+                : participants; // If I have no handle (SMS fallback), all participants are recipients
+            return {
+                agent: myIdentity,
+                recipients,
+            };
+        }
+        // Someone else sent the message - find them as agent, I'm a recipient
+        const { handleIdText } = record.context;
+        const agent = participants.find(p => p.handle === handleIdText);
+        if (!agent) {
+            // The sender is not among the chat's participants: build them from the
+            // message's own handle, the same way as any other participant.
+            const agentSource = this.getAgentSource(record.context.service);
+            return {
+                agent: this.buildParticipantAgent(record, agentSource, handleIdText),
+                recipients: [myIdentity],
+            };
+        }
+        return {
+            agent,
+            recipients: [...participants.filter(p => p.handle !== agent.handle), myIdentity],
+        };
+    }
+    getServiceSource(_service) {
+        // All messages come from iMessage database, so use imessage source regardless of service type
+        return 'imessage';
+    }
+    getAgentSource(service) {
+        // For Person source - differentiates identity systems
+        switch (service?.toLowerCase()) {
+            case 'sms':
+                return 'phone';
+            case 'imessage':
+            default:
+                return 'icloud';
+        }
+    }
+    normalizedBody(record) {
+        // Use text field first, fallback to processed attributedBody
+        return record.data.text || record.context.attributedBody || '';
+    }
+    processAttachments(attachments) {
+        const mediaObjects = [];
+        for (const attachment of attachments) {
+            try {
+                const filePath = this.resolveAttachmentPath(attachment.filename);
+                // Check if file exists
+                if (!fs.existsSync(filePath)) {
+                    console.warn(`Attachment file not found: ${filePath}`);
+                    continue;
+                }
+                // MIME drives the media object @type (ImageObject vs DocumentObject…).
+                // chat.db's mime_type is NULL for some transfers (dynamic UTIs like
+                // rich-link previews), so fall back to extension, then magic bytes.
+                const mimeType = attachment.mimeType ||
+                    this.getMimeTypeFromExtension(filePath) ||
+                    this.sniffMimeType(this.readLeadingBytes(filePath)) ||
+                    'application/octet-stream';
+                // Reference the file by path; ingest reads the bytes into the
+                // attachment store — no base64 inflation through the pipeline.
+                const mediaObject = createMediaObject({
+                    path: filePath,
+                    mimeType,
+                    description: attachment.transferName || path.basename(attachment.filename),
+                });
+                // Add iMessage attachment GUID for deduplication
+                mediaObject.sourceId = attachment.guid;
+                mediaObject.source = 'imessage';
+                mediaObject['@key'] = ['source', 'sourceId'];
+                mediaObjects.push(mediaObject);
+            }
+            catch (error) {
+                console.warn(`Failed to process attachment ${attachment.filename}:`, error);
+            }
+        }
+        return mediaObjects;
+    }
+    getMimeTypeFromExtension(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const mimeTypes = {
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.webp': 'image/webp',
+            '.heic': 'image/heic',
+            '.heif': 'image/heif',
+            '.tiff': 'image/tiff',
+            '.tif': 'image/tiff',
+            '.ico': 'image/x-icon',
+            '.mp4': 'video/mp4',
+            '.mov': 'video/quicktime',
+            '.avi': 'video/x-msvideo',
+            '.3gp': 'video/3gpp',
+            '.mp3': 'audio/mpeg',
+            '.wav': 'audio/wav',
+            '.m4a': 'audio/mp4',
+            '.caf': 'audio/x-caf',
+            '.amr': 'audio/amr',
+            '.pdf': 'application/pdf',
+            '.vcf': 'text/vcard',
+        };
+        return mimeTypes[ext];
+    }
+    /** First 16 bytes of a file — enough for every signature in sniffMimeType. */
+    readLeadingBytes(filePath) {
+        const buf = Buffer.alloc(16);
+        const fd = fs.openSync(filePath, 'r');
+        try {
+            const n = fs.readSync(fd, buf, 0, 16, 0);
+            return buf.subarray(0, n);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    /** Last-resort detection from magic bytes (e.g. rich-link previews with dyn.* UTIs). */
+    sniffMimeType(bytes) {
+        const ascii = (start, text) => bytes.length >= start + text.length &&
+            bytes.toString('latin1', start, start + text.length) === text;
+        if (bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff)
+            return 'image/jpeg';
+        if (bytes.length >= 4 && bytes[0] === 0x89 && ascii(1, 'PNG'))
+            return 'image/png';
+        if (ascii(0, 'GIF8'))
+            return 'image/gif';
+        if (ascii(0, 'RIFF') && ascii(8, 'WEBP'))
+            return 'image/webp';
+        if (ascii(0, 'RIFF') && ascii(8, 'WAVE'))
+            return 'audio/wav';
+        if (ascii(4, 'ftypheic') || ascii(4, 'ftypheix') || ascii(4, 'ftypmif1'))
+            return 'image/heic';
+        if (ascii(4, 'ftypqt'))
+            return 'video/quicktime';
+        if (ascii(4, 'ftypM4A'))
+            return 'audio/mp4';
+        if (ascii(4, 'ftyp'))
+            return 'video/mp4';
+        if (ascii(0, '%PDF'))
+            return 'application/pdf';
+        if (ascii(0, 'ID3'))
+            return 'audio/mpeg';
+        if (ascii(0, 'caff'))
+            return 'audio/x-caf';
+        if (ascii(0, '#!AMR'))
+            return 'audio/amr';
+        if (bytes.length >= 4 && bytes[0] === 0 && bytes[1] === 0 && bytes[2] === 1 && bytes[3] === 0)
+            return 'image/x-icon';
+        return undefined;
+    }
+    resolveAttachmentPath(filename) {
+        // iMessage filename field contains paths like ~/Library/Messages/Attachments/...
+        // Need to expand the ~ to the actual home directory
+        if (filename.startsWith('~/')) {
+            return path.join(process.env.HOME || '', filename.slice(2));
+        }
+        // If it's already an absolute path, use as-is
+        if (path.isAbsolute(filename)) {
+            return filename;
+        }
+        // Handle relative paths by prepending the standard iMessage attachments directory
+        const attachmentsDir = path.join(process.env.HOME || '', 'Library', 'Messages', 'Attachments');
+        return path.join(attachmentsDir, filename);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { ImessageExtractor } from './connectors/ImessageExtractor.js';
+export { default as ImessageTransformer } from './connectors/ImessageTransformer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,3 @@
+// Export extractors for plugin scanning
+export { ImessageExtractor } from './connectors/ImessageExtractor.js';
+export { default as ImessageTransformer } from './connectors/ImessageTransformer.js';

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@chronicle.app/imessage",
+  "version": "0.1.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc -b tsconfig.lib.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "lint": "eslint src --ext .ts,.js",
+    "test": "node --test src/*.test.js"
+  },
+  "keywords": [],
+  "author": "Andrew Louis",
+  "license": "MIT",
+  "type": "module",
+  "description": "Chronicle imessage extraction plugin",
+  "devDependencies": {
+    "@chronicle.app/tsconfig": "0.1.0",
+    "@types/node": "^22.10.1",
+    "typescript": "^5.7.2"
+  },
+  "homepage": "https://chronicle.app",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chronicle-app/chronicle.git",
+    "directory": "plugins/imessage"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@chronicle.app/etl": "0.1.0",
+    "@chronicle.app/schema": "0.1.0",
+    "zod": "^3.24.1",
+    "@chronicle.app/etl-sqlite": "0.1.0",
+    "@chronicle.app/icloud": "0.1.0"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "chronicle": {
+    "plugin": true
+  },
+  "oclif": {}
+}