@mcpher/gas-fakes 1.2.26 → 1.2.28

package/package.json

@@ -34,7 +34,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "1.2.26",
+  "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",
@@ -408,9 +413,9 @@ export async function initializeConfiguration(options = {}) {
 /**
  * Handles the 'auth' command to authenticate with Google Cloud.
  */
-export function authenticateUser() {
+export async function authenticateUser() {
   // First, check if gcloud CLI is available.
-  checkForGcloudCli();
+  await checkForGcloudCli();
 
   const rootDirectory = process.cwd();
   const envPath = path.join(rootDirectory, ".env");
@@ -486,13 +491,14 @@ export 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 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 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 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 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

@@ -1,11 +1,10 @@
-import { spawn } from "child_process";
+import { spawn, execSync } from "child_process";
 import { createRequire } from "node:module";
-
 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";
 
 /**
@@ -26,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 = "";
 
@@ -73,10 +73,11 @@ export async function checkForGcloudCli() {
 /**
  * Helper function to run a shell command sync (used in setup).
  */
-export async function runCommandSync(command) {
-  const { execSync } = await import("child_process");
+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';
+  }
+}