apple-tools-mcp 1.1.3 → 1.2.0

package/lib/indexerRuntime.js

@@ -0,0 +1,142 @@
+/**
+ * Indexer daemon vs MCP stdio runtime helpers.
+ * Kept separate from index.js so daemon paths can be tested without
+ * starting MCP stdio or loading the embedding model.
+ */
+
+/**
+ * @param {boolean} indexerMode
+ * @returns {boolean}
+ */
+export function shouldConnectMcpStdio(indexerMode) {
+  return !indexerMode;
+}
+
+/**
+ * @param {boolean} indexerMode
+ * @returns {boolean}
+ */
+export function shouldExitOnStdinClose(indexerMode) {
+  return !indexerMode;
+}
+
+/**
+ * Bind stdin `close` → callback only for MCP stdio clients.
+ * Indexer daemons must ignore stdin close (LaunchAgent often uses /dev/null).
+ *
+ * @param {{ on: (event: string, handler: () => void) => void }} stdin
+ * @param {boolean} indexerMode
+ * @param {() => void} onClose
+ * @returns {{ bound: boolean }}
+ */
+export function bindStdinCloseExit(stdin, indexerMode, onClose) {
+  if (!shouldExitOnStdinClose(indexerMode)) {
+    return { bound: false };
+  }
+  stdin.on("close", onClose);
+  return { bound: true };
+}
+
+/**
+ * Start one index cycle, or skip if a cycle is already running.
+ *
+ * @param {boolean} indexingInProgress
+ * @param {(msg: string) => void} [log]
+ * @returns {{ started: boolean, indexingInProgress: boolean }}
+ */
+export function beginIndexCycle(indexingInProgress, log = (msg) => console.error(msg)) {
+  if (indexingInProgress) {
+    log("Indexing already in progress, skipping cycle");
+    return { started: false, indexingInProgress: true };
+  }
+  return { started: true, indexingInProgress: true };
+}
+
+/**
+ * After a cycle: daemon keeps the lock; MCP local-fallback releases it.
+ *
+ * @param {{
+ *   success: boolean,
+ *   indexerMode: boolean,
+ *   cycleEndFlags: (success: boolean) => {
+ *     indexingInProgress: boolean,
+ *     sessionIndexComplete: boolean,
+ *     ownsIndexLock: boolean,
+ *     isFirstEverRun?: boolean
+ *   },
+ *   releaseLock: () => void
+ * }} args
+ */
+export function applyIndexerCycleEnd({ success, indexerMode, cycleEndFlags, releaseLock }) {
+  const flags = cycleEndFlags(success);
+  if (indexerMode) {
+    return {
+      indexingInProgress: flags.indexingInProgress,
+      sessionIndexComplete: flags.sessionIndexComplete,
+      ownsIndexLock: true,
+      isFirstEverRun: flags.isFirstEverRun,
+      released: false
+    };
+  }
+  releaseLock();
+  return {
+    indexingInProgress: flags.indexingInProgress,
+    sessionIndexComplete: flags.sessionIndexComplete,
+    ownsIndexLock: flags.ownsIndexLock,
+    isFirstEverRun: flags.isFirstEverRun,
+    released: true
+  };
+}
+
+/**
+ * MCP stdio startup: index locally only when the lock is free.
+ *
+ * @param {() => boolean} acquireLock
+ * @returns {{ startBackground: boolean, ownsIndexLock: boolean, startHeartbeat: boolean, reason: "local-fallback" | "lock-held" }}
+ */
+export function mcpIndexingStartup(acquireLock) {
+  if (!acquireLock()) {
+    return { startBackground: false, ownsIndexLock: false, startHeartbeat: false, reason: "lock-held" };
+  }
+  return { startBackground: true, ownsIndexLock: true, startHeartbeat: true, reason: "local-fallback" };
+}
+
+/**
+ * Shared path once this process owns indexer.lock: heartbeat + background cycles.
+ * MCP local-fallback must use this too, not only the daemon.
+ *
+ * @param {{ startHeartbeat: () => void, startBackground: () => void }} steps
+ */
+export function beginOwnedIndexing(steps) {
+  steps.startHeartbeat();
+  steps.startBackground();
+}
+
+/**
+ * Retry until the daemon owns indexer.lock, then run onAcquired.
+ *
+ * @param {() => boolean} acquireLock
+ * @param {{
+ *   retryMs: number,
+ *   onAcquired: () => void,
+ *   log?: (msg: string) => void,
+ *   setTimeoutFn?: typeof setTimeout
+ * }} options
+ */
+export function waitForIndexerLock(acquireLock, options) {
+  const retryMs = options.retryMs;
+  const onAcquired = options.onAcquired;
+  const log = options.log || ((msg) => console.error(msg));
+  const setTimeoutFn = options.setTimeoutFn || setTimeout;
+
+  const tryAcquire = () => {
+    if (acquireLock()) {
+      log("Indexer daemon acquired indexer.lock");
+      onAcquired();
+      return;
+    }
+    log("Indexer daemon waiting for indexer.lock...");
+    setTimeoutFn(tryAcquire, retryMs);
+  };
+  tryAcquire();
+}

package/lib/processMode.js

@@ -0,0 +1,28 @@
+/**
+ * Process mode detection for apple-tools-mcp.
+ *
+ * Canonical indexer entrypoint: `node index.js --mode=indexer`
+ * Convenience bin: `apple-tools-indexer` (same file; detected via argv[1]).
+ * MCP stdio remains the default when neither is present.
+ */
+
+import path from "path";
+
+/**
+ * @param {string[]} [argv=process.argv]
+ * @returns {boolean}
+ */
+export function isIndexerMode(argv = process.argv) {
+  if (!Array.isArray(argv) || argv.length === 0) {
+    return false;
+  }
+  if (argv.includes("--mode=indexer")) {
+    return true;
+  }
+  const modeIdx = argv.indexOf("--mode");
+  if (modeIdx !== -1 && argv[modeIdx + 1] === "indexer") {
+    return true;
+  }
+  const entry = argv[1] ? path.basename(argv[1]) : "";
+  return entry === "apple-tools-indexer";
+}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "apple-tools-mcp",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "MCP server for semantic search across Apple Mail, Messages, and Calendar",
   "type": "module",
   "main": "index.js",
   "bin": {
-    "apple-tools-mcp": "./index.js"
+    "apple-tools-mcp": "./index.js",
+    "apple-tools-indexer": "./index.js"
   },
   "author": "Peter Coates",
   "license": "MIT",
@@ -27,8 +28,6 @@
     "messages",
     "imessage",
     "semantic-search",
-    "claude",
-    "anthropic",
     "macos"
   ],
   "engines": {
@@ -52,6 +51,7 @@
   ],
   "scripts": {
     "start": "node index.js",
+    "indexer": "node index.js --mode=indexer",
     "build-index": "node -e \"import('./indexer.js').then(i=>i.rebuildIndex()).catch(e=>{console.error(e.message);process.exit(1)})\"",
     "audit": "node scripts/audit-index.js",
     "test": "vitest run",