apple-tools-mcp 1.1.0 → 1.1.1

package/README.md

@@ -137,10 +137,10 @@ Once configured, Claude can use these tools:
 | Tool | Description |
 |------|-------------|
 | `calendar_search` | Semantic search for events with filters |
-| `calendar_date` | Get events on a specific date |
+| `calendar_date` | Get events on a specific date (live Calendar.app, not the search index) |
 | `calendar_upcoming` | Get next N upcoming events |
 | `calendar_week` | Get all events for current or future week |
-| `calendar_free_time` | Find available time slots on a date |
+| `calendar_free_time` | Find available time slots on a date (live Calendar.app, not the search index) |
 | `calendar_recurring` | List recurring events |
 
 ### Contacts Tools

package/index.js

@@ -436,29 +436,11 @@ async function calendarSearch(query, options = {}) {
 }
 
 async function calendarDate(date) {
-  if (!sessionIndexComplete) {
-    return getIndexingMessage();
-  }
-
-  const ready = await isIndexReady("calendar");
-  if (!ready) {
-    return "Calendar index not available. Please try again shortly.";
-  }
-
   const result = await getCalendarDateResults(date);
   return formatCalendarResults(result);
 }
 
 async function calendarFreeTime(date, options = {}) {
-  if (!sessionIndexComplete) {
-    return getIndexingMessage();
-  }
-
-  const ready = await isIndexReady("calendar");
-  if (!ready) {
-    return "Calendar index not available. Please try again shortly.";
-  }
-
   const result = await calculateFreeTime(date, options);
   return formatFreeTimeResults(result);
 }
@@ -1454,7 +1436,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("Apple Tools MCP server running (v1.1.0)");
+  console.error("Apple Tools MCP server running (v1.1.1)");
   // Background indexing runs automatically on startup and every INDEX_INTERVAL
 }
 

package/indexer.js

@@ -63,6 +63,7 @@ const BATCH_DELAY_MS = 0; // No delay needed - benchmarks showed no thermal thro
 
 // Mac Absolute Time epoch: Jan 1, 2001 00:00:00 UTC
 const MAC_ABSOLUTE_EPOCH = 978307200;
+export const CALENDAR_TMP_PREFIX = "apple-tools-cal-";
 
 let embeddingPipeline = null;
 let db = null;
@@ -1687,6 +1688,117 @@ export function getUpcomingEvents(limit = 10) {
   }
 }
 
