clawty 0.0.1

package/src/imessage/database.ts

@@ -0,0 +1,427 @@
+import { Database } from "bun:sqlite";
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync } from "fs";
+import type { IMessage } from "./types.ts";
+
+const CHAT_DB_PATH = join(homedir(), "Library", "Messages", "chat.db");
+const APPLE_EPOCH_OFFSET = 978307200;
+
+// On modern macOS, date is in nanoseconds since 2001-01-01
+function appleTimestampToDate(timestamp: number): Date {
+  // Handle both seconds and nanosecond formats
+  // Nanosecond timestamps are > 1e15, second timestamps are < 1e12
+  const seconds = timestamp > 1e15 ? timestamp / 1e9 : timestamp;
+  return new Date((seconds + APPLE_EPOCH_OFFSET) * 1000);
+}
+
+// Extract text from attributedBody (NSAttributedString binary plist)
+// On newer macOS, `text` column can be NULL and content is in attributedBody
+function extractTextFromAttributedBody(buf: Buffer | Uint8Array | null): string | null {
+  if (!buf) return null;
+  try {
+    // The attributedBody is a binary plist containing NSAttributedString
+    // The plain text is embedded as a UTF-8 string after a specific marker
+    // Look for the streamtyped marker pattern and extract text after it
+    const bytes = Buffer.from(buf);
+    const str = bytes.toString("latin1");
+
+    // Strategy 1: Look for NSString content between known markers
+    // The text typically appears after "NSString" and before "NSDictionary"
+    const nsStringIdx = str.indexOf("NSString");
+    if (nsStringIdx !== -1) {
+      // Find the start of actual text content
+      // It's usually preceded by a length byte
+      let searchStart = nsStringIdx + 8;
+      // Skip past class info bytes to find the actual text
+      for (let i = searchStart; i < Math.min(searchStart + 50, bytes.length); i++) {
+        // Look for printable ASCII start after some binary bytes
+        if (bytes[i]! >= 0x20 && bytes[i]! < 0x7f) {
+          // Found potential text start, now find the end
+          let textEnd = i;
+          while (textEnd < bytes.length) {
+            const b = bytes[textEnd]!;
+            // Allow printable ASCII, common UTF-8 continuation bytes, and some control chars
+            if (b >= 0x20 || b === 0x0a || b === 0x0d || b === 0x09 || (b >= 0x80 && b <= 0xfe)) {
+              textEnd++;
+            } else {
+              break;
+            }
+          }
+          if (textEnd - i > 1) {
+            const extracted = bytes.subarray(i, textEnd).toString("utf-8").trim();
+            if (extracted.length > 0) return extracted;
+          }
+        }
+      }
+    }
+
+    // Strategy 2: Find text using the bplist pattern
+    // Look for the content between specific byte patterns
+    const markers = [
+      Buffer.from([0x01, 0x94, 0x84, 0x01]), // Common marker before text
+      Buffer.from([0x01, 0x84, 0x01]),          // Alternative marker
+    ];
+
+    for (const marker of markers) {
+      const idx = bytes.indexOf(marker);
+      if (idx !== -1) {
+        const textStart = idx + marker.length;
+        // Read until we hit a non-text byte sequence
+        let textEnd = textStart;
+        while (textEnd < bytes.length && bytes[textEnd] !== 0x06 && bytes[textEnd] !== 0x86) {
+          textEnd++;
+        }
+        const extracted = bytes.subarray(textStart, textEnd).toString("utf-8").trim();
+        if (extracted.length > 0) return extracted;
+      }
+    }
+
+    // Strategy 3: Brute force - find the longest printable UTF-8 run
+    let bestStart = 0;
+    let bestLen = 0;
+    let currentStart = 0;
+    let currentLen = 0;
+
+    for (let i = 0; i < bytes.length; i++) {
+      const b = bytes[i]!;
+      if (b >= 0x20 || b === 0x0a || b === 0x0d || b === 0x09) {
+        if (currentLen === 0) currentStart = i;
+        currentLen++;
+      } else if (b >= 0xc0 && b <= 0xfe) {
+        // UTF-8 multibyte start
+        if (currentLen === 0) currentStart = i;
+        currentLen++;
+      } else if (b >= 0x80 && b <= 0xbf && currentLen > 0) {
+        // UTF-8 continuation byte
+        currentLen++;
+      } else {
+        if (currentLen > bestLen) {
+          bestStart = currentStart;
+          bestLen = currentLen;
+        }
+        currentLen = 0;
+      }
+    }
+    if (currentLen > bestLen) {
+      bestStart = currentStart;
+      bestLen = currentLen;
+    }
+
+    if (bestLen > 1) {
+      return bytes.subarray(bestStart, bestStart + bestLen).toString("utf-8").trim();
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Generate common phone number variations for matching.
+ * E.g. "6692333038" → ["+16692333038", "+1 6692333038", ...]
+ *      "+16692333038" → ["16692333038", "6692333038", ...]
+ */
+function phoneVariations(contact: string): string[] {
+  // Only generate variations for phone-number-like strings (digits, +, spaces, dashes)
+  const digits = contact.replace(/[\s\-\(\)\.]/g, "");
+  if (!/^\+?\d{7,15}$/.test(digits)) return [];
+
+  const raw = digits.replace(/^\+/, "");
+  const variations: string[] = [];
+
+  if (raw.length === 10) {
+    // Looks like a US number without country code: add +1
+    variations.push(`+1${raw}`, `1${raw}`);
+  } else if (raw.length === 11 && raw.startsWith("1")) {
+    // Looks like a US number with country code 1: try with +, without 1
+    variations.push(`+${raw}`, raw.slice(1), `+${raw.slice(1)}`);
+  } else {
+    // International: try with/without +
+    if (digits.startsWith("+")) {
+      variations.push(raw);
+    } else {
+      variations.push(`+${raw}`);
+    }
+  }
+
+  return variations;
+}
+
+export class IMessageDatabase {
+  private db: Database;
+  private lastRowId: number = 0;
+  private processedRowIds = new Set<number>();
+
+  constructor() {
+    if (!existsSync(CHAT_DB_PATH)) {
+      throw new Error(
+        `iMessage database not found at ${CHAT_DB_PATH}.\n` +
+        `Make sure you're running on macOS with Messages.app configured.`
+      );
+    }
+
+    try {
+      // Open read-only; the DB already uses WAL mode (set by Messages.app)
+      this.db = new Database(CHAT_DB_PATH, { readonly: true });
+      // Wait up to 3s if Messages.app has the DB locked during WAL checkpoint
+      this.db.exec("PRAGMA busy_timeout = 3000");
+    } catch (e: any) {
+      if (e.message?.includes("unable to open") || e.message?.includes("authorization denied")) {
+        throw new Error(
+          `Cannot access iMessage database. Full Disk Access is required.\n\n` +
+          `To grant access:\n` +
+          `1. Open System Settings → Privacy & Security → Full Disk Access\n` +
+          `2. Click the + button\n` +
+          `3. Add your terminal app (Terminal.app, iTerm2, Warp, etc.)\n` +
+          `4. Restart your terminal and try again`
+        );
+      }
+      throw e;
+    }
+  }
+
+  initialize(): void {
+    // Get the current max ROWID so we only process new messages
+    const row = this.db.query("SELECT MAX(ROWID) as maxId FROM message").get() as { maxId: number } | null;
+    this.lastRowId = row?.maxId ?? 0;
+    // Initialized — only process new messages from here
+  }
+
+  getNewMessages(contact: string): IMessage[] {
+    // Match contact by exact ID or by trailing digits (so "6692333038" matches "+16692333038")
+    const contactDigits = contact.replace(/[^\d]/g, "");
+    const isPhone = contactDigits.length >= 7;
+
+    const query = this.db.query(`
+      SELECT
+        m.ROWID as rowId,
+        m.text,
+        m.attributedBody,
+        m.date,
+        m.is_from_me as isFromMe,
+        h.id as sender,
+        h.service,
+        c.chat_identifier as chatId
+      FROM message m
+      LEFT JOIN handle h ON m.handle_id = h.ROWID
+      LEFT JOIN chat_message_join cmj ON m.ROWID = cmj.message_id
+      LEFT JOIN chat c ON cmj.chat_id = c.ROWID
+      WHERE m.ROWID > ?1
+        AND m.is_from_me = 0
+        AND (h.id = ?2 OR (?3 AND REPLACE(REPLACE(REPLACE(h.id, '+', ''), '-', ''), ' ', '') LIKE '%' || ?4))
+        AND m.cache_roomnames IS NULL
+      ORDER BY m.ROWID ASC
+    `);
+
+    const rows = query.all(this.lastRowId, contact, isPhone ? 1 : 0, contactDigits) as Array<{
+      rowId: number;
+      text: string | null;
+      attributedBody: Buffer | null;
+      date: number;
+      isFromMe: number;
+      sender: string;
+      service: string;
+      chatId: string | null;
+    }>;
+
+    const messages: IMessage[] = [];
+
+    for (const row of rows) {
+      // Skip already-processed ROWIDs (prevents self-message echo loops)
+      if (this.processedRowIds.has(row.rowId)) continue;
+
+      // Update last seen ROWID
+      if (row.rowId > this.lastRowId) {
+        this.lastRowId = row.rowId;
+      }
+
+      // Try to get text from the text column first, then attributedBody
+      let text = row.text;
+      if (!text && row.attributedBody) {
+        text = extractTextFromAttributedBody(row.attributedBody);
+      }
+
+      // Skip messages with no extractable text
+      if (!text || text.trim().length === 0) continue;
+
+      this.processedRowIds.add(row.rowId);
+
+      messages.push({
+        rowId: row.rowId,
+        text: text.trim(),
+        sender: row.sender,
+        date: appleTimestampToDate(row.date),
+        isFromMe: row.isFromMe === 1,
+        service: row.service ?? "iMessage",
+        chatId: row.chatId,
+      });
+    }
+
+    // Prune old processed ROWIDs to prevent memory leak (keep last 1000)
+    if (this.processedRowIds.size > 1000) {
+      const sorted = [...this.processedRowIds].sort((a, b) => a - b);
+      const toRemove = sorted.slice(0, sorted.length - 500);
+      for (const id of toRemove) this.processedRowIds.delete(id);
+    }
+
+    return messages;
+  }
+
+  /**
+   * Get the N most recent messages for a contact (both incoming and outgoing).
+   */
+  getRecentMessages(contact: string, limit: number = 20): IMessage[] {
+    const contactDigits = contact.replace(/[^\d]/g, "");
+    const isPhone = contactDigits.length >= 7;
+
+    const query = this.db.query(`
+      SELECT
+        m.ROWID as rowId,
+        m.text,
+        m.attributedBody,
+        m.date,
+        m.is_from_me as isFromMe,
+        COALESCE(h.id, ?1) as sender,
+        COALESCE(h.service, 'iMessage') as service,
+        c.chat_identifier as chatId
+      FROM message m
+      LEFT JOIN handle h ON m.handle_id = h.ROWID
+      LEFT JOIN chat_message_join cmj ON m.ROWID = cmj.message_id
+      LEFT JOIN chat c ON cmj.chat_id = c.ROWID
+      WHERE (
+        (m.is_from_me = 0 AND (h.id = ?1 OR (?3 AND REPLACE(REPLACE(REPLACE(h.id, '+', ''), '-', ''), ' ', '') LIKE '%' || ?4)))
+        OR (m.is_from_me = 1 AND (c.chat_identifier LIKE '%' || ?1 || '%' OR (?3 AND c.chat_identifier LIKE '%' || ?4 || '%')))
+      )
+        AND m.cache_roomnames IS NULL
+      ORDER BY m.ROWID DESC
+      LIMIT ?2
+    `);
+
+    const rows = query.all(contact, limit, isPhone ? 1 : 0, contactDigits) as Array<{
+      rowId: number;
+      text: string | null;
+      attributedBody: Buffer | null;
+      date: number;
+      isFromMe: number;
+      sender: string;
+      service: string;
+      chatId: string | null;
+    }>;
+
+    const messages: IMessage[] = [];
+
+    for (const row of rows) {
+      let text = row.text;
+      if (!text && row.attributedBody) {
+        text = extractTextFromAttributedBody(row.attributedBody);
+      }
+      if (!text || text.trim().length === 0) continue;
+
+      messages.push({
+        rowId: row.rowId,
+        text: text.trim(),
+        sender: row.isFromMe === 1 ? "me" : row.sender,
+        date: appleTimestampToDate(row.date),
+        isFromMe: row.isFromMe === 1,
+        service: row.service ?? "iMessage",
+        chatId: row.chatId,
+      });
+    }
+
+    // Reverse so oldest is first
+    return messages.reverse();
+  }
+
+  /**
+   * Get the current max ROWID.
+   */
+  getMaxRowId(): number {
+    const row = this.db.query("SELECT MAX(ROWID) as maxId FROM message").get() as { maxId: number } | null;
+    return row?.maxId ?? 0;
+  }
+
+  /**
+   * Check if we can access the database (permissions check)
+   */
+  verify(): boolean {
+    try {
+      this.db.query("SELECT COUNT(*) FROM message").get();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Look up a contact handle to verify it exists.
+   * Tries the exact value first, then common phone number variations
+   * (+1 prefix, stripped +1, etc.) so users don't have to get the format exactly right.
+   */
+  findContact(contact: string): { id: string; service: string } | null {
+    // Try exact match first
+    const exact = this.db.query(
+      "SELECT id, service FROM handle WHERE id = ? LIMIT 1"
+    ).get(contact) as { id: string; service: string } | null;
+    if (exact) return exact;
+
+    // Generate phone number variations to try
+    const variations = phoneVariations(contact);
+    for (const variant of variations) {
+      const row = this.db.query(
+        "SELECT id, service FROM handle WHERE id = ? LIMIT 1"
+      ).get(variant) as { id: string; service: string } | null;
+      if (row) return row;
+    }
+
+    return null;
+  }
+
+  /**
+   * Advance the cursor past any new rows (e.g. after sending an outgoing message).
+   * Prevents echo loops when bridging with your own number.
+   */
+  advanceCursor(): void {
+    const row = this.db.query("SELECT MAX(ROWID) as maxId FROM message").get() as { maxId: number } | null;
+    if (row?.maxId && row.maxId > this.lastRowId) {
+      this.lastRowId = row.maxId;
+    }
+  }
+
+  /**
+   * Advance cursor aggressively to catch echo rows from self-messaging.
+   * Polls multiple times over ~1.5s to catch the is_from_me=0 echo copy
+   * that iMessage creates when you message yourself.
+   */
+  async advanceCursorWithDelay(): Promise<void> {
+    this.advanceCursor();
+    // Also mark all recent is_from_me=0 rows as processed to catch echoes
+    this.markRecentAsProcessed();
+    for (let i = 0; i < 3; i++) {
+      await new Promise((r) => setTimeout(r, 500));
+      this.advanceCursor();
+      this.markRecentAsProcessed();
+    }
+  }
+
+  /**
+   * Mark recent outgoing rows (is_from_me=1) as processed to prevent echo loops.
+   * Only marks our own messages — never incoming messages from the contact.
+   */
+  private markRecentAsProcessed(): void {
+    const rows = this.db.query(
+      "SELECT ROWID FROM message WHERE ROWID > ?1 AND is_from_me = 1 ORDER BY ROWID ASC LIMIT 50"
+    ).all(this.lastRowId - 5) as Array<{ ROWID: number }>;
+    for (const row of rows) {
+      this.processedRowIds.add(row.ROWID);
+      if (row.ROWID > this.lastRowId) {
+        this.lastRowId = row.ROWID;
+      }
+    }
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}

package/src/imessage/sender.ts

@@ -0,0 +1,196 @@
+import { tmpdir } from "os";
+import { join } from "path";
+import { unlink } from "fs/promises";
+
+const MAX_IMESSAGE_LENGTH = 15000;
+
+/**
+ * Remove a temp file, ignoring errors.
+ */
+async function cleanupTmpFile(path: string): Promise<void> {
+  try { await unlink(path); } catch {}
+}
+
+/**
+ * Send an iMessage using JXA (JavaScript for Automation).
+ * Uses chats.whose({id: {_contains: contact}}) which is the reliable
+ * approach on modern macOS (Sonoma/Sequoia). Message content is read
+ * from a temp file to avoid all string escaping issues.
+ */
+async function sendViaJxa(contact: string, text: string): Promise<{ ok: boolean; error?: string }> {
+  const tmpFile = join(tmpdir(), `imessage-claude-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
+  await Bun.write(tmpFile, text);
+
+  try {
+    const jxaScript = `
+ObjC.import('Foundation');
+function run() {
+  var filePath = ${JSON.stringify(tmpFile)};
+  var contact = ${JSON.stringify(contact)};
+  var nsStr = $.NSString.stringWithContentsOfFileEncodingError(filePath, $.NSUTF8StringEncoding, null);
+  var message = nsStr.js;
+  var app = Application("Messages");
+  var chats = app.chats.whose({id: {_contains: contact}})();
+  if (chats.length === 0) throw new Error("No chat found for contact: " + contact);
+  app.send(message, {to: chats[0]});
+  return "ok";
+}`;
+
+    const proc = Bun.spawn(["osascript", "-l", "JavaScript", "-e", jxaScript], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const [exitCode, stderr] = await Promise.all([
+      proc.exited,
+      new Response(proc.stderr).text(),
+    ]);
+
+    if (exitCode === 0) return { ok: true };
+    return { ok: false, error: stderr.trim() };
+  } finally {
+    await cleanupTmpFile(tmpFile);
+  }
+}
+
+/**
+ * Fallback: send using classic AppleScript.
+ * Reads message from temp file. Tries participant syntax, then buddy syntax.
+ */
+async function sendViaAppleScript(contact: string, text: string): Promise<{ ok: boolean; error?: string }> {
+  const tmpFile = join(tmpdir(), `imessage-claude-${Date.now()}.txt`);
+  await Bun.write(tmpFile, text);
+
+  const escapedContact = contact.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const escapedPath = tmpFile.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+
+  try {
+    // Try participant syntax first (modern macOS)
+    const script = `
+set msgFile to POSIX file "${escapedPath}"
+set msgContent to read msgFile as «class utf8»
+tell application "Messages"
+  set targetService to 1st account whose service type = iMessage
+  set targetBuddy to participant "${escapedContact}" of targetService
+  send msgContent to targetBuddy
+end tell`;
+
+    const proc = Bun.spawn(["osascript", "-e", script], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const [exitCode, stderr] = await Promise.all([
+      proc.exited,
+      new Response(proc.stderr).text(),
+    ]);
+
+    if (exitCode === 0) return { ok: true };
+
+    // Try buddy syntax (older macOS)
+    const fallbackScript = `
+set msgFile to POSIX file "${escapedPath}"
+set msgContent to read msgFile as «class utf8»
+tell application "Messages"
+  send msgContent to buddy "${escapedContact}" of (service 1 whose service type is iMessage)
+end tell`;
+
+    const fallbackProc = Bun.spawn(["osascript", "-e", fallbackScript], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const [fbExit, fbErr] = await Promise.all([
+      fallbackProc.exited,
+      new Response(fallbackProc.stderr).text(),
+    ]);
+
+    if (fbExit === 0) return { ok: true };
+    return { ok: false, error: `participant: ${stderr.trim()} | buddy: ${fbErr.trim()}` };
+  } finally {
+    await cleanupTmpFile(tmpFile);
+  }
+}
+
+/**
+ * Send an iMessage to a contact. Tries JXA first, falls back to AppleScript.
+ */
+export async function sendIMessage(contact: string, message: string): Promise<void> {
+  const chunks = splitMessage(message, MAX_IMESSAGE_LENGTH);
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunk = chunks[i]!;
+
+    // Try JXA first (chat-based, most reliable on modern macOS)
+    let result = await sendViaJxa(contact, chunk);
+
+    // Fall back to AppleScript if JXA fails
+    if (!result.ok) {
+      process.stderr.write(`JXA send failed (${result.error}), trying AppleScript fallback...\n`);
+      result = await sendViaAppleScript(contact, chunk);
+    }
+
+    if (!result.ok) {
+      throw new Error(
+        `Failed to send iMessage: ${result.error}\n\n` +
+        `Make sure:\n` +
+        `1. Messages.app is open and signed in to iMessage\n` +
+        `2. Your terminal has Automation permission for Messages\n` +
+        `   (System Settings → Privacy & Security → Automation)\n` +
+        `3. You have an existing chat with this contact in Messages`
+      );
+    }
+
+    // Small delay between chunks to maintain order
+    if (i < chunks.length - 1) {
+      await Bun.sleep(500);
+    }
+  }
+}
+
+/**
+ * Split a long message into chunks at natural breakpoints.
+ */
+function splitMessage(text: string, maxLength: number): string[] {
+  if (text.length <= maxLength) return [text];
+
+  const chunks: string[] = [];
+  let remaining = text;
+
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+
+    let splitIdx = remaining.lastIndexOf("\n\n", maxLength);
+    if (splitIdx <= 0) splitIdx = remaining.lastIndexOf("\n", maxLength);
+    if (splitIdx <= 0) splitIdx = remaining.lastIndexOf(" ", maxLength);
+    if (splitIdx <= 0) splitIdx = maxLength;
+
+    chunks.push(remaining.slice(0, splitIdx));
+    remaining = remaining.slice(splitIdx).trimStart();
+  }
+
+  if (chunks.length > 1) {
+    return chunks.map((chunk, i) => `[${i + 1}/${chunks.length}]\n${chunk}`);
+  }
+
+  return chunks;
+}
+
+/**
+ * Test that we can reach Messages.app (permissions check).
+ */
+export async function verifySendPermission(): Promise<boolean> {
+  try {
+    const proc = Bun.spawn(["osascript", "-e", 'tell application "Messages" to get name'], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const exitCode = await proc.exited;
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}

package/src/imessage/types.ts

@@ -0,0 +1,9 @@
+export interface IMessage {
+  rowId: number;
+  text: string;
+  sender: string;
+  date: Date;
+  isFromMe: boolean;
+  service: string;
+  chatId: string | null;
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { IMessageDatabase } from "./imessage/database.ts";
+export { sendIMessage, verifySendPermission } from "./imessage/sender.ts";
+export { verifyClaudeInstalled } from "./claude/runner.ts";
+export type { IMessage } from "./imessage/types.ts";