@mcpher/gas-fakes 1.2.27 → 1.2.28

package/package.json

@@ -34,7 +34,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "1.2.27",
+  "version": "1.2.28",
   "license": "MIT",
   "main": "main.js",
   "description": "A proof of concept implementation of Apps Script Environment on Node",

package/src/cli/setup.js

@@ -171,6 +171,11 @@ export async function initializeConfiguration(options = {}) {
         value: "https://www.googleapis.com/auth/gmail.modify",
       },
       */
+      {
+        sensitivity: "sensitive",
+        title: "Calendar (full access)",
+        value: "https://www.googleapis.com/auth/calendar",
+      },
       {
         // actually labels are not sensitive
         title: "Gmail labels",
@@ -302,8 +307,8 @@ export async function initializeConfiguration(options = {}) {
           existingConfig.LOG_DESTINATION
         ) > -1
           ? ["CONSOLE", "CLOUD", "BOTH", "NONE"].indexOf(
-            existingConfig.LOG_DESTINATION
-          )
+              existingConfig.LOG_DESTINATION
+            )
           : 0,
     },
     {
@@ -316,7 +321,7 @@ export async function initializeConfiguration(options = {}) {
       ],
       initial:
         ["FILE", "UPSTASH"].indexOf(existingConfig.STORE_TYPE?.toUpperCase()) >
-          -1
+        -1
           ? ["FILE", "UPSTASH"].indexOf(existingConfig.STORE_TYPE.toUpperCase())
           : 0,
     },