+// Convert local-day unix ms bounds to Apple/Core Data seconds (unix - 978307200)
+export function localDayToMacBounds(startMs, endMs) {
+  const startMac = Math.floor(Number(startMs) / 1000) - MAC_ABSOLUTE_EPOCH;
+  const endMac = Math.floor(Number(endMs) / 1000) - MAC_ABSOLUTE_EPOCH;
+  if (!Number.isFinite(startMac) || !Number.isFinite(endMac)) {
+    throw new Error("Invalid date bounds");
+  }
+  return { startMac, endMac };
+}
+
+// Date-bounded OccurrenceCache query: one row per occurrence, no GROUP BY ci.ROWID
+export function buildEventsOnDateQuery(startMac, endMac) {
+  const startBound = Math.floor(Number(startMac));
+  const endBound = Math.floor(Number(endMac));
+  if (!Number.isFinite(startBound) || !Number.isFinite(endBound)) {
+    throw new Error("Invalid Mac Absolute Time bounds");
+  }
+  const timedStart = "COALESCE(oc.occurrence_end_date - (ci.end_date - ci.start_date), ci.start_date)";
+  const occEnd = "COALESCE(oc.occurrence_end_date, ci.end_date)";
+  // First local day = occurrence-end local date minus (durationDays - 1). Day math, not seconds (DST-safe).
+  const allDayStartDate = `date(${occEnd} + 978307200, 'unixepoch', 'localtime', '-' || (CAST(round((ci.end_date - ci.start_date) / 86400.0) AS INTEGER) - 1) || ' days')`;
+  const allDayStartMac = `CAST(strftime('%s', ${allDayStartDate} || ' 00:00:00', 'utc') AS INTEGER) - 978307200`;
+  return `
+      SELECT DISTINCT
+        ci.ROWID as itemId,
+        ci.summary as title,
+        datetime(CASE WHEN ci.all_day THEN ${allDayStartMac} ELSE ${timedStart} END + 978307200, 'unixepoch', 'localtime') as start,
+        datetime(${occEnd} + 978307200, 'unixepoch', 'localtime') as end,
+        CASE WHEN ci.all_day THEN ${allDayStartMac} ELSE ${timedStart} END as startMac,
+        ${occEnd} as endMac,
+        ci.all_day as isAllDay,
+        c.title as calendar,
+        l.title as location
+      FROM OccurrenceCache oc
+      INNER JOIN CalendarItem ci ON oc.event_id = ci.ROWID
+      LEFT JOIN Calendar c ON ci.calendar_id = c.ROWID
+      LEFT JOIN Location l ON ci.location_id = l.ROWID
+      WHERE ci.summary IS NOT NULL AND ci.summary <> ''
+        AND (c.title IS NULL OR c.title NOT IN ('Found in Mail', 'Found in Natural Language'))
+        AND (
+          (oc.day >= ${startBound} AND oc.day < ${endBound})
+          OR (
+            ci.all_day = 0
+            AND ${timedStart} < ${startBound}
+            AND ${occEnd} > ${startBound}
+          )
+        )
+      ORDER BY startMac ASC, title ASC
+    `;
+}
+
+// Copy Calendar.sqlitedb (+ wal/shm) to /tmp for one query, then delete the copies.
+// Calendar.app holds a lock on the live db; sqlite can read a snapshot copy.
+function withCalendarCopy(fn) {
+  const id = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const tmpDb = path.join("/tmp", `${CALENDAR_TMP_PREFIX}${id}.sqlitedb`);
+  const tmpWal = `${tmpDb}-wal`;
+  const tmpShm = `${tmpDb}-shm`;
+  const srcWal = `${CALENDAR_DB}-wal`;
+  const srcShm = `${CALENDAR_DB}-shm`;
+
+  try {
+    if (!fs.existsSync(CALENDAR_DB)) {
+      throw new Error("Calendar database not found");
+    }
+    fs.copyFileSync(CALENDAR_DB, tmpDb);
+    if (fs.existsSync(srcWal)) {
+      fs.copyFileSync(srcWal, tmpWal);
+    }
+    if (fs.existsSync(srcShm)) {
+      fs.copyFileSync(srcShm, tmpShm);
+    }
+    return fn(tmpDb);
+  } finally {
+    for (const file of [tmpDb, tmpWal, tmpShm]) {
+      try {
+        fs.unlinkSync(file);
+      } catch {
+        // already gone or never created
+      }
+    }
+  }
+}
+
+// calendar_date: live OccurrenceCache for every occurrence on a local day
+export function getEventsOnDate(startMs, endMs) {
+  try {
+    if (!fs.existsSync(CALENDAR_DB)) {
+      return { events: [], error: "Calendar database not found" };
+    }
+    const { startMac, endMac } = localDayToMacBounds(startMs, endMs);
+    const query = buildEventsOnDateQuery(startMac, endMac);
+    let lastError;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        const events = withCalendarCopy((dbPath) => {
+          return safeSqlite3Json(dbPath, query, { timeout: 15000 });
+        });
+        return { events, error: null };
+      } catch (e) {
+        lastError = e;
+        console.error(`Error getting events on date (attempt ${attempt + 1}):`, e.message);
+      }
+    }
+    return { events: [], error: lastError.message };
+  } catch (e) {
+    console.error("Error getting events on date:", e.message);
+    return { events: [], error: e.message };
+  }
+}
+
 // ============ NEW TOOLS - PHASE 2 ============
 
 // mail_unread_count: Get count of unread emails via AppleScript

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apple-tools-mcp",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "MCP server for semantic search across Apple Mail, Messages, and Calendar",
   "type": "module",
   "main": "index.js",

package/search.js

@@ -2,7 +2,7 @@ import * as lancedb from "@lancedb/lancedb";
 import * as chrono from "chrono-node";
 import { safeOsascript } from "./lib/shell.js";
 import { safeMatch, validateSearchQuery } from "./lib/validators.js";
-import { embed, INDEX_DIR, getRecentEmails, getEmailsByDateRange, getRecentMessages, getConversation, getCalendarByDate, getAllCalendarEvents, resolveEmail, resolvePhone, formatContact } from "./indexer.js";
+import { embed, INDEX_DIR, getRecentEmails, getEmailsByDateRange, getRecentMessages, getConversation, getEventsOnDate, resolveEmail, resolvePhone, formatContact } from "./indexer.js";
 
 let db = null;
 let tables = {};
@@ -1319,28 +1319,40 @@ export async function searchCalendar(query, options = {}) {
   }
 }
 
