@kingcrab/pi-imessage 0.0.42 → 1.0.0

package/dist/transport/attachments.js

@@ -0,0 +1,37 @@
+import { execFile } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { access, copyFile, mkdir, readFile, rename, rm } from "node:fs/promises";
+import { extname, join } from "node:path";
+import { promisify } from "node:util";
+const execute = promisify(execFile);
+export async function archiveAttachments(workingDir, chatGuid, paths) {
+    const directory = join(workingDir, "attachments", encodeURIComponent(chatGuid));
+    await mkdir(directory, { recursive: true });
+    const result = [];
+    for (const source of paths) {
+        const hash = createHash("sha256")
+            .update(await readFile(source))
+            .digest("hex");
+        const extension = extname(source).toLowerCase();
+        const heic = [".heic", ".heif"].includes(extension);
+        const destination = join(directory, hash + (heic ? ".jpg" : extension));
+        try {
+            await access(destination);
+        }
+        catch {
+            const temporary = `${destination}.${randomUUID()}`;
+            try {
+                if (heic)
+                    await execute("/usr/bin/sips", ["-s", "format", "jpeg", source, "--out", temporary]);
+                else
+                    await copyFile(source, temporary);
+                await rename(temporary, destination);
+            }
+            finally {
+                await rm(temporary, { force: true });
+            }
+        }
+        result.push(destination);
+    }
+    return result;
+}

package/dist/transport/http.js

@@ -0,0 +1,110 @@
+import { EventEmitter } from "node:events";
+import { Client, EnvHttpProxyAgent, getGlobalDispatcher, install, Pool, setGlobalDispatcher, } from "undici";
+const initialFetch = globalThis.fetch;
+const fetchGlobals = [
+    "fetch",
+    "Headers",
+    "Response",
+    "Request",
+    "FormData",
+    "WebSocket",
+    "CloseEvent",
+    "ErrorEvent",
+    "MessageEvent",
+    "EventSource",
+];
+let processOwned = false;
+// A terminated body still rejects its reader. Avoid an unhandled Client error crashing the process.
+function listenForClientErrors(dispatcher) {
+    EventEmitter.prototype.on.call(dispatcher, "error", () => { });
+    return dispatcher;
+}
+function createClient(origin, options) {
+    return listenForClientErrors(new Client(origin, options));
+}
+/** One process owner; settings are defaults beneath explicit environment proxy values. */
+export function openHttpTransport(settings) {
+    if (processOwned)
+        throw new Error("HTTP transport already has a process owner");
+    const previousDispatcher = getGlobalDispatcher();
+    const globals = [];
+    const retiring = new Set();
+    let retirementError;
+    let current;
+    let closing;
+    function retire(dispatcher) {
+        const pending = dispatcher
+            .close()
+            .catch((error) => {
+            retirementError ??= error;
+        })
+            .finally(() => retiring.delete(pending));
+        retiring.add(pending);
+    }
+    function reload(next) {
+        if (closing)
+            throw new Error("HTTP transport is closed");
+        if (current && getGlobalDispatcher() !== current)
+            throw new Error("HTTP dispatcher ownership changed; refusing to replace another caller's transport");
+        if (!Number.isFinite(next.idleTimeoutMs) || next.idleTimeoutMs < 0)
+            throw new Error("Invalid HTTP idle timeout");
+        const proxy = next.proxy?.trim() || undefined;
+        const dispatcher = listenForClientErrors(new EnvHttpProxyAgent({
+            httpProxy: process.env.http_proxy ?? process.env.HTTP_PROXY ?? proxy ?? "",
+            httpsProxy: process.env.https_proxy ?? process.env.HTTPS_PROXY ?? proxy ?? "",
+            noProxy: process.env.no_proxy ?? process.env.NO_PROXY ?? "",
+            allowH2: false,
+            proxyTunnel: true,
+            headersTimeout: Math.floor(next.idleTimeoutMs),
+            bodyTimeout: Math.floor(next.idleTimeoutMs),
+            connect: { autoSelectFamilyAttemptTimeout: 2000 },
+            clientFactory: createClient,
+            factory: (origin, options) => options.connections === 1
+                ? createClient(origin, options)
+                : listenForClientErrors(new Pool(origin, { ...options, factory: createClient })),
+        }));
+        setGlobalDispatcher(dispatcher);
+        const previous = current;
+        current = dispatcher;
+        if (previous)
+            retire(previous); // close drains active requests; it does not abort them.
+    }
+    reload(settings);
+    processOwned = true;
+    // Match fetch and its constructors to the dispatcher, but preserve a deliberate fetch override.
+    if (globalThis.fetch === initialFetch) {
+        for (const name of fetchGlobals)
+            globals.push({ name, previous: Object.getOwnPropertyDescriptor(globalThis, name) });
+        install();
+        for (const entry of globals)
+            entry.installed = Object.getOwnPropertyDescriptor(globalThis, entry.name);
+    }
+    return {
+        reload,
+        close() {
+            closing ??= (async () => {
+                if (getGlobalDispatcher() === current)
+                    setGlobalDispatcher(previousDispatcher);
+                for (const entry of globals) {
+                    if (Object.getOwnPropertyDescriptor(globalThis, entry.name)?.value !== entry.installed?.value)
+                        continue;
+                    if (entry.previous)
+                        Object.defineProperty(globalThis, entry.name, entry.previous);
+                    else
+                        Reflect.deleteProperty(globalThis, entry.name);
+                }
+                if (current)
+                    retire(current);
+                try {
+                    await Promise.all(retiring);
+                    if (retirementError)
+                        throw new Error("HTTP transport cleanup failed", { cause: retirementError });
+                }
+                finally {
+                    processOwned = false;
+                }
+            })();
+            return closing;
+        },
+    };
+}

