apple-tools-mcp 2.1.4 → 3.0.0

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/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" }));
+        }
+      }
+    })();
+  };
+}