@@ -486,13 +491,14 @@ export async function authenticateUser() {
 
   console.log("Revoking previous credentials...");
   try {
-    execSync("gcloud auth revoke --quiet", { stdio: "ignore" });
+    execSync("gcloud auth revoke --quiet", { stdio: "ignore", shell: true });
   } catch (e) {
     /* ignore */
   }
   try {
     execSync("gcloud auth application-default revoke --quiet", {
       stdio: "ignore",
+      shell: true,
     });
   } catch (e) {
     /* ignore */
@@ -502,6 +508,7 @@ export async function authenticateUser() {
   try {
     execSync(`gcloud config configurations describe "${activeConfig}"`, {
       stdio: "ignore",
+      shell: true,
     });
     console.log(`Configuration '${activeConfig}' already exists.`);
   } catch (error) {
@@ -519,6 +526,26 @@ export async function authenticateUser() {
   console.log("Initiating user login...");
   runCommandSync(`gcloud auth login ${driveAccessFlag}`);
 
+  // --- Verify that the user is actually logged in ---
+  try {
+    const currentAccount = execSync("gcloud config get-value account", {
+      encoding: "utf8",
+      shell: true,
+    }).trim();
+
+    if (!currentAccount || currentAccount === "(unset)") {
+      console.error("\n[Error] Login appeared to fail or no account selected.");
+      console.error(
+        "Please try running 'gcloud auth login' manually to diagnose issues."
+      );
+      process.exit(1);
+    }
+    console.log(`Successfully logged in as: ${currentAccount}`);
+  } catch (error) {
+    console.error("\n[Error] Failed to verify logged-in account.");
+    process.exit(1);
+  }
+
   console.log("Initiating Application Default Credentials (ADC) login...");
   runCommandSync(
     `gcloud auth application-default login --scopes="${scopes}" ${clientFlag}`
@@ -543,7 +570,7 @@ export async function authenticateUser() {
     );
   }
 
-  const currentProject = execSync("gcloud config get project")
+  const currentProject = execSync("gcloud config get project", { shell: true })
     .toString()
     .trim();
   console.log(
@@ -551,11 +578,12 @@ export async function authenticateUser() {
   );
 
   console.log("\nFetching token information...");
-  const userToken = execSync("gcloud auth print-access-token")
+  const userToken = execSync("gcloud auth print-access-token", { shell: true })
     .toString()
     .trim();
   const appDefaultToken = execSync(
-    "gcloud auth application-default print-access-token"
+    "gcloud auth application-default print-access-token",
+    { shell: true }
   )
     .toString()
     .trim();
@@ -586,6 +614,7 @@ export function enableGoogleAPIs(options) {
     docs: "docs.googleapis.com",
     gmail: "gmail.googleapis.com",
     logging: "logging.googleapis.com",
+    calendar: "calendar"
   };
 
   const servicesToEnable = new Set();

package/src/cli/utils.js

@@ -4,7 +4,7 @@ const require = createRequire(import.meta.url);
 const pjson = require("../../package.json");
 
 export const VERSION = pjson.version;
-export const CLI_VERSION = "0.0.18"; // Kept from original logic
+export const CLI_VERSION = "0.0.19";
 export const MCP_VERSION = "0.0.7";
 
 /**
@@ -25,7 +25,8 @@ export function normalizeScriptNewlines(text) {
  */
 export function spawnCommand(command, args) {
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args);
+    // shell: true is important for Windows to find .cmd/.bat files correctly
+    const child = spawn(command, args, { shell: true });
     let stdout = "";
     let stderr = "";
 
@@ -74,7 +75,9 @@ export async function checkForGcloudCli() {
  */
 export function runCommandSync(command) {
   try {
-    execSync(command, { stdio: "inherit" });
+    // shell: true is explicitly added to ensure compatibility on Windows,
+    // especially for handling interactive commands or batch files like gcloud.cmd
+    execSync(command, { stdio: "inherit", shell: true });
   } catch (error) {
     console.error(`\nError executing command: ${command}`);
     process.exit(1);

package/src/index.js

@@ -7,6 +7,7 @@ import './services/urlfetchapp/app.js'
 import './services/utilities/app.js'
 import './services/spreadsheetapp/app.js'
 import './services/gmailapp/app.js'
+import './services/calendarapp/app.js'
 import './services/session/app.js'
 import './services/advdrive/app.js'
 import './services/advsheets/app.js'

package/src/services/advcalendar/clapis.js

@@ -0,0 +1,14 @@
+import { google } from "googleapis";
+import { Auth } from '../../support/auth.js'
+import { syncLog } from '../../support/workersync/synclogger.js'
+
+let __client = null;
+syncLog('...importing Calendar API');
+export const getCalendarApiClient = () => {
+  const auth = Auth.getAuthClient()
+  if (!__client) {
+    syncLog('Creating new Calendar API client');
+    __client = google.calendar({ version: 'v3', auth });
+  }
+  return __client;
+}

package/src/services/advcalendar/fakeadvcalendarcalendarlist.js

@@ -18,4 +18,34 @@ class FakeAdvCalendarCalendarList extends FakeAdvResource {
     this.calendar = mainService;
     this.__fakeObjectType = "Calendar.CalendarList";
   }
+
+  list(options = {}) {
+    const { response, data } = this._call("list", options);
+    return data;
+  }
+
+  get(calendarId, options) {
+    const { response, data } = this._call("get", { calendarId, ...options });
+    return data;
+  }
+
+  insert(requestBody, options) {
+    const { response, data } = this._call("insert", { requestBody, ...options });
+    return data;
+  }
+
+  patch(requestBody, calendarId, options) {
+    const { response, data } = this._call("patch", { calendarId, requestBody, ...options });
+    return data;
+  }
+
+  update(requestBody, calendarId, options) {
+    const { response, data } = this._call("update", { calendarId, requestBody, ...options });
+    return data;
+  }
+
+  remove(calendarId, options) {
+    const { response, data } = this._call("remove", { calendarId, ...options });
+    return data;
+  }
 }

package/src/services/advcalendar/fakeadvcalendarcalendars.js

@@ -18,4 +18,29 @@ class FakeAdvCalendarCalendars extends FakeAdvResource {
     this.calendar = mainService;
     this.__fakeObjectType = "Calendar.Calendars";
   }
+
+  get(calendarId, options) {
+    const { response, data } = this._call("get", { calendarId, ...options });
+    return data;
+  }
+
+  insert(requestBody, options) {
+    const { response, data } = this._call("insert", { requestBody, ...options });
+    return data;
+  }
+
+  patch(requestBody, calendarId, options) {
+    const { response, data } = this._call("patch", { calendarId, requestBody, ...options });
+    return data;
+  }
+
+  update(requestBody, calendarId, options) {
+    const { response, data } = this._call("update", { calendarId, requestBody, ...options });
+    return data;
+  }
+
+  delete(calendarId, options) {
+    const { response, data } = this._call("delete", { calendarId, ...options });
+    return data;
+  }
 }

package/src/services/advcalendar/fakeadvcalendarevents.js

@@ -18,4 +18,54 @@ class FakeAdvCalendarEvents extends FakeAdvResource {
     this.calendar = mainService;
     this.__fakeObjectType = "Calendar.Events";
   }
-}
+
+  list(calendarId, options) {
+    const { response, data } = this._call("list", { calendarId, ...options });
+    return data;
+  }
+
+  get(calendarId, eventId, options) {
+    const { response, data } = this._call("get", { calendarId, eventId, ...options });
+    return data;
+  }
+
+  insert(requestBody, calendarId, options) {
+    const { response, data } = this._call("insert", { calendarId, requestBody, ...options });
+    return data;
+  }
+
+  update(requestBody, calendarId, eventId, options) {
+    const { response, data } = this._call("update", { calendarId, eventId, requestBody, ...options });
+    return data;
+  }
+
+  patch(requestBody, calendarId, eventId, options) {
+    const { response, data } = this._call("patch", { calendarId, eventId, requestBody, ...options });
+    return data;
+  }
+
+  delete(calendarId, eventId, options) {
+    const { response, data } = this._call("delete", { calendarId, eventId, ...options });
+    return data;
+  }
+
+  quickAdd(calendarId, text, options) {
+    const { response, data } = this._call("quickAdd", { calendarId, text, ...options });
+    return data;
+  }
+
+  move(calendarId, eventId, destinationCalendarId, options) {
+    const { response, data } = this._call("move", { calendarId, eventId, destinationCalendarId, ...options });
+    return data;
+  }
+  
+  import(requestBody, calendarId, options) {
+    const { response, data } = this._call("import", { calendarId, requestBody, ...options });
+    return data;
+  }
+  
+  instances(calendarId, eventId, options) {
+      const { response, data } = this._call("instances", { calendarId, eventId, ...options });
+      return data;
+  }
+}

package/src/services/calendarapp/app.js

@@ -0,0 +1,11 @@
+
+
+/**
+ * the idea here is to create an empty global entry for the singleton
+ * but only load it when it is actually used.
+ */
+import { newFakeCalendarApp as maker } from './fakecalendarapp.js';
+import { lazyLoaderApp } from '../common/lazyloader.js'
+
+let _app = null;
+_app = lazyLoaderApp(_app, 'CalendarApp', maker)

package/src/services/calendarapp/fakecalendar.js

@@ -0,0 +1,328 @@
+import { Proxies } from '../../support/proxies.js';
+import { newFakeCalendarEvent } from './fakecalendarevent.js';
+import { newFakeCalendarEventSeries } from './fakecalendareventseries.js';
+
+export const newFakeCalendar = (...args) => {
+  return Proxies.guard(new FakeCalendar(...args));
+};
+
+/**
+ * Represents a calendar in the CalendarApp service.
+ * @see https://developers.google.com/apps-script/reference/calendar/calendar
+ */
+export class FakeCalendar {
+  /**
+   * @param {string} id The calendar ID.
+   * @param {object} resource The underlying Calendar resource (Advanced).
+   */
+  constructor(id, resource) {
+    this.__id = id;
+  }
+
+  /**
+   * Internal helper to refresh or get the current resource (Calendars).
+   */
+  get __resource() {
+    // calendar caching will will only update if its changed
+    return Calendar.Calendars.get(this.__id);
+  }
+
+  /**
+   * Internal helper to get the current list entry resource (CalendarList).
+   * Used for user-specific properties like color, hidden, selected.
+   */
+  get __listEntry() {
+    try {
+      return Calendar.CalendarList.get(this.__id);
+    } catch (e) {
+      return null;
+    }
+  }
+
+  getId() {
+    return this.__id || this.__resource.id;
+  }
+
+  getName() {
+    // summary can be in list entry (override) or calendar resource
+    const entry = this.__listEntry;
+    if (entry && entry.summaryOverride) return entry.summaryOverride;
+    return this.__resource.summary || '';
+  }
+
+  setName(name) {
+    this.__checkWriteAccess();
+    // Sets the name of the calendar. This updates the global name (Calendars).
+    Calendar.Calendars.patch({ summary: name }, this.getId());
+    return this;
+  }
+
+  getDescription() {
+    return this.__resource.description || '';
+  }
+
+  setDescription(description) {
+    this.__checkWriteAccess();
+    Calendar.Calendars.patch({ description }, this.getId());
+    return this;
+  }
+
+  getTimeZone() {
+    return this.__resource.timeZone || '';
+  }
+
+  setTimeZone(timeZone) {
+    this.__checkWriteAccess();
+    Calendar.Calendars.patch({ timeZone }, this.getId());
+    return this;
+  }
+
+  getColor() {
+    const entry = this.__listEntry;
+    return entry ? entry.backgroundColor : '';
+  }
+
+  setColor(color) {
+    this.__checkWriteAccess();
+    Calendar.CalendarList.patch({ backgroundColor: color }, this.getId());
+    return this;
+  }
+
+  isHidden() {
+    const entry = this.__listEntry;
+    return entry ? !!entry.hidden : false;
+  }
+
+  setHidden(hidden) {
+    this.__checkWriteAccess();
+    Calendar.CalendarList.patch({ hidden }, this.getId());
+    return this;
+  }
+
+  isSelected() {
+    const entry = this.__listEntry;
+    return entry ? !!entry.selected : false;
+  }
+
+  setSelected(selected) {
+    this.__checkWriteAccess();
+    Calendar.CalendarList.patch({ selected }, this.getId());
+    return this;
+  }
+
+  isMyPrimaryCalendar() {
+    return this.getId() === 'primary' || (this.__listEntry && this.__listEntry.primary);
+  }
+
+  isOwnedByMe() {
+    const entry = this.__listEntry;
+    return entry ? entry.accessRole === 'owner' : false;
+  }
+
+  /**
+   * Permanently deletes a calendar.
+   */
+  deleteCalendar() {
+    this.__checkDeleteAccess();
+    Calendar.Calendars.remove(this.getId());
+  }
+
+  unsubscribeFromCalendar() {
+    // Unsubscribes the user from a calendar (removes from list).
+    Calendar.CalendarList.remove(this.getId());
+  }
+
+  // --- Events ---
+
+  createEvent(title, startTime, endTime, options) {
+    if (startTime.getTime() >= endTime.getTime()) {
+      throw new Error('Event start date must be before event end date.');
+    }
+    this.__checkWriteAccess();
+    const resource = {
+      summary: title,
+      start: { dateTime: startTime.toISOString() },
+      end: { dateTime: endTime.toISOString() }
+    };
+    this.__applyEventOptions(resource, options);
+    
+    const args = {};
+    if (options && options.sendInvites) {
+      args.sendUpdates = 'all';
+    }
+
+    const event = Calendar.Events.insert(resource, this.getId(), args);
+    return newFakeCalendarEvent(this.getId(), event);
+  }
+
+  createAllDayEvent(title, startDate, endDateOrOptions, options) {
+    this.__checkWriteAccess();
+    
+    let endDate = startDate;
+    let opts = options;
+
+    if (endDateOrOptions instanceof Date) {
+        endDate = endDateOrOptions;
+    } else if (typeof endDateOrOptions === 'object') {
+        opts = endDateOrOptions;
+        // Single day event, end date should be start date + 1 day for API v3 (exclusive)
+        const nextDay = new Date(startDate);
+        nextDay.setDate(nextDay.getDate() + 1);
+        endDate = nextDay;
+    } else {
+        // Just title and date
+        const nextDay = new Date(startDate);
+        nextDay.setDate(nextDay.getDate() + 1);
+        endDate = nextDay;
+    }
+
+    if (startDate.getTime() >= endDate.getTime()) {
+      throw new Error('Event start date must be before event end date.');
+    }
+
+    const toDateString = (date) => date.toISOString().split('T')[0];
+
+    const resource = {
+        summary: title,
+        start: { date: toDateString(startDate) },
+        end: { date: toDateString(endDate) }
+    };
+    this.__applyEventOptions(resource, opts);
+
+    const args = {};
+    if (opts && opts.sendInvites) {
+        args.sendUpdates = 'all';
+    }
+
+    const event = Calendar.Events.insert(resource, this.getId(), args);
+    return newFakeCalendarEvent(this.getId(), event);
+  }
+
+  createEventFromDescription(description) {
+    this.__checkWriteAccess();
+    const event = Calendar.Events.quickAdd(this.getId(), description);
+    return newFakeCalendarEvent(this.getId(), event);
+  }
+
+  getEvents(startTime, endTime, options) {
+    this.__checkReadAccess();
+    const args = {
+        timeMin: startTime.toISOString(),
+        timeMax: endTime.toISOString(),
+        singleEvents: true // Expand recurring events usually expected
+    };
+    
+    if (options) {
+        if (options.start !== undefined) args.startIndex = options.start; // Note: Not in v3 standard list?
+        if (options.max !== undefined) args.maxResults = options.max;
+        if (options.search) args.q = options.search;
+        if (options.author) { /* Not directly supported in v3 list? */ }
+    }
+
+    const list = Calendar.Events.list(this.getId(), args);
+    return (list.items || []).map(item => newFakeCalendarEvent(this.getId(), item));
+  }
+
+  getEventsForDay(date, options) {
+    const startTime = new Date(date);
+    startTime.setHours(0, 0, 0, 0);
+    const endTime = new Date(date);
+    endTime.setHours(23, 59, 59, 999);
+    return this.getEvents(startTime, endTime, options);
+  }
+
+  getEventById(iCalId) {
+    this.__checkReadAccess();
+    // Apps Script expects iCalUID. Try finding by iCalUID first using list.
+    // This avoids "Not Found" errors in the worker when passing iCalUID to events.get (which expects eventId)
+    const list = Calendar.Events.list(this.getId(), { iCalUID: iCalId });
+    if (list.items && list.items.length > 0) {
+        return newFakeCalendarEvent(this.getId(), list.items[0]);
+    }
+
+    // Fallback: Try getting by eventId directly.
+    try {
+        const event = Calendar.Events.get(this.getId(), iCalId);
+        return newFakeCalendarEvent(this.getId(), event);
+    } catch (e) {
+        return null;
+    }
+  }
+
+  // --- Series ---
+  
+  createEventSeries(title, startTime, endTime, recurrence, options) {
+      // TODO: Implement recurrence conversion to RRULE
+      // For now, simple insert without proper RRULE if Recurrence object not fully implemented
+      return this.createEvent(title, startTime, endTime, options); // Fallback
+  }
+
+  createAllDayEventSeries(title, startDate, recurrence, options) {
+       // TODO
+       return this.createAllDayEvent(title, startDate, options); // Fallback
+  }
+
+  getEventSeriesById(iCalId) {
+      // TODO
+      return null;
+  }
+
+  // --- Internal ---
+
+  __applyEventOptions(resource, options) {
+    if (options) {
+        if (options.description) resource.description = options.description;
+        if (options.location) resource.location = options.location;
+        if (options.guests) resource.attendees = options.guests.split(',').map(e => ({ email: e.trim() }));
+    }
+  }
+
+  __checkAccess(accessType) {
+    const behavior = ScriptApp.__behavior;
+    if (!behavior.sandboxMode) return true;
+
+    const calendarId = this.getId();
+
+    // Session-created calendars are always writable
+    if (behavior.isKnownCalendar(calendarId)) return true;
+
+    // Check whitelist
+    const settings = behavior.sandboxService.CalendarApp;
+    const whitelist = settings && settings.calendarWhitelist;
+
+    if (!whitelist) {
+      throw new Error(`Access to calendar ${calendarId} is denied. No calendar whitelist configured.`);
+    }
+
+    const calendarName = this.getName();
+    // primary check
+    if (calendarId === 'primary') {
+         const entry = whitelist.find(item => item.name === 'Primary' || item.name === 'primary');
+         if (entry && entry[accessType]) return true;
+         // Default primary to accessible if not explicit? Or strictly follow whitelist?
+         // Existing code had "Primary calendar is always accessible" for *read* in CalendarApp.
+         // But here we check specific access.
+    }
+
+    const entry = whitelist.find(item => item.name === calendarName);
+    if (entry && entry[accessType]) {
+      return true;
+    }
+
+    throw new Error(`${accessType} access to calendar "${calendarName}" (${calendarId}) is denied by sandbox rules`);
+  }
+  
+  __checkDeleteAccess() {
+    return this.__checkAccess('write'); // Delete requires write usually? Or 'delete'?
+  }
+  __checkWriteAccess() {
+    return this.__checkAccess('write');
+  }
+  __checkReadAccess() {
+    return this.__checkAccess('read');
+  }
+
+  toString() {
+    return 'Calendar';
+  }
+}

package/src/services/calendarapp/fakecalendarapp.js

@@ -0,0 +1,147 @@
+import { Proxies } from '../../support/proxies.js';
+import * as CalendarEnums from '../enums/calendarenums.js';
+import { newFakeCalendar } from './fakecalendar.js';
+
+/**
+ * Creates a new FakeCalendarApp instance.
+ * @returns {FakeCalendarApp} The new instance.
+ */
+export const newFakeCalendarApp = () => {
+  return Proxies.guard(new FakeCalendarApp());
+};
+
+/**
+ * Placeholder for CalendarApp service.
+ * @see https://developers.google.com/apps-script/reference/calendar/calendar-app
+ */
+export class FakeCalendarApp {
+  constructor() {
+    // Attach enums
+    Object.assign(this, CalendarEnums);
+  }
+
+  createCalendar(name, options = {}) {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'createCalendar');
+    this.__checkUsage('write');
+    const resource = Calendar.Calendars.insert({ summary: name, ...options });
+    if (ScriptApp.__behavior.sandboxMode && resource.id) {
+      ScriptApp.__behavior.addCalendarId(resource.id);
+    }
+    return newFakeCalendar(resource.id, resource);
+  }
+
+  getCalendarById(id) {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getCalendarById');
+    this.__checkUsage('read');
+    this.__checkCalendarAccess(id);
+    const resource = Calendar.Calendars.get(id);
+    return newFakeCalendar(id, resource);
+  }
+
+  getDefaultCalendar() {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getDefaultCalendar');
+    return this.getCalendarById('primary');
+  }
+
+  getCalendarsByName(name) {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getCalendarsByName');
+    this.__checkUsage('read');
+    const list = Calendar.CalendarList.list();
+    return (list.items || [])
+      .filter(item => this.__isCalendarAccessible(item.id))
+      .filter(item => item.summary === name)
+      .map(item => newFakeCalendar(item.id, item));
+  }
+
+  getAllCalendars() {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getAllCalendars');
+    this.__checkUsage('read');
+    const list = Calendar.CalendarList.list();
+    return (list.items || [])
+      .filter(item => this.__isCalendarAccessible(item.id))
+      .map(item => newFakeCalendar(item.id, item));
+  }
+
+  getAllOwnedCalendars() {
+    ScriptApp.__behavior.checkMethod('CalendarApp', 'getAllOwnedCalendars');
+    this.__checkUsage('read');
+    const list = Calendar.CalendarList.list();
+    return (list.items || [])
+      .filter(item => this.__isCalendarAccessible(item.id))
+      .filter(item => item.accessRole === 'owner')
+      .map(item => newFakeCalendar(item.id, item));
+  }
+
+  __isCalendarAccessible(calendarId) {
+    try {
+      this.__checkCalendarAccess(calendarId);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  __checkCalendarAccess(calendarId) {
+    const behavior = ScriptApp.__behavior;
+    if (!behavior.sandboxMode) return true;
+
+    // 1. Session check - calendars created in this session are always accessible
+    if (behavior.isKnownCalendar(calendarId)) return true;
+
+    // 2. Primary calendar is always accessible
+    if (calendarId === 'primary') return true;
+
+    // 3. Whitelist check
+    const settings = behavior.sandboxService.CalendarApp;
+    const whitelist = settings && settings.calendarWhitelist;
+
+    if (!whitelist) {
+      throw new Error(`Access to calendar ${calendarId} is denied. No calendar whitelist configured.`);
+    }
+
+    // Get calendar details to check name
+    const calendar = Calendar.Calendars.get(calendarId);
+    const calendarName = calendar.summary;
+
+    // Check if calendar name is in whitelist with read permission
+    const entry = whitelist.find(item => item.name === calendarName);
+    if (entry && entry.read) {
+      return true;
+    }
+
+    throw new Error(`Access to calendar "${calendarName}" (${calendarId}) is denied by sandbox rules`);
+  }
+
+  __checkUsage(type) {
+    const serviceName = 'CalendarApp';
+    const behavior = ScriptApp.__behavior;
+    if (behavior.sandboxMode) {
+      const settings = behavior.sandboxService[serviceName];
+      let limit = settings && settings.usageLimit;
+      if (limit) {
+        if (typeof limit === 'number') {
+          const total = (settings.usageCount.read || 0) + (settings.usageCount.write || 0) + (settings.usageCount.trash || 0);
+          if (total >= limit) {
+            throw new Error(`Calendar total usage limit of ${limit} exceeded`);
+          }
+          settings.incrementUsage(type);
+          return;
+        }
+
+        let specificLimit = limit[type];
+        if (specificLimit !== undefined) {
+          const current = settings.usageCount[type] || 0;
+          if (current >= specificLimit) {
+            throw new Error(`Calendar ${type} usage limit of ${specificLimit} exceeded`);
+          }
+          settings.incrementUsage(type);
+        }
+      }
+    }
+  }
+
+  // Common pattern in gas-fakes for internal use
+  __addAllowed(id) {
+    // Shared logic with other services to track created resources
+  }
+}

package/src/services/calendarapp/fakecalendarevent.js

@@ -0,0 +1,44 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakeCalendarEvent = (...args) => {
+  return Proxies.guard(new FakeCalendarEvent(...args));
+};
+
+/**
+ * Represents a calendar event.
+ * @see https://developers.google.com/apps-script/reference/calendar/calendar-event
+ */
+export class FakeCalendarEvent {
+  /**
+   * @param {string} calendarId The calendar ID.
+   * @param {object} resource The underlying Event resource (Advanced).
+   */
+  constructor(calendarId, resource) {
+    this.__calendarId = calendarId;
+    this.__id = resource.id;
+    this.__iCalUID = resource.iCalUID;
+  }
+
+  get __resource() {
+    // Try to get by ID
+    try {
+        return Calendar.Events.get(this.__calendarId, this.__id);
+    } catch (e) {
+        // Fallback: search by iCalUID if main ID fails (though usually id is reliable for get)
+        // or if the event was deleted?
+        throw new Error(`Event with ID ${this.__id} not found in calendar ${this.__calendarId}`);
+    }
+  }
+
+  getId() {
+    return this.__resource.iCalUID || this.__resource.id;
+  }
+
+  getTitle() {
+    return this.__resource.summary || '';
+  }
+
+  toString() {
+    return 'CalendarEvent';
+  }
+}

package/src/services/calendarapp/fakecalendareventseries.js

@@ -0,0 +1,36 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakeCalendarEventSeries = (...args) => {
+  return Proxies.guard(new FakeCalendarEventSeries(...args));
+};
+
+/**
+ * Represents a series of events (a recurring event).
+ * @see https://developers.google.com/apps-script/reference/calendar/calendar-event-series
+ */
+export class FakeCalendarEventSeries {
+  /**
+   * @param {string} calendarId The calendar ID.
+   * @param {object} resource The underlying Event resource (Advanced).
+   */
+  constructor(calendarId, resource) {
+    this.__calendarId = calendarId;
+    this.__id = resource.id;
+  }
+
+  get __resource() {
+    try {
+        return Calendar.Events.get(this.__calendarId, this.__id);
+    } catch (e) {
+        throw new Error(`Event Series with ID ${this.__id} not found in calendar ${this.__calendarId}`);
+    }
+  }
+
+  getId() {
+    return this.__resource.iCalUID || this.__resource.id;
+  }
+
+  toString() {
+    return 'CalendarEventSeries';
+  }
+}

package/src/services/calendarapp/fakeeventrecurrence.js

@@ -0,0 +1,19 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakeEventRecurrence = (...args) => {
+  return Proxies.guard(new FakeEventRecurrence(...args));
+};
+
+/**
+ * Represents the recurrence settings for an event series.
+ * @see https://developers.google.com/apps-script/reference/calendar/event-recurrence
+ */
+export class FakeEventRecurrence {
+  constructor() {
+    // TODO: Implement recurrence rules storage
+  }
+
+  toString() {
+    return 'EventRecurrence';
+  }
+}

package/src/services/enums/calendarenums.js

@@ -0,0 +1,85 @@
+import { newFakeGasenum} from "@mcpher/fake-gasenum";
+export const Color = newFakeGasenum([
+  "BLUE",
+  "BROWN",
+  "CHARCOAL",
+  "CHESTNUT",
+  "GRAY",
+  "GREEN",
+  "INDIGO",
+  "LIME",
+  "MUSTARD",
+  "OLIVE",
+  "ORANGE",
+  "PINK",
+  "PLUM",
+  "PURPLE",
+  "RED",
+  "RED_ORANGE",
+  "SEA_BLUE",
+  "SLATE",
+  "TEAL",
+  "TURQOISE",
+  "YELLOW"
+])
+export const EventColor = newFakeGasenum([
+  "BLUE",
+  "CYAN",
+  "GRAY",
+  "GREEN",
+  "MAUVE",
+  "ORANGE",
+  "PALE_BLUE",
+  "PALE_GREEN",
+  "PALE_RED",
+  "RED",
+  "YELLOW"
+])
+export const EventTransparency = newFakeGasenum([
+  "OPAQUE",
+  "TRANSPARENT"
+])
+export const EventType = newFakeGasenum([
+  "DEFAULT",
+  "BIRTHDAY",
+  "FOCUS_TIME",
+  "FROM_GMAIL",
+  "OUT_OF_OFFICE",
+  "WORKING_LOCATION"
+])
+export const GuestStatus = newFakeGasenum([
+  "INVITED",
+  "MAYBE",
+  "NO",
+  "OWNER",
+  "YES"
+])
+export const Month = newFakeGasenum([
+  "JANUARY",
+  "FEBRUARY",
+  "MARCH",
+  "APRIL",
+  "MAY",
+  "JUNE",
+  "JULY",
+  "AUGUST",
+  "SEPTEMBER",
+  "OCTOBER",
+  "NOVEMBER",
+  "DECEMBER"
+])
+export const Visibility = newFakeGasenum([
+  "CONFIDENTIAL",
+  "DEFAULT",
+  "PRIVATE",
+  "PUBLIC"
+])
+export const Weekday = newFakeGasenum([
+  "SUNDAY",
+  "MONDAY",
+  "TUESDAY",
+  "WEDNESDAY",
+  "THURSDAY",
+  "FRIDAY",
+  "SATURDAY"
+])

package/src/services/scriptapp/behavior.js

@@ -17,6 +17,7 @@ const serviceModel = {
   methodWhitelist: null,
   emailWhitelist: null,
   labelWhitelist: null,
+  calendarWhitelist: null,
   usageLimit: null,
   usageCount: 0
 }
@@ -169,6 +170,17 @@ class FakeSandboxService {
     return this.__state.labelWhitelist
   }
 
+  set calendarWhitelist(value) {
+    if (!is.null(value)) {
+      checkArgs(value, "array")
+      // We expect objects like { name: 'calendar-name', read?: boolean, write?: boolean, delete?: boolean }
+    }
+    this.__state.calendarWhitelist = value
+  }
+  get calendarWhitelist() {
+    return this.__state.calendarWhitelist
+  }
+
   set usageLimit(value) {
     if (!is.null(value)) {
       // expect object with read, write, trash keys optionally
@@ -211,6 +223,11 @@ class FakeSandboxService {
     return this.__state.usageCount[type];
   }
 
+  resetUsageCount() {
+    this.__state.usageCount = { read: 0, write: 0, trash: 0, send: 0 };
+    return this;
+  }
+
   set enabled(value) {
     this.__state.enabled = checkArgs(value)
   }
@@ -236,6 +253,7 @@ class FakeBehavior {
     // key is the file id
     this.__createdIds = new Set();
     this.__createdGmailIds = new Set();
+    this.__createdCalendarIds = new Set();
     // in sandbox mode we only allow access to files created in this instance
     // this is to emulate the behavior of a drive.file scope
     this.__sandboxMode = false;
@@ -347,6 +365,18 @@ class FakeBehavior {
     }
     return id
   }
+  addCalendarId(id) {
+    if (this.sandboxMode) {
+      if (!is.nonEmptyString(id)) {
+        throw new Error(`Invalid sandbox id parameter (${id}) - must be a non-empty string`);
+      }
+      if (!this.isKnownCalendar(id)) {
+        slogger.log(`...adding calendar id ${id} to sandbox allowed list`);
+        this.__createdCalendarIds.add(id);
+      }
+    }
+    return id
+  }
   isAccessible(id, serviceName, accessType = 'read') {
     if (this.sandboxMode && !is.nonEmptyString(id)) {
       throw new Error(`Invalid sandbox id parameter (${id}) - must be a non-empty string`);
@@ -510,7 +540,29 @@ class FakeBehavior {
       slogger.log('...skipping cleaning up sandbox files (Gmail)');
     }
 
-    slogger.log(`...trashed ${trashed.length} sandboxed files and ${trashedGmail.length} gmail items`);
+    // Clean up Calendar artifacts
+    let trashedCalendars = [];
+    const calendarSettings = this.sandboxService.CalendarApp;
+    const calendarCleanup = calendarSettings && calendarSettings.cleanup;
+
+    if (calendarCleanup) {
+      trashedCalendars = Array.from(this.__createdCalendarIds).reduce((acc, id) => {
+        try {
+          // Delete calendar
+          Calendar.Calendars.delete(id);
+          slogger.log(`...deleted calendar ${id}`);
+          acc.push(id);
+        } catch (e) {
+          slogger.log(`...failed to delete calendar ${id}: ${e.message}`);
+        }
+        return acc;
+      }, []);
+      this.__createdCalendarIds.clear();
+    } else {
+      slogger.log('...skipping cleaning up sandbox calendars');
+    }
+
+    slogger.log(`...trashed ${trashed.length} sandboxed files, ${trashedGmail.length} gmail items, and ${trashedCalendars.length} calendars`);
     return trashed;
   }
   isKnown(id) {
@@ -519,4 +571,7 @@ class FakeBehavior {
   isKnownGmail(id) {
     return this.__createdGmailIds.has(id);
   }
+  isKnownCalendar(id) {
+    return this.__createdCalendarIds.has(id);
+  }
 }

package/src/support/sxcalendar.js

@@ -0,0 +1,61 @@
+/**
+ * CALENDAR
+ * all these functions run in the worker
+ * thus turning async operations into sync
+ * note
+ * - arguments and returns must be serializable ie. primitives or plain objects
+ */
+
+import { responseSyncify } from './auth.js';
+import { syncWarn, syncError } from './workersync/synclogger.js';
+import { getCalendarApiClient } from '../services/advcalendar/clapis.js';
+
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+/**
+ * sync a call to calendar api
+ * @param {object} Auth the auth object
+ * @param {object} p pargs
+ * @param {string} p.prop the prop of calendar eg 'calendars' for calendar.calendars
+ * @param {string} p.method the method of calendar eg 'get' for calendar.calendars.get
+ * @param {object} p.params the params to add to the request
+ * @param {object} p.options gaxios options
+ * @return {import('./sxdrive.js').SxResult} from the Calendar api
+ */
+export const sxCalendar = async (Auth, { prop, method, params, options = {} }) => {
+
+  const apiClient = getCalendarApiClient();
+
+  const maxRetries = 7;
+  let delay = 1777;
+
+  for (let i = 0; i < maxRetries; i++) {
+    let response;
+    let error;
+
+    try {
+      const callish = apiClient[prop];
+      response = await callish[method](params, options);
+    } catch (err) {
+      error = err;
+      response = err.response;
+    }
+
+    const isRetryable = [429, 500, 503].includes(response?.status) || error?.code == 429;
+
+    if (isRetryable && i < maxRetries - 1) {
+      // add a random jitter to avoid thundering herd
+      const jitter = Math.floor(Math.random() * 1000);
+      syncWarn(`Retryable error on Calendar API call ${prop}.${method} (status: ${response?.status}). Retrying in ${delay + jitter}ms...`);
+      await sleep(delay + jitter);
+      delay *= 2;
+      continue;
+    }
+
+    if (error || isRetryable) {
+      syncError(`Failed in sxCalendar for ${prop}.${method}`, error);
+      return { data: null, response: responseSyncify(response) };
+    }
+    return { data: response.data, response: responseSyncify(response) };
+  }
+};

package/src/support/syncit.js

@@ -17,6 +17,7 @@ import { gmailCacher } from "./gmailcacher.js";
 import { formsCacher } from "./formscacher.js";
 import { slidesCacher } from "./slidescacher.js";
 import { sheetsCacher } from "./sheetscacher.js";
+import { calendarCacher } from "./calendarcacher.js";
 import is from "@sindresorhus/is";
 import { callSync } from "./workersync/synchronizer.js";
 
@@ -401,6 +402,13 @@ const fxGmail = (args) =>
     cacher: gmailCacher,
     idField: "id",
   });
+const fxCalendar = (args) =>
+  fxGeneric({
+    ...args,
+    serviceName: "Calendar",
+    cacher: calendarCacher,
+    idField: "calendarId",
+  });
 
 // const fxGetImagesFromXlsx = (args) => callSync("sxGetImagesFromXlsx", args);
 
@@ -421,5 +429,6 @@ export const Syncit = {
   fxDocs,
   fxForms,
   fxGmail,
+  fxCalendar,
   fxDriveExport
 }

package/src/support/workersync/sxfunctions.js

@@ -8,6 +8,7 @@ export * from "../sxstore.js";
 export * from "../sxzip.js";
 export * from "../sxauth.js";
 export * from "../sxgmail.js";
+export * from "../sxcalendar.js";
 export * from "../sxxlsx.js";