-// Get events on a specific date
+// Local midnight of parsed date through next local midnight (handles DST; not +24h)
+export function getLocalDayBounds(dateStr) {
+  const start = parseNaturalDate(dateStr);
+  if (start == null) return null;
+  const endDate = new Date(start);
+  endDate.setDate(endDate.getDate() + 1);
+  return { start, end: endDate.getTime() };
+}
+
+// Get events on a specific date from live Calendar.sqlitedb (not the vector index)
 export async function getCalendarDateResults(dateStr) {
   try {
-    const range = getDateRange(dateStr);
+    const range = getLocalDayBounds(dateStr);
     if (!range) {
       return { success: false, error: `Could not parse date: ${dateStr}` };
     }
 
     console.error(`[Calendar Date] Query for "${dateStr}"`);
-    console.error(`[Calendar Date] Range: ${new Date(range.start).toISOString()} to ${new Date(range.end).toISOString()}`);
+    console.error(`[Calendar Date] Range: ${new Date(range.start).toString()} to ${new Date(range.end).toString()}`);
 
-    const results = await getCalendarByDate(range.start, range.end);
+    const { events, error } = getEventsOnDate(range.start, range.end);
+    if (error) {
+      return { success: false, error: `Error getting calendar events: ${error}` };
+    }
 
-    const formattedResults = results.map((row, idx) => ({
+    const formattedResults = events.map((row, idx) => ({
       index: idx + 1,
       title: row.title || "No title",
-      start: formatLocalDate(row.start) || "Unknown",
-      startTimestamp: row.startTimestamp || null,
-      end: formatLocalDate(row.end) || "Unknown",
+      start: formatLocalDate(row.start) || row.start || "Unknown",
+      startTimestamp: row.startMac != null ? (Number(row.startMac) + 978307200) * 1000 : null,
+      end: formatLocalDate(row.end) || row.end || "Unknown",
       calendar: row.calendar || "Unknown",
       location: row.location || "",
-      isAllDay: row.isAllDay || false
+      isAllDay: !!row.isAllDay
     }));
 
     const dateLabel = new Date(range.start).toLocaleDateString("en-US", {
@@ -1360,6 +1372,24 @@ export async function getCalendarDateResults(dateStr) {
   }
 }
 
+// Clamp a timed event to [dayStartMs, dayEndMs) and return minutes from local midnight.
+// Overnight events (23:00–01:00) contribute only the slice that falls on this day.
+export function clampBusyToLocalDay(evtStartMs, evtEndMs, dayStartMs, dayEndMs) {
+  const clampedStart = Math.max(evtStartMs, dayStartMs);
+  const clampedEnd = Math.min(evtEndMs, dayEndMs);
+  if (!(clampedEnd > clampedStart)) return null;
+
+  const startMinutes = clampedStart <= dayStartMs
+    ? 0
+    : new Date(clampedStart).getHours() * 60 + new Date(clampedStart).getMinutes();
+  const endMinutes = clampedEnd >= dayEndMs
+    ? 24 * 60
+    : new Date(clampedEnd).getHours() * 60 + new Date(clampedEnd).getMinutes();
+
+  if (!(endMinutes > startMinutes)) return null;
+  return { startMinutes, endMinutes };
+}
+
 // Calculate free time slots on a specific date
 export async function calculateFreeTime(dateStr, options = {}) {
   const {
@@ -1369,12 +1399,17 @@ export async function calculateFreeTime(dateStr, options = {}) {
   } = options;
 
   try {
-    const range = getDateRange(dateStr);
+    const range = getLocalDayBounds(dateStr);
     if (!range) {
       return { success: false, error: `Could not parse date: ${dateStr}` };
     }
 
-    let events = await getCalendarByDate(range.start, range.end);
+    const { events: liveEvents, error } = getEventsOnDate(range.start, range.end);
+    if (error) {
+      return { success: false, error: `Error calculating free time: ${error}` };
+    }
+
+    let events = liveEvents;
 
     // Filter by calendar if specified
     if (calendarName) {
@@ -1390,16 +1425,21 @@ export async function calculateFreeTime(dateStr, options = {}) {
         continue;
       }
 
-      const evtStart = new Date(evt.startTimestamp);
-      const evtEnd = evt.end ? parseDate(evt.end) : evt.startTimestamp + (60 * 60 * 1000); // Default 1 hour
+      const evtStart = evt.startMac != null
+        ? (Number(evt.startMac) + 978307200) * 1000
+        : (evt.startTimestamp || parseDate(evt.start));
+      const evtEnd = evt.endMac != null
+        ? (Number(evt.endMac) + 978307200) * 1000
+        : (evt.end ? parseDate(evt.end) : evtStart + (60 * 60 * 1000));
 
-      const startMinutes = evtStart.getHours() * 60 + evtStart.getMinutes();
-      const endMinutes = new Date(evtEnd).getHours() * 60 + new Date(evtEnd).getMinutes();
+      const clamped = clampBusyToLocalDay(evtStart, evtEnd, range.start, range.end);
+      if (!clamped) continue;
 
-      busyPeriods.push({
-        start: Math.max(startMinutes, startHour * 60),
-        end: Math.min(endMinutes, endHour * 60)
-      });
+      const start = Math.max(clamped.startMinutes, startHour * 60);
+      const end = Math.min(clamped.endMinutes, endHour * 60);
+      if (end > start) {
+        busyPeriods.push({ start, end });
+      }
     }
 
     // Sort busy periods