package/dist/{rich-text.js → transport/rich-text.js}

@@ -104,7 +104,12 @@ function parseMarkdownToSpans(markdown) {
     for (const match of markdown.matchAll(pattern)) {
         const index = match.index ?? 0;
         if (index > lastIndex) {
-            spans.push({ text: markdown.slice(lastIndex, index), bold: false, italic: false, strikethrough: false });
+            spans.push({
+                text: markdown.slice(lastIndex, index),
+                bold: false,
+                italic: false,
+                strikethrough: false,
+            });
         }
         const token = match[0];
         if (token.startsWith("**") && token.endsWith("**")) {
@@ -163,16 +168,23 @@ async function copyRichTextToClipboard(text, options) {
         await rm(dir, { recursive: true, force: true });
     }
 }
-export async function sendRichTextMessage(chatGuid, text, options) {
-    const parts = chatGuid.split(";");
-    const isGroup = parts[1] === "+";
-    if (isGroup) {
-        throw new Error("Rich-text sending is currently only supported for direct-message chats");
-    }
-    const recipient = recipientFromChatGuid(chatGuid);
-    await copyRichTextToClipboard(text, options);
-    await openConversation(recipient);
-    await pasteAndSend();
-    console.log(`[send] sent rich text to ${chatGuid}: "${text.substring(0, 60)}"`);
+// The pasteboard and frontmost conversation are process-wide, not per chat.
+let pendingSend = Promise.resolve();
+export function sendRichTextMessage(chatGuid, text, options) {
+    const resolvedOptions = { ...DEFAULT_RICH_TEXT_OPTIONS, ...options };
+    const operation = pendingSend.then(async () => {
+        const parts = chatGuid.split(";");
+        const isGroup = parts[1] === "+";
+        if (isGroup) {
+            throw new Error("Rich-text sending is currently only supported for direct-message chats");
+        }
+        const recipient = recipientFromChatGuid(chatGuid);
+        await copyRichTextToClipboard(text, resolvedOptions);
+        await openConversation(recipient);
+        await pasteAndSend();
+        console.log(`[send] sent rich text to ${chatGuid}: "${text.substring(0, 60)}"`);
+    });
+    // Release the transport turn on failure, without retrying a possibly completed send.
+    pendingSend = operation.catch(() => { });
+    return operation;
 }
-//# sourceMappingURL=rich-text.js.map

package/dist/{send.js → transport/send.js}

@@ -15,7 +15,7 @@
  */
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { constants, accessSync } from "node:fs";
+import { accessSync, constants } from "node:fs";
 import { copyFile, mkdir, unlink } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, extname, join } from "node:path";
@@ -26,8 +26,6 @@ const SCRIPT_TIMEOUT_MS = 30_000;
 const ATTACHMENT_VERIFY_TIMEOUT_MS = 30_000;
 const ATTACHMENT_VERIFY_POLL_MS = 500;
 const MESSAGES_APP_PATH = "/System/Applications/Messages.app";
-const ATTACHMENTS_ROOT = join(homedir(), "Library", "Messages", "Attachments");
-const STAGING_DIR = join(ATTACHMENTS_ROOT, "pi-imessage");
 const CHAT_DB_PATH = join(homedir(), "Library", "Messages", "chat.db");
 // ── AppleScript helpers ───────────────────────────────────────────────────────
 /** Escape special characters for AppleScript string literals. */
@@ -94,17 +92,18 @@ end tell`;
  *
  * Returns the staged path; caller is responsible for cleanup after send.
  */
-async function stageAttachment(sourcePath) {
+async function stageAttachment(sourcePath, attachmentsRoot) {
     // If the source is already inside the Attachments root, imagent can read it.
-    if (sourcePath.startsWith(`${ATTACHMENTS_ROOT}/`)) {
+    if (sourcePath.startsWith(`${attachmentsRoot}/`)) {
         return { stagedPath: sourcePath, cleanup: async () => { } };
     }
-    await mkdir(STAGING_DIR, { recursive: true, mode: 0o755 });
+    const stagingDirectory = join(attachmentsRoot, "pi-imessage");
+    await mkdir(stagingDirectory, { recursive: true, mode: 0o755 });
     const ext = extname(sourcePath);
     const base = basename(sourcePath, ext)
         .replace(/[^A-Za-z0-9._-]/g, "_")
         .slice(0, 40);
-    const stagedPath = join(STAGING_DIR, `${Date.now()}-${randomUUID().slice(0, 8)}-${base}${ext}`);
+    const stagedPath = join(stagingDirectory, `${Date.now()}-${randomUUID().slice(0, 8)}-${base}${ext}`);
     await copyFile(sourcePath, stagedPath);
     return {
         stagedPath,
@@ -119,7 +118,7 @@ async function stageAttachment(sourcePath) {
     };
 }
 /** Poll chat.db until the staged attachment finishes transferring (or times out). */
-async function verifyAttachmentSent(stagedPath, timeoutMs) {
+async function verifyAttachmentSent(stagedPath, timeoutMs, dbPath) {
     const stagedBase = basename(stagedPath);
     // filename in chat.db can be stored as absolute path or "~/Library/Messages/Attachments/...",
     // so match on the unique basename we generated (Date.now() + UUID prefix).
@@ -134,7 +133,7 @@ async function verifyAttachmentSent(stagedPath, timeoutMs) {
     let last = { attachmentId: null, transferState: null, isSent: null, error: null };
     while (Date.now() < deadline) {
         try {
-            const { stdout } = await execFileAsync("sqlite3", ["-json", CHAT_DB_PATH, sql], { timeout: 5_000 });
+            const { stdout } = await execFileAsync("sqlite3", ["-json", dbPath, sql], { timeout: 5_000 });
             const rows = stdout.trim() ? JSON.parse(stdout) : [];
             const row = rows[0];
             if (row) {
@@ -221,7 +220,9 @@ end tell`;
         console.warn(`[send] failed to check iMessage status; continuing so the watchdog can diagnose send failures: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-export function createMessageSender() {
+export function createMessageSender(options = {}) {
+    const attachmentsRoot = options.attachmentsRoot ?? join(homedir(), "Library", "Messages", "Attachments");
+    const dbPath = options.dbPath ?? CHAT_DB_PATH;
     return {
         async sendMessage(chatGuid, text, richText) {
             const startTime = Date.now();
@@ -241,7 +242,7 @@ export function createMessageSender() {
             accessSync(filePath, constants.R_OK);
             const origName = basename(filePath);
             console.log(`[send] start: ${chatGuid} mode=attachment file=${origName}`);
-            const { stagedPath, cleanup } = await stageAttachment(filePath);
+            const { stagedPath, cleanup } = await stageAttachment(filePath, attachmentsRoot);
             const staged = stagedPath !== filePath;
             if (staged) {
                 console.log(`[send] staged attachment for imagent: ${basename(stagedPath)}`);
@@ -249,7 +250,7 @@ export function createMessageSender() {
             try {
                 const script = buildSendAttachmentScript(chatGuid, stagedPath);
                 await execFileAsync("osascript", ["-e", script], { timeout: SCRIPT_TIMEOUT_MS });
-                const status = await verifyAttachmentSent(stagedPath, ATTACHMENT_VERIFY_TIMEOUT_MS);
+                const status = await verifyAttachmentSent(stagedPath, ATTACHMENT_VERIFY_TIMEOUT_MS, dbPath);
                 if (!status.ok) {
                     throw new Error(`attachment send failed for ${origName}: ${status.detail}`);
                 }
@@ -266,4 +267,3 @@ export function createMessageSender() {
         },
     };
 }
-//# sourceMappingURL=send.js.map

package/dist/transport/watch.js

@@ -0,0 +1,124 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import Database from "better-sqlite3";
+export const defaultDatabasePath = join(homedir(), "Library", "Messages", "chat.db");
+export function resolveMessageText(row) {
+    if (row.text?.trim())
+        return row.text.trim();
+    const blob = row.attributedBody;
+    if (!blob)
+        return "";
+    const marker = blob.indexOf("NSString");
+    if (marker < 0)
+        return "";
+    let position = blob.indexOf(0x2b, marker + 8) + 1;
+    if (position <= 0 || position >= blob.length)
+        return "";
+    let length = blob[position++];
+    if (length === 0x81) {
+        if (position + 2 > blob.length)
+            return "";
+        length = blob.readUInt16LE(position);
+        position += 2;
+    }
+    return position + length <= blob.length
+        ? blob
+            .subarray(position, position + length)
+            .toString("utf8")
+            .trim()
+        : "";
+}
+export function createWatcher(options) {
+    const db = new Database(options.dbPath, { readonly: true, fileMustExist: true });
+    let cursor;
+    try {
+        const maximum = db.prepare("SELECT COALESCE(MAX(ROWID),0) AS value FROM message").get().value;
+        cursor = options.cursor ?? maximum;
+        if (!Number.isSafeInteger(cursor) || cursor < 0 || cursor > maximum)
+            throw new Error("Messages cursor is invalid or ahead of the database; reconcile it before starting");
+    }
+    catch (error) {
+        db.close();
+        throw error;
+    }
+    let stopped = false;
+    let started = false;
+    let closing;
+    let timer;
+    let pending;
+    async function readPage() {
+        const rows = db
+            .prepare(`SELECT m.ROWID AS rowid,m.guid,m.text,m.attributedBody,
+			m.is_from_me AS isFromMe,m.associated_message_type AS reaction,m.service,
+			m.thread_originator_guid AS replyGuid,h.id AS sender,c.guid AS chatGuid,c.display_name AS groupName
+			FROM message m LEFT JOIN handle h ON h.ROWID=m.handle_id
+			LEFT JOIN chat_message_join j ON j.message_id=m.ROWID LEFT JOIN chat c ON c.ROWID=j.chat_id
+			WHERE m.ROWID>? ORDER BY m.ROWID LIMIT 200`)
+            .all(cursor);
+        for (const row of rows) {
+            if (stopped)
+                break;
+            if (!row.isFromMe && !row.reaction && row.chatGuid) {
+                const attachments = db
+                    .prepare(`SELECT a.filename FROM attachment a
+					JOIN message_attachment_join j ON j.attachment_id=a.ROWID WHERE j.message_id=?`)
+                    .all(row.rowid).flatMap(({ filename }) => (filename ? [filename.replace(/^~(?=\/)/, homedir())] : []));
+                const reply = row.replyGuid
+                    ? db.prepare("SELECT text,attributedBody FROM message WHERE guid=?").get(row.replyGuid)
+                    : undefined;
+                const text = resolveMessageText(row);
+                if (text || attachments.length)
+                    await options.accept({
+                        rowid: row.rowid,
+                        guid: row.guid,
+                        chatGuid: row.chatGuid,
+                        text,
+                        sender: row.sender ?? "unknown",
+                        service: row.service ?? "iMessage",
+                        groupName: row.groupName ?? "",
+                        replyTo: reply ? resolveMessageText(reply) : null,
+                        attachments,
+                    });
+            }
+            await options.saveCursor(row.rowid);
+            cursor = row.rowid;
+        }
+    }
+    function poll() {
+        if (stopped)
+            return Promise.resolve();
+        pending ??= readPage().finally(() => {
+            pending = undefined;
+        });
+        return pending;
+    }
+    function tick() {
+        void poll()
+            .catch(options.onError)
+            .finally(() => {
+            if (!stopped)
+                timer = setTimeout(tick, options.intervalMs ?? 2000);
+        });
+    }
+    return {
+        get cursor() {
+            return cursor;
+        },
+        poll,
+        start() {
+            if (stopped || started)
+                return;
+            started = true;
+            tick();
+        },
+        stop() {
+            stopped = true;
+            clearTimeout(timer);
+            closing ??= (async () => {
+                await pending?.catch(() => { });
+                db.close();
+            })();
+            return closing;
+        },
+    };
+}