apple-tools-mcp 2.1.5 → 3.0.1

package/indexer.js

@@ -85,10 +85,10 @@ let db = null;
 async function getEmbedder() {
   if (!embeddingPipeline) {
     console.error("Loading embedding model (first time may take a minute)...");
-    // Lazy import: @xenova/transformers loads sharp at import time. A static
+    // Lazy import: @huggingface/transformers loads sharp at import time. A static
     // import crashes Linux (and any host without the platform sharp native)
     // before search.js formatters / pronoun helpers can load.
-    const { pipeline } = await import("@xenova/transformers");
+    const { pipeline } = await import("@huggingface/transformers");
     embeddingPipeline = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
     console.error("Embedding model loaded.");
   }

package/lib/calendarWrite.js

@@ -44,6 +44,17 @@ export const RECURRENCE_FREQUENCIES = ["daily", "weekly", "monthly", "yearly"];
 export const RECURRENCE_DAYS = ["MO", "TU", "WE", "TH", "FR", "SA", "SU"];
 export const RSVP_RESPONSES = ["accept", "decline", "tentative"];
 
+// Regression (2026-09-23): calendar_edit's classic-AppleScript fallback and
+// calendar_rsvp both ran atmFindEvent (see findEventHandler below) under a
+// flat 60000ms runAppleScript timeout -- exactly matching the MCP client
+// SDK's own default 60s CallTool timeout, so the client could give up with
+// a raw "Request timed out" before the server ever got to answer, even
+// though the underlying operation kept running and generally succeeded
+// (same class of bug already fixed for mail_send/reply/forward). Trimmed
+// under that ceiling to leave real margin, including for atmFindEvent's own
+// retry loop (~8s worst case).
+export const CALENDAR_FIND_TIMEOUT_MS = 45000;
+
 const RSVP_STATUS = {
   accept: "accepted",
   decline: "declined",
@@ -163,16 +174,36 @@ export function defaultEndParts(start, allDay) {
   };
 }
 
+/**
+ * calendar_edit / calendar_rsvp's classic-AppleScript fallback both resolve
+ * an event by uid through this handler. Regression (2026-09-23): RSVPing to
+ * an event created moments earlier through the daemon's separate EventKit
+ * session ("no event with that id was found") failed on the first lookup
+ * even though the event genuinely existed -- Calendar.app's classic
+ * AppleScript object model can lag behind a write made through EventKit.
+ * An EventKit-based fix isn't available here: writeOnly EventKit can only
+ * re-query an event via the exact in-memory EKEvent object from the
+ * session that created it (see describeEventKitWriteFailure below), which
+ * doesn't exist for a real invitation synced in from elsewhere. Retrying
+ * the classic lookup a few times gives Calendar.app's own model a chance
+ * to catch up, well inside callers' existing 60s budget.
+ */
 function findEventHandler() {
   return `on atmFindEvent(theUid)
-  tell application "Calendar"
-    repeat with cal in calendars
-      try
-        set hits to (every event of cal whose uid is theUid)
-        if (count of hits) > 0 then return item 1 of hits
-      end try
-    end repeat
-  end tell
+  set attemptsLeft to 5
+  repeat
+    tell application "Calendar"
+      repeat with cal in calendars
+        try
+          set hits to (every event of cal whose uid is theUid)
+          if (count of hits) > 0 then return item 1 of hits
+        end try
+      end repeat
+    end tell
+    set attemptsLeft to attemptsLeft - 1
+    if attemptsLeft is 0 then exit repeat
+    delay 2
+  end repeat
   error "EVENT_NOT_FOUND"
 end atmFindEvent`;
 }
@@ -503,11 +534,19 @@ function addRow(c) {
   var local = type === 0 ? "yes" : "no";
   rows.push(name + "<<>>" + writable + "<<>>" + local + "<<>>" + type + "<<>>" + srcName);
 }
+var listError = "";
 try {
   var cals = store.calendarsForEntityType($.EKEntityTypeEvent);
   for (var i = 0; i < cals.count; i++) addRow(cals.objectAtIndex(i));
-} catch (e) {}
-try { addRow(store.defaultCalendarForNewEvents); } catch (e) {}
+} catch (e) {
+  listError = String(e);
+}
+try { addRow(store.defaultCalendarForNewEvents); } catch (e) {
+  if (!listError) listError = String(e);
+}
+if (rows.length === 0 && listError) {
+  throw new Error("EVENTKIT_LIST_FAILED: " + listError);
+}
 rows.join("|||");`;
 }
 
@@ -659,26 +698,37 @@ set AppleScript's text item delimiters to "|||"
 return outputList as string`;
 
   const result = runAppleScript(script, { timeout: 30000, appName: "Calendar" });
-  if (!result.ok) {
-    return { ok: false, message: failure(action, "list calendars", result) };
-  }
-
-  let calendars = result.output
-    .split("|||")
-    .map((entry) => entry.trim())
-    .filter((entry) => entry.length > 0)
-    .map((entry) => {
-      const [name, writable] = entry.split("<<>>");
-      return { name: name || "", writable: writable !== "no" };
-    });
 
+  // EventKit does not require Calendar.app to be running, so a real EventKit
+  // list can stand in when the classic AppleScript path fails (app closed).
+  // An empty EventKit string is not that list: the JXA helper used to swallow
+  // every error and still exit 0, which hid TCC / timeout / not-running.
   const ekList = runAppleScript(buildEventKitListCalendarsScript(), {
     timeout: 15000,
     appName: "Calendar",
     language: "JavaScript"
   });
-  if (ekList.ok) {
-    calendars = mergeCalendarSources(calendars, parseEventKitCalendarList(ekList.output));
+  const ekCalendars = ekList.ok ? parseEventKitCalendarList(ekList.output) : [];
+
+  if (!result.ok && ekCalendars.length === 0) {
+    return { ok: false, message: failure(action, "list calendars", result) };
+  }
+
+  let calendars = result.ok
+    ? result.output
+        .split("|||")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0)
+        .map((entry) => {
+          const [name, writable] = entry.split("<<>>");
+          return { name: name || "", writable: writable !== "no" };
+        })
+    : [];
+
+  if (ekCalendars.length > 0) {
+    calendars = result.ok
+      ? mergeCalendarSources(calendars, ekCalendars)
+      : ekCalendars;
   }
 
   if (calendars.length === 0) {
@@ -1115,7 +1165,7 @@ export function calendarEdit(args = {}) {
     return { ok: false, message: `${action} refused: ${e.message}` };
   }
 
-  const result = runAppleScript(script, { timeout: 60000, appName: "Calendar" });
+  const result = runAppleScript(script, { timeout: CALENDAR_FIND_TIMEOUT_MS, appName: "Calendar" });
   if (!result.ok) return { ok: false, message: failure(action, summary, result, [updates.description || ""]) };
 
   return {
@@ -1284,10 +1334,16 @@ export function calendarRemove(args = {}) {
 }
 
 export function buildRsvpScript({ eventId, status, attendeeEmail }) {
+  // Calendar.app's AppleScript dictionary defines `participation status` as
+  // one of unknown/accepted/declined/tentative (confirmed via `sdef`/aete
+  // dump) -- there is no "needs action" term, so that bare two-word phrase
+  // was a syntax error (AppleScript parsed "needs" as an identifier and
+  // choked on "action" where it expected "then"). `unknown` is the correct
+  // term for "no answer yet".
   const match = attendeeEmail
     ? `    if (email of att) is ${asString(attendeeEmail)} then set theAttendee to att`
     : `    try
-      if (participation status of att) is needs action then set theAttendee to att
+      if (participation status of att) is unknown then set theAttendee to att
     end try`;
 
   return `${findEventHandler()}
@@ -1344,7 +1400,7 @@ export function calendarRsvp(args = {}) {
 
   const result = runAppleScript(
     buildRsvpScript({ eventId, status: RSVP_STATUS[responseRaw], attendeeEmail }),
-    { timeout: 60000, appName: "Calendar" }
+    { timeout: CALENDAR_FIND_TIMEOUT_MS, appName: "Calendar" }
   );
 
   if (!result.ok) {

package/lib/config.js

@@ -32,7 +32,11 @@ export const MAX_INDEX_INTERVAL_MS = 6 * 60 * 60 * 1000;
 /** Recommended Mini always-on value (set in config.json, not the product default). */
 export const MINI_RECOMMENDED_INDEX_INTERVAL_MS = 60 * 1000;
 
-const KNOWN_CONFIG_KEYS = new Set(["indexInterval", "indexIntervalMs"]);
+/** --transport=http bind address/port defaults. Network exposure is opt-in. */
+export const DEFAULT_HTTP_HOST = "127.0.0.1";
+export const DEFAULT_HTTP_PORT = 8421;
+
+const KNOWN_CONFIG_KEYS = new Set(["indexInterval", "indexIntervalMs", "httpHost", "httpPort"]);
 
 const MAX_DURATION_STRING_LENGTH = 32;
 
@@ -310,3 +314,27 @@ export function logResolvedInterval(resolved, options = {}) {
   const clampedNote = resolved.clamped ? ", clamped" : "";
   log(`Effective index refresh interval: ${resolved.human} (${resolved.ms} ms) [source=${resolved.source}${clampedNote}]`);
 }
+
+/**
+ * Resolve --transport=http bind host/port.
+ * Precedence (highest wins): env vars > config.json > product default.
+ *
+ * @param {{ env?: NodeJS.ProcessEnv, configPath?: string, fileData?: Record<string, unknown>, warn?: (msg: string) => void }} [options]
+ * @returns {{ host: string, port: number }}
+ */
+export function resolveHttpServerConfig(options = {}) {
+  const env = options.env || process.env;
+  const warn = options.warn || defaultWarn;
+  const data =
+    options.fileData !== undefined
+      ? options.fileData
+      : loadConfigFile({ configPath: options.configPath, env, warn }).data;
+
+  const host = env.APPLE_TOOLS_HTTP_HOST || (typeof data.httpHost === "string" ? data.httpHost : undefined) || DEFAULT_HTTP_HOST;
+
+  const rawPort = env.APPLE_TOOLS_HTTP_PORT !== undefined ? env.APPLE_TOOLS_HTTP_PORT : data.httpPort;
+  const parsedPort = typeof rawPort === "number" ? rawPort : Number(rawPort);
+  const port = Number.isInteger(parsedPort) && parsedPort > 0 && parsedPort < 65536 ? parsedPort : DEFAULT_HTTP_PORT;
+
+  return { host, port };
+}

package/lib/httpAuth.js

@@ -0,0 +1,106 @@
+/**
+ * Shared-secret auth for the HTTP transport (--transport=http).
+ *
+ * stdio mode needs no auth — a locally spawned child process is already
+ * trusted by whoever spawned it. HTTP mode is reachable over the LAN and,
+ * via Tailscale, from outside it, and this server exposes write tools
+ * (send iMessage, edit contacts/calendar), so every HTTP request must carry
+ * a bearer token.
+ *
+ * The token is a random secret generated once and stored in the macOS
+ * Keychain — never in a config file, the repo, or logs after the first
+ * (one-time, clearly labeled) print. There is no external account, no
+ * OAuth flow, and no cost: it's a self-issued password, like an SSH key.
+ */
+
+import crypto from "crypto";
+import { execFileSync as defaultExecFileSync } from "child_process";
+
+export const KEYCHAIN_SERVICE = "apple-tools-mcp-http";
+export const KEYCHAIN_ACCOUNT = "http-auth-token";
+
+function readFromKeychain(exec) {
+  try {
+    const out = exec(
+      "/usr/bin/security",
+      ["find-generic-password", "-s", KEYCHAIN_SERVICE, "-a", KEYCHAIN_ACCOUNT, "-w"],
+      { stdio: ["ignore", "pipe", "ignore"] }
+    );
+    const token = out.toString("utf8").trim();
+    return token.length > 0 ? token : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeToKeychain(exec, token) {
+  exec(
+    "/usr/bin/security",
+    ["add-generic-password", "-s", KEYCHAIN_SERVICE, "-a", KEYCHAIN_ACCOUNT, "-w", token, "-U"],
+    { stdio: ["ignore", "ignore", "pipe"] }
+  );
+}
+
+function generateToken(randomBytes) {
+  return randomBytes(32).toString("hex");
+}
+
+/**
+ * Loads the HTTP auth token from Keychain, generating and storing one the
+ * first time this runs on a given machine. Returns the token either way.
+ *
+ * @param {{
+ *   log?: (msg: string) => void,
+ *   forceNew?: boolean,
+ *   execFileSync?: typeof defaultExecFileSync,
+ *   randomBytes?: typeof crypto.randomBytes
+ * }} [options]
+ * @returns {{ token: string, generated: boolean }}
+ */
+export function loadOrCreateHttpAuthToken(options = {}) {
+  const log = options.log || ((msg) => console.error(msg));
+  const exec = options.execFileSync || defaultExecFileSync;
+  const randomBytes = options.randomBytes || crypto.randomBytes;
+
+  if (!options.forceNew) {
+    const existing = readFromKeychain(exec);
+    if (existing) {
+      return { token: existing, generated: false };
+    }
+  }
+
+  const token = generateToken(randomBytes);
+  writeToKeychain(exec, token);
+  log("============================================================");
+  log("Generated a new HTTP auth token (shown once, stored in Keychain):");
+  log(token);
+  log("Use this as a Bearer token when configuring remote MCP clients,");
+  log("e.g. claude mcp add ... -H \"Authorization: Bearer " + token + "\"");
+  log("Retrieve it again later with: apple-tools-mcp http-token");
+  log("============================================================");
+  return { token, generated: true };
+}
+
+/**
+ * Constant-time check of an incoming `Authorization: Bearer <token>` header
+ * against the expected token. Never throws.
+ *
+ * @param {string | undefined | null} headerValue
+ * @param {string} expectedToken
+ * @returns {boolean}
+ */
+export function verifyAuthHeader(headerValue, expectedToken) {
+  if (typeof headerValue !== "string") {
+    return false;
+  }
+  const match = /^Bearer\s+(.+)$/i.exec(headerValue.trim());
+  if (!match) {
+    return false;
+  }
+  const provided = Buffer.from(match[1], "utf8");
+  const expected = Buffer.from(expectedToken, "utf8");
+  if (provided.length !== expected.length) {
+    return false;
+  }
+  return crypto.timingSafeEqual(provided, expected);
+}

package/lib/httpStdioProxy.js

@@ -0,0 +1,45 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+/** Forward the tool interface from an HTTP MCP server to a local stdio client. */
+export function createProxyServer(remoteClient) {
+  const server = new Server(
+    { name: "apple-tools-http-proxy", version: "3.0.0" },
+    { capabilities: { tools: {} } },
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, (request) =>
+    remoteClient.listTools(request.params));
+  server.setRequestHandler(CallToolRequestSchema, (request) =>
+    remoteClient.callTool(request.params));
+
+  return server;
+}
+
+export async function runHttpStdioProxy({ url, token, input = process.stdin, output = process.stdout }) {
+  if (!token) throw new Error("APPLE_TOOLS_MCP_TOKEN is required");
+  const endpoint = new URL(url);
+  if (endpoint.protocol !== "http:" && endpoint.protocol !== "https:") {
+    throw new Error("MCP URL must use http or https");
+  }
+
+  const remoteClient = new Client({ name: "apple-tools-http-proxy", version: "3.0.0" });
+  const remoteTransport = new StreamableHTTPClientTransport(endpoint, {
+    requestInit: { headers: { Authorization: `Bearer ${token}` } },
+  });
+  await remoteClient.connect(remoteTransport);
+
+  const server = createProxyServer(remoteClient);
+  try {
+    await server.connect(new StdioServerTransport(input, output));
+  } catch (error) {
+    await remoteClient.close();
+    throw error;
+  }
+
+  server.onclose = () => { void remoteClient.close(); };
+  return server;
+}

package/lib/httpTransport.js

@@ -0,0 +1,71 @@
+/**
+ * Authenticated request handler for the Streamable HTTP transport.
+ *
+ * Keep this separate from index.js so request parsing and authorization can
+ * be exercised without starting the MCP server or touching the Keychain.
+ */
+
+/**
+ * @param {{
+ *   token: string,
+ *   verifyAuthHeader: (header: string | string[] | undefined, token: string) => boolean,
+ *   createServer: () => { connect: (transport: unknown) => Promise<void>, close: () => Promise<void> },
+ *   StreamableHTTPServerTransport: new (options: { sessionIdGenerator: undefined }) => { handleRequest: (req: unknown, res: unknown) => Promise<void>, close: () => Promise<void> },
+ *   packageVersion: string,
+ *   log?: (message: string) => void
+ * }} options
+ */
+export function createHttpRequestHandler(options) {
+  const { token, verifyAuthHeader, createServer, StreamableHTTPServerTransport, packageVersion } = options;
+  const log = options.log || ((message) => console.error(message));
+
+  return (req, res) => {
+    if (!verifyAuthHeader(req.headers["authorization"], token)) {
+      res.writeHead(401, { "Content-Type": "application/json", "WWW-Authenticate": "Bearer" });
+      res.end(JSON.stringify({ error: "Unauthorized: missing or invalid bearer token" }));
+      return;
+    }
+
+    let url;
+    try {
+      // The request target is relative. Do not derive a URL base from the
+      // user-controlled Host header, which can itself be malformed.
+      url = new URL(req.url || "/", "http://localhost");
+    } catch {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "bad request" }));
+      return;
+    }
+
+    if (url.pathname === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, version: packageVersion }));
+      return;
+    }
+
+    if (url.pathname !== "/mcp" && url.pathname !== "/") {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "not found" }));
+      return;
+    }
+
+    void (async () => {
+      const requestServer = createServer();
+      const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+      try {
+        await requestServer.connect(transport);
+        await transport.handleRequest(req, res);
+        res.on("close", () => {
+          void transport.close();
+          void requestServer.close();
+        });
+      } catch (err) {
+        log(`MCP HTTP request error: ${err.message}`);
+        if (!res.headersSent) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "internal error" }));
+        }
+      }
+    })();
+  };
+}