@mgcrea/mcp-apple-messages 1.4.0 → 1.7.0

package/README.md

@@ -68,14 +68,25 @@ That is a capability downgrade reported through `diagnostics`, never a throw.
 
 Read: `diagnostics`, `list_chats`, `list_messages`, `search_messages`, `get_message`.
 
+Opt-in read: `find_codes`, behind `APPLE_MESSAGES_ALLOW_CODES` — see [Configuration](#configuration).
+Off by default, and not covered by the write gate.
+
 Write: `send_message`, and that is the whole dictionary. `sdef` lists three commands — `send`,
 `login` and `logout` — and the other two would sign the user out of iMessage on every device they
 own. There is no edit, delete, mark-as-read or reaction verb to expose, so **everything this server
 can show you, it cannot change.**
 
-`send`'s direct parameter is typed `file` OR `text`; only the text form ships. A tool that hands an
-arbitrary local path to a remote person is an exfiltration primitive whose blast radius, unlike the
-text form's, is not bounded by what the model can say.
+`send`'s direct parameter is typed `file` OR `text`, and both forms ship in two lanes with different
+bounds. `attachmentId` forwards a file that is already in this Mac's Messages store — the same guid
+`save_attachment` takes, through the same "inside `~/Library/Messages`, or refuse" boundary — so it
+reaches no arbitrary path and needs no flag beyond `ALLOW_WRITES`. `filePath` names any local file,
+which is an exfiltration primitive whose blast radius, unlike the text form's, is not bounded by what
+the model can say; it exists as a parameter only when `APPLE_MESSAGES_ALLOW_FILE_SEND` is on, and it
+is off by default. There is no directory confinement on it on purpose — see
+[docs/messages.md](../../docs/messages.md) for why one would be a speed bump wearing a boundary's
+clothes.
+
+One call sends one thing, so a captioned photo is two calls.
 
 ### Sending, and how it reports what it sent
 
@@ -110,8 +121,25 @@ records exactly what that leaves open; the safe way to measure it is a message t
 | `APPLE_MESSAGES_DEFAULT_RANGE_DAYS` | `30`    | Window when only a start is given.      |
 | `APPLE_MESSAGES_MAX_RESULTS`        | `50`    | Default page size.                      |
 | `APPLE_MESSAGES_ALLOW_WRITES`       | off     | Register `send_message` at all.         |
+| `APPLE_MESSAGES_ALLOW_CODES`        | off     | Register `find_codes` at all.           |
+| `APPLE_MESSAGES_ALLOW_FILE_SEND`    | off     | Add `filePath` to `send_message`.       |
 | `APPLE_MESSAGES_SEND_RECONCILE_MS`  | `5000`  | How long to wait for the sent row.      |
 
+`APPLE_MESSAGES_ALLOW_CODES` gates `find_codes`, which extracts one-time 2FA codes from recently
+received messages. It is a **read**, and it is deliberately not folded into `ALLOW_WRITES`: reaching
+a read through the write gate would mean granting the right to send a message in order to get it.
+
+It is gated at all because of what it combines with. This server already holds the conversation
+history and `@mgcrea/mcp-apple-mail` holds the inbox — between them, the password-_reset_ channel.
+Adding live authentication codes completes an account-takeover primitive out of parts that were each
+individually reasonable, so it defaults off and the two gates are independent in both directions.
+
+Codes are matched by signal rather than by a `\d{4,8}` regex, and every result carries a
+`confidence` and a `matched` saying how it was found; anything below `high` should be checked
+against the message body before use. See `src/codes.ts` in `@mgcrea/mcp-apple-core` — the heuristic moved there when
+`@mgcrea/mcp-apple-safari` became its second caller — and `docs/passwords.md` in the repo for
+why the Passwords app itself is unreachable and this is what ships in its place.
+
 ## Notes that will bite you
 
 - **Dates do not fit in a JavaScript number.** Every date column is nanoseconds since 2001 —

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { A as MESSAGES_SURFACE, V as BUILD_INFO, a as loadConfig, r as createServer } from "./server-BSHulHkz.js";
+import { A as MESSAGES_SURFACE, V as BUILD_INFO, a as loadConfig, r as createServer } from "./server-Bzgy1r6u.js";
 import { runStdioServer } from "@mgcrea/mcp-apple-core";
 //#region src/cli.ts
 const LOG_PREFIX = "apple-messages-mcp";

package/dist/index.d.ts

@@ -40,6 +40,8 @@ declare const ConfigSchema: z.ZodObject<{
   attachmentDir: z.ZodDefault<z.ZodString>;
   defaultRangeDays: z.ZodDefault<z.ZodNumber>;
   sendReconcileMs: z.ZodDefault<z.ZodNumber>;
+  allowCodes: z.ZodDefault<z.ZodBoolean>;
+  allowFileSend: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
 type Config = z.infer<typeof ConfigSchema>;
 declare const loadConfig: (env?: NodeJS.ProcessEnv) => Config;
@@ -291,6 +293,13 @@ type CreateClientOptions = {
  */
 type SendResult = {
   sent: true;
+  /**
+   * What was sent: `text`, `attachment` (a file already in the Messages store,
+   * named by its guid) or `file` (a local path, which only exists as an input
+   * when `allowFileSend` is on). One call sends exactly one of them — the
+   * dictionary's direct parameter is file OR text.
+   */
+  kind: "text" | "attachment" | "file";
   /** Which rung of the ladder in `client/jxa/core.ts` answered. */
   strategy: string;
   targetKind: string;
@@ -375,16 +384,11 @@ declare class AppleMessagesClient {
    *
    * ## Two boundaries, not one
    *
-   * The DESTINATION boundary is the same one Mail and Notes enforce:
-   * `attachmentDir` is a confinement, `directory` may only select inside it, and
-   * the leaf name is `basename`d because it comes from whoever sent the message.
-   *
-   * The SOURCE boundary is this surface's own. `filename` comes out of a
-   * database this server never writes, and it is a fully-qualified path: taken
-   * at face value it names any file the process can read. So it is required to
-   * resolve inside the Messages root before a single byte is read. That check
-   * has never fired on a real store and is not expected to — it is here so that
-   * the day the schema surprises us, the surprise is a refusal.
+   * The SOURCE boundary is `#resolveStoreAttachment` above, shared with the send
+   * lane. What is left here is the DESTINATION boundary, the same one Mail and
+   * Notes enforce: `attachmentDir` is a confinement, `directory` may only select
+   * inside it, and the leaf name is `basename`d because it comes from whoever
+   * sent the message.
    */
   saveAttachment(attachmentId: string, opts?: {
     directory?: string | undefined;
@@ -400,12 +404,15 @@ declare class AppleMessagesClient {
    * Send one message. A real one, to a real person, immediately.
    *
    * Everything difficult about this is in `client/jxa/core.ts`; what is left
-   * here is choosing the target from the file lane and reconciling afterwards.
+   * here is choosing the target from the file lane, deciding what may be sent,
+   * and reconciling afterwards.
    */
   sendMessage(input: {
     chatRef?: string | undefined;
     to?: string | undefined;
-    text: string;
+    text?: string | undefined;
+    attachmentId?: string | undefined;
+    filePath?: string | undefined;
     service?: string | undefined;
   }): Promise<SendResult>;
   /** Bounds for a range query, as apple-seconds. */
@@ -696,11 +703,28 @@ declare const outline: (buffer: Uint8Array, maxTokens?: number) => string[];
  * every device is not something to do behind a tool call, and there is no read
  * to justify logging in.
  *
- * `send`'s direct parameter is typed `file` OR `text`. **This ships text only.**
- * The file form is one branch away and deliberately not taken: a tool that
- * transfers an arbitrary local path to a remote person is an exfiltration
- * primitive, and unlike the text form its blast radius is not bounded by what
- * the model can say. Recorded here so the omission reads as a decision.
+ * `send`'s direct parameter is typed `file` OR `text`. **Both ship, in two lanes
+ * with different bounds.** This paragraph used to record the file form as
+ * deliberately omitted — a tool that transfers an arbitrary local path to a
+ * remote person is an exfiltration primitive, and unlike the text form its blast
+ * radius is not bounded by what the model can say. That reasoning is unchanged.
+ * What changed is that it turned out to argue against *one* of the two things
+ * a file send could mean, not both:
+ *
+ *   - `attachmentId` forwards a file ALREADY in this Mac's Messages store,
+ *     named by the same `attachment.guid` `save_attachment` takes. The client
+ *     resolves it through the same source boundary — inside `messagesRoot`,
+ *     nothing else — so there is no arbitrary path and no arbitrary read. The
+ *     set is bounded by construction, which is why this lane ships under
+ *     `allowWrites` alone.
+ *   - `filePath` names any local file, and IS the primitive above. It is
+ *     registered only when `allowFileSend` is on, and defaults off.
+ *
+ * The script below cannot tell the two apart and must not try: it receives one
+ * already-resolved `p.file` and forwards it. Every bound lives in the client,
+ * because a script that composed its own path would move the boundary somewhere
+ * nothing tests. `test/jxa.test.ts` pins that — one `Path(`, and its argument is
+ * `p.file`.
  *
  * ## The `to` parameter, and why the file lane picks the target
  *
@@ -726,8 +750,17 @@ declare const PRELUDE = "\nObjC.import(\"AppKit\");\n\nfunction ok(data) { retur
  * One script, one verb.
  *
  * `send` is the only mutating command in the Messages dictionary that this
- * server exposes — see `core.ts` for the full list and for why `login`/`logout`
- * and the file form of `send` are left out.
+ * server exposes — see `core.ts` for the full list, for why `login`/`logout` are
+ * left out, and for the two lanes the file form arrives in.
+ *
+ * ## One call site, two payloads
+ *
+ * The file form is `M.send(Path(...), …)` and the text form is `M.send(str, …)`,
+ * which invites two branches around two `send` calls. It is written as one call
+ * over a payload chosen beforehand instead, because `test/jxa.test.ts` proves
+ * the target is resolved before anything is sent by comparing the position of
+ * `resolveTarget(` against `M.send(` — with two call sites that check would pin
+ * the first and quietly ignore the second.
  *
  * ## What this script deliberately does NOT do
  *
@@ -745,7 +778,7 @@ declare const PRELUDE = "\nObjC.import(\"AppKit\");\n\nfunction ok(data) { retur
  * re-resolve by scanning the store for a recent row on the target chat" — and it
  * is what makes a send reportable at all on a surface with no id bridge.
  */
-declare const SEND_MESSAGE = "\nObjC.import(\"AppKit\");\n\nfunction ok(data) { return JSON.stringify({ ok: true, data: data }); }\nfunction err(code, message, extra) {\n  var e = { code: code, message: String(message) };\n  if (extra) e.detail = extra;\n  return JSON.stringify({ ok: false, error: e });\n}\n\n/** Read one property defensively — every read on this surface is allowed to fail. */\nfunction prop(fn, fallback) {\n  try {\n    var v = fn();\n    return v === undefined ? fallback : v;\n  } catch (e) {\n    return fallback;\n  }\n}\n\nfunction isMessagesRunning() {\n  var apps = $.NSRunningApplication.runningApplicationsWithBundleIdentifier(\"com.apple.MobileSMS\");\n  return apps.count > 0;\n}\n\n/** The dictionary's service type enumeration: SMS, iMessage, RCS. */\nfunction serviceEnum(name) {\n  var s = String(name || \"\").toLowerCase();\n  if (s === \"sms\") return \"SMS\";\n  if (s === \"rcs\") return \"RCS\";\n  return \"iMessage\";\n}\n\n/**\n * Find something `send` will accept as its `to`.\n *\n * Ordered cheapest and most-likely-to-work first. Every rung is wrapped, every\n * failure is recorded, and the caller is told which one answered — on a surface\n * whose whole read half is known broken, \"it worked\" without \"how\" is not a\n * result anyone can act on later.\n */\nfunction resolveTarget(M, p, tried) {\n  var i;\n\n  // 1. The chat guid the file lane read out of chat.db. No enumeration.\n  if (p.chatGuid) {\n    try {\n      var chat = M.chats.byId(p.chatGuid);\n      chat.id();\n      return { target: chat, strategy: \"chat-guid\", kind: \"chat\" };\n    } catch (e) {\n      tried.push(\"chat-guid: \" + (e.message || e));\n    }\n  }\n\n  if (!p.handle) return null;\n\n  // 2. The guid Messages composes for a one-to-one chat, spelled the way the\n  //    store spells it: \"iMessage;-;+15551234567\". Constructed rather than read,\n  //    so it is below the real one and above everything that enumerates.\n  var services = p.service ? [serviceEnum(p.service)] : [\"iMessage\", \"SMS\", \"RCS\"];\n  for (i = 0; i < services.length; i++) {\n    var guess = services[i] + \";-;\" + p.handle;\n    try {\n      var guessed = M.chats.byId(guess);\n      guessed.id();\n      return { target: guessed, strategy: \"chat-guid-guess\", kind: \"chat\", guid: guess };\n    } catch (e2) {\n      tried.push(\"chat-guid-guess(\" + guess + \"): \" + (e2.message || e2));\n    }\n  }\n\n  // 3. A participant reached through its account. This enumerates, so it is\n  //    expected to fail with \"Application isn't running\" — kept because it is\n  //    the form every AppleScript example on the internet uses, and because if\n  //    launching the app does wake the scripting interface, this is what works.\n  for (i = 0; i < services.length; i++) {\n    try {\n      var accounts = M.accounts.whose({ serviceType: services[i] })();\n      for (var j = 0; j < accounts.length; j++) {\n        try {\n          var buddy = accounts[j].participants.whose({ handle: p.handle })()[0];\n          if (buddy) {\n            buddy.id();\n            return { target: buddy, strategy: \"account-participant\", kind: \"participant\" };\n          }\n        } catch (e4) {\n          tried.push(\"account-participant(\" + services[i] + \"): \" + (e4.message || e4));\n        }\n      }\n    } catch (e3) {\n      tried.push(\"accounts(\" + services[i] + \"): \" + (e3.message || e3));\n    }\n  }\n\n  // 4. The flat participant list, last because it is the widest enumeration.\n  try {\n    var flat = M.participants.whose({ handle: p.handle })()[0];\n    if (flat) {\n      flat.id();\n      return { target: flat, strategy: \"participant\", kind: \"participant\" };\n    }\n    tried.push(\"participant: no participant with that handle\");\n  } catch (e5) {\n    tried.push(\"participant: \" + (e5.message || e5));\n  }\n\n  return null;\n}\n\nfunction run(argv) {\n  var p = JSON.parse(argv[0]);\n  var M = Application(\"Messages\");\n\n  var wasRunning = isMessagesRunning();\n  if (!wasRunning && !p.allowLaunch) {\n    return err(\"APP_NOT_RUNNING\", \"Messages is not running.\");\n  }\n\n  var tried = [];\n  var resolved = resolveTarget(M, p, tried);\n  if (!resolved) {\n    return err(\n      \"SEND_TARGET_NOT_FOUND\",\n      \"Messages would not resolve a chat or participant for that recipient.\",\n      tried\n    );\n  }\n\n  try {\n    M.send(p.text, { to: resolved.target });\n  } catch (e) {\n    return err(\"SEND_FAILED\", e.message || e, tried);\n  }\n\n  return ok({\n    strategy: resolved.strategy,\n    targetKind: resolved.kind,\n    // Best effort, and allowed to be null: reading the id back is itself a read.\n    targetId: prop(function () { return String(resolved.target.id()); }, null),\n    launched: !wasRunning,\n    attempts: tried\n  });\n}\n";
+declare const SEND_MESSAGE = "\nObjC.import(\"AppKit\");\n\nfunction ok(data) { return JSON.stringify({ ok: true, data: data }); }\nfunction err(code, message, extra) {\n  var e = { code: code, message: String(message) };\n  if (extra) e.detail = extra;\n  return JSON.stringify({ ok: false, error: e });\n}\n\n/** Read one property defensively — every read on this surface is allowed to fail. */\nfunction prop(fn, fallback) {\n  try {\n    var v = fn();\n    return v === undefined ? fallback : v;\n  } catch (e) {\n    return fallback;\n  }\n}\n\nfunction isMessagesRunning() {\n  var apps = $.NSRunningApplication.runningApplicationsWithBundleIdentifier(\"com.apple.MobileSMS\");\n  return apps.count > 0;\n}\n\n/** The dictionary's service type enumeration: SMS, iMessage, RCS. */\nfunction serviceEnum(name) {\n  var s = String(name || \"\").toLowerCase();\n  if (s === \"sms\") return \"SMS\";\n  if (s === \"rcs\") return \"RCS\";\n  return \"iMessage\";\n}\n\n/**\n * Find something `send` will accept as its `to`.\n *\n * Ordered cheapest and most-likely-to-work first. Every rung is wrapped, every\n * failure is recorded, and the caller is told which one answered — on a surface\n * whose whole read half is known broken, \"it worked\" without \"how\" is not a\n * result anyone can act on later.\n */\nfunction resolveTarget(M, p, tried) {\n  var i;\n\n  // 1. The chat guid the file lane read out of chat.db. No enumeration.\n  if (p.chatGuid) {\n    try {\n      var chat = M.chats.byId(p.chatGuid);\n      chat.id();\n      return { target: chat, strategy: \"chat-guid\", kind: \"chat\" };\n    } catch (e) {\n      tried.push(\"chat-guid: \" + (e.message || e));\n    }\n  }\n\n  if (!p.handle) return null;\n\n  // 2. The guid Messages composes for a one-to-one chat, spelled the way the\n  //    store spells it: \"iMessage;-;+15551234567\". Constructed rather than read,\n  //    so it is below the real one and above everything that enumerates.\n  var services = p.service ? [serviceEnum(p.service)] : [\"iMessage\", \"SMS\", \"RCS\"];\n  for (i = 0; i < services.length; i++) {\n    var guess = services[i] + \";-;\" + p.handle;\n    try {\n      var guessed = M.chats.byId(guess);\n      guessed.id();\n      return { target: guessed, strategy: \"chat-guid-guess\", kind: \"chat\", guid: guess };\n    } catch (e2) {\n      tried.push(\"chat-guid-guess(\" + guess + \"): \" + (e2.message || e2));\n    }\n  }\n\n  // 3. A participant reached through its account. This enumerates, so it is\n  //    expected to fail with \"Application isn't running\" — kept because it is\n  //    the form every AppleScript example on the internet uses, and because if\n  //    launching the app does wake the scripting interface, this is what works.\n  for (i = 0; i < services.length; i++) {\n    try {\n      var accounts = M.accounts.whose({ serviceType: services[i] })();\n      for (var j = 0; j < accounts.length; j++) {\n        try {\n          var buddy = accounts[j].participants.whose({ handle: p.handle })()[0];\n          if (buddy) {\n            buddy.id();\n            return { target: buddy, strategy: \"account-participant\", kind: \"participant\" };\n          }\n        } catch (e4) {\n          tried.push(\"account-participant(\" + services[i] + \"): \" + (e4.message || e4));\n        }\n      }\n    } catch (e3) {\n      tried.push(\"accounts(\" + services[i] + \"): \" + (e3.message || e3));\n    }\n  }\n\n  // 4. The flat participant list, last because it is the widest enumeration.\n  try {\n    var flat = M.participants.whose({ handle: p.handle })()[0];\n    if (flat) {\n      flat.id();\n      return { target: flat, strategy: \"participant\", kind: \"participant\" };\n    }\n    tried.push(\"participant: no participant with that handle\");\n  } catch (e5) {\n    tried.push(\"participant: \" + (e5.message || e5));\n  }\n\n  return null;\n}\n\nfunction run(argv) {\n  var p = JSON.parse(argv[0]);\n  var M = Application(\"Messages\");\n\n  var wasRunning = isMessagesRunning();\n  if (!wasRunning && !p.allowLaunch) {\n    return err(\"APP_NOT_RUNNING\", \"Messages is not running.\");\n  }\n\n  // The dictionary's direct parameter is file OR text, so one send sends one\n  // thing. The client enforces this too; it is repeated here because a\n  // malformed param set must fail before a target is addressed, not after.\n  var hasFile = typeof p.file === \"string\" && p.file.length > 0;\n  var hasText = typeof p.text === \"string\" && p.text.length > 0;\n  if (hasFile === hasText) {\n    return err(\"SEND_PAYLOAD_INVALID\", \"Expected exactly one of text or file.\");\n  }\n  // `p.file` is already resolved and already bounded by the client. This does\n  // not build a path, join one, or read one — it forwards what it was handed.\n  var payload = hasFile ? Path(p.file) : p.text;\n\n  var tried = [];\n  var resolved = resolveTarget(M, p, tried);\n  if (!resolved) {\n    return err(\n      \"SEND_TARGET_NOT_FOUND\",\n      \"Messages would not resolve a chat or participant for that recipient.\",\n      tried\n    );\n  }\n\n  try {\n    M.send(payload, { to: resolved.target });\n  } catch (e) {\n    return err(\"SEND_FAILED\", e.message || e, tried);\n  }\n\n  return ok({\n    sent: hasFile ? \"file\" : \"text\",\n    strategy: resolved.strategy,\n    targetKind: resolved.kind,\n    // Best effort, and allowed to be null: reading the id back is itself a read.\n    targetId: prop(function () { return String(resolved.target.id()); }, null),\n    launched: !wasRunning,\n    attempts: tried\n  });\n}\n";
 //#endregion
 //#region src/server.d.ts
 declare const SERVER_NAME: string;
@@ -788,6 +821,19 @@ type ToolContext = {
    * survives it intact.
    */
   allowWrites: boolean;
+  /**
+   * Gates `find_codes` alone, and is independent of `allowWrites` on purpose —
+   * see `config.ts` for why a read got a switch of its own.
+   */
+  allowCodes: boolean;
+  /**
+   * Widens `send_message` with a `filePath` parameter, and is meaningless
+   * without `allowWrites` — see `config.ts`. It changes the tool's SCHEMA rather
+   * than the registered set, which is why it belongs here and not in a call-time
+   * check: a parameter that exists and is always refused is a parameter the
+   * model will keep filling in.
+   */
+  allowFileSend: boolean;
 };
 /**
  * Register the Apple Messages tools.
@@ -796,9 +842,20 @@ type ToolContext = {
  * surface the flag carries a permission claim as well as a safety one: with it
  * off no Apple Event is ever sent, so no Automation grant is ever requested.
  * What is needed either way is Full Disk Access, absolutely — see `diagnostics`.
- *
- * The registered set does NOT vary with whether the store is readable. That is a
- * runtime condition, and MCP clients cache the tool list.
+ * One further read, `find_codes`, only when `allowCodes` is on.
+ *
+ * The registered set is a pure function of STATIC CONFIGURATION, never of
+ * runtime state. In particular it does NOT vary with whether the store is
+ * readable: MCP clients cache the tool list, so a set that shrank when a grant
+ * was missing would stay shrunk after the grant arrived.
+ *
+ * That invariant used to read "a pure function of `allowWrites` and nothing
+ * else". `allowCodes` widened the input without weakening the guarantee, which
+ * was always about runtime conditions rather than about there being exactly one
+ * flag. `allowFileSend` widens it again and is the first flag that changes a
+ * tool's SCHEMA rather than the registered set — the guarantee covers that too,
+ * for the same reason: an MCP client caches the shape as well as the list.
+ * `test/tools.test.ts` asserts each arm separately.
  */
 declare const registerTools: (server: McpServer, client: AppleMessagesClient, ctx: ToolContext) => void;
 //#endregion

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/build-info.ts","../src/config.ts","../src/client/locate.ts","../src/client/store.ts","../src/client/messages.ts","../src/client/dates.ts","../src/client/errors.ts","../src/client/ref.ts","../src/client/typedstream.ts","../src/client/jxa/core.ts","../src/client/jxa/write.ts","../src/server.ts","../src/tools/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/build-info.ts","../src/config.ts","../src/client/locate.ts","../src/client/store.ts","../src/client/messages.ts","../src/client/dates.ts","../src/client/errors.ts","../src/client/ref.ts","../src/client/typedstream.ts","../src/client/jxa/core.ts","../src/client/jxa/write.ts","../src/server.ts","../src/tools/index.ts"],"mappings":"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"}

package/dist/index.js

@@ -1,2 +1,2 @@
-import { A as MESSAGES_SURFACE, B as toAppleSeconds, C as locateStore, D as ChatNotFoundError, E as AppleMessagesError, F as SendTargetNotFoundError, I as CORE_DATA_EPOCH_OFFSET, L as appleSecondsSql, M as MessagesUnavailableError, N as SchemaDriftError, O as IndexUnavailableError, P as SendFailedError, R as fromAppleSeconds, S as defaultStorePath, T as PRELUDE, V as BUILD_INFO, _ as decodeMessageRef, a as loadConfig, b as ATTACHMENTS_RELATIVE, c as introspect, d as decodeAttributedBody, f as outline, g as decodeChatRef, h as MESSAGE_REF_VERSION, i as registerTools, j as MessageNotFoundError, k as MESSAGES_BUNDLE_ID, l as openStore, m as InvalidMessageRefError, n as SERVER_VERSION, o as AppleMessagesClient, p as CHAT_REF_VERSION, r as createServer, s as MessagesStore, t as SERVER_NAME, u as reactionLabel, v as encodeChatRef, w as SEND_MESSAGE, x as STORE_RELATIVE, y as encodeMessageRef, z as renderInstant } from "./server-BSHulHkz.js";
+import { A as MESSAGES_SURFACE, B as toAppleSeconds, C as locateStore, D as ChatNotFoundError, E as AppleMessagesError, F as SendTargetNotFoundError, I as CORE_DATA_EPOCH_OFFSET, L as appleSecondsSql, M as MessagesUnavailableError, N as SchemaDriftError, O as IndexUnavailableError, P as SendFailedError, R as fromAppleSeconds, S as defaultStorePath, T as PRELUDE, V as BUILD_INFO, _ as decodeMessageRef, a as loadConfig, b as ATTACHMENTS_RELATIVE, c as introspect, d as decodeAttributedBody, f as outline, g as decodeChatRef, h as MESSAGE_REF_VERSION, i as registerTools, j as MessageNotFoundError, k as MESSAGES_BUNDLE_ID, l as openStore, m as InvalidMessageRefError, n as SERVER_VERSION, o as AppleMessagesClient, p as CHAT_REF_VERSION, r as createServer, s as MessagesStore, t as SERVER_NAME, u as reactionLabel, v as encodeChatRef, w as SEND_MESSAGE, x as STORE_RELATIVE, y as encodeMessageRef, z as renderInstant } from "./server-Bzgy1r6u.js";
 export { ATTACHMENTS_RELATIVE, AppleMessagesClient, AppleMessagesError, BUILD_INFO, CHAT_REF_VERSION, CORE_DATA_EPOCH_OFFSET, ChatNotFoundError, IndexUnavailableError, InvalidMessageRefError, MESSAGES_BUNDLE_ID, MESSAGES_SURFACE, MESSAGE_REF_VERSION, MessageNotFoundError, MessagesStore, MessagesUnavailableError, PRELUDE, SEND_MESSAGE, SERVER_NAME, SERVER_VERSION, STORE_RELATIVE, SchemaDriftError, SendFailedError, SendTargetNotFoundError, appleSecondsSql, createServer, decodeAttributedBody, decodeChatRef, decodeMessageRef, defaultStorePath, encodeChatRef, encodeMessageRef, fromAppleSeconds, introspect, loadConfig, locateStore, openStore, outline, reactionLabel, registerTools, renderInstant, toAppleSeconds };