@hmawla/co-assistant 1.0.6 → 1.0.7

package/plugins/google-calendar/index.compiled.mjs

@@ -0,0 +1,361 @@
+// plugins/google-calendar/auth.ts
+var TOKEN_ENDPOINT = "https://oauth2.googleapis.com/token";
+var EXPIRY_MARGIN_MS = 6e4;
+var CalendarAuth = class {
+  clientId;
+  clientSecret;
+  refreshToken;
+  accessToken = null;
+  expiresAt = 0;
+  constructor(clientId, clientSecret, refreshToken) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.refreshToken = refreshToken;
+  }
+  /**
+   * Check whether all required credentials have been provided.
+   */
+  isConfigured() {
+    return Boolean(this.clientId && this.clientSecret && this.refreshToken);
+  }
+  /**
+   * Return a valid access token, refreshing it first if necessary.
+   *
+   * @throws {Error} If credentials are missing or the token exchange fails.
+   */
+  async getAccessToken() {
+    if (!this.isConfigured()) {
+      throw new Error(
+        "CalendarAuth is not configured \u2014 client ID, client secret, and refresh token are all required."
+      );
+    }
+    if (this.accessToken && Date.now() < this.expiresAt) {
+      return this.accessToken;
+    }
+    const body = new URLSearchParams({
+      client_id: this.clientId,
+      client_secret: this.clientSecret,
+      refresh_token: this.refreshToken,
+      grant_type: "refresh_token"
+    });
+    const response = await fetch(TOKEN_ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: body.toString()
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(
+        `Failed to refresh Google access token (${response.status}): ${text}`
+      );
+    }
+    const data = await response.json();
+    this.accessToken = data.access_token;
+    this.expiresAt = Date.now() + data.expires_in * 1e3 - EXPIRY_MARGIN_MS;
+    return this.accessToken;
+  }
+};
+
+// plugins/google-calendar/tools.ts
+var CALENDAR_API = "https://www.googleapis.com/calendar/v3";
+async function calendarFetch(auth, path, options = {}) {
+  const token = await auth.getAccessToken();
+  const res = await fetch(`${CALENDAR_API}${path}`, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Google Calendar API error (${res.status}): ${text}`);
+  }
+  if (res.status === 204) return { success: true };
+  return res.json();
+}
+function formatEventTime(dt) {
+  if (dt.dateTime) {
+    return new Date(dt.dateTime).toLocaleString("en-US", {
+      weekday: "short",
+      month: "short",
+      day: "numeric",
+      year: "numeric",
+      hour: "numeric",
+      minute: "2-digit",
+      timeZoneName: "short"
+    });
+  }
+  if (dt.date) {
+    return (/* @__PURE__ */ new Date(dt.date + "T00:00:00")).toLocaleDateString("en-US", {
+      weekday: "short",
+      month: "short",
+      day: "numeric",
+      year: "numeric"
+    });
+  }
+  return "N/A";
+}
+function formatEvent(event) {
+  const lines = [];
+  lines.push(`\u{1F4C5} ${event.summary ?? "(no title)"}`);
+  if (event.start) lines.push(`   Start: ${formatEventTime(event.start)}`);
+  if (event.end) lines.push(`   End:   ${formatEventTime(event.end)}`);
+  if (event.location) lines.push(`   \u{1F4CD} ${event.location}`);
+  if (event.description) lines.push(`   ${event.description}`);
+  if (event.attendees?.length) {
+    const emails = event.attendees.map((a) => a.email).join(", ");
+    lines.push(`   \u{1F465} ${emails}`);
+  }
+  lines.push(`   ID: ${event.id}`);
+  return lines.join("\n");
+}
+function createCalendarTools(auth) {
+  const listEvents = {
+    name: "list_events",
+    description: "List upcoming calendar events. Optionally filter by date range.",
+    parameters: {
+      type: "object",
+      properties: {
+        maxResults: {
+          type: "number",
+          description: "Maximum number of events to return (default 10)."
+        },
+        timeMin: {
+          type: "string",
+          description: "Start of the time range as an ISO 8601 date-time string. Defaults to now."
+        },
+        timeMax: {
+          type: "string",
+          description: "End of the time range as an ISO 8601 date-time string."
+        },
+        calendarId: {
+          type: "string",
+          description: 'Calendar ID to query (default "primary").'
+        }
+      }
+    },
+    handler: async (args) => {
+      try {
+        const calendarId = encodeURIComponent(
+          args.calendarId ?? "primary"
+        );
+        const params = new URLSearchParams({
+          maxResults: String(args.maxResults ?? 10),
+          timeMin: args.timeMin ?? (/* @__PURE__ */ new Date()).toISOString(),
+          orderBy: "startTime",
+          singleEvents: "true"
+        });
+        if (args.timeMax) params.set("timeMax", args.timeMax);
+        const data = await calendarFetch(
+          auth,
+          `/calendars/${calendarId}/events?${params.toString()}`
+        );
+        const events = data.items ?? [];
+        if (events.length === 0) {
+          return "No upcoming events found.";
+        }
+        return events.map(formatEvent).join("\n\n");
+      } catch (error) {
+        return `Error listing events: ${error.message}`;
+      }
+    }
+  };
+  const createEvent = {
+    name: "create_event",
+    description: "Create a new calendar event.",
+    parameters: {
+      type: "object",
+      properties: {
+        summary: { type: "string", description: "Event title." },
+        description: { type: "string", description: "Event description." },
+        startTime: {
+          type: "string",
+          description: "Start date-time in ISO 8601 format."
+        },
+        endTime: {
+          type: "string",
+          description: "End date-time in ISO 8601 format."
+        },
+        location: { type: "string", description: "Event location." },
+        attendees: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of attendee email addresses."
+        },
+        calendarId: {
+          type: "string",
+          description: 'Calendar ID (default "primary").'
+        }
+      },
+      required: ["summary", "startTime", "endTime"]
+    },
+    handler: async (args) => {
+      try {
+        const calendarId = encodeURIComponent(
+          args.calendarId ?? "primary"
+        );
+        const body = {
+          summary: args.summary,
+          start: { dateTime: args.startTime },
+          end: { dateTime: args.endTime }
+        };
+        if (args.description) body.description = args.description;
+        if (args.location) body.location = args.location;
+        if (args.attendees) {
+          body.attendees = args.attendees.map((email) => ({
+            email
+          }));
+        }
+        const event = await calendarFetch(
+          auth,
+          `/calendars/${calendarId}/events`,
+          { method: "POST", body: JSON.stringify(body) }
+        );
+        return `\u2705 Event created successfully!
+
+${formatEvent(event)}`;
+      } catch (error) {
+        return `Error creating event: ${error.message}`;
+      }
+    }
+  };
+  const updateEvent = {
+    name: "update_event",
+    description: "Update an existing calendar event by event ID.",
+    parameters: {
+      type: "object",
+      properties: {
+        eventId: { type: "string", description: "The event ID to update." },
+        summary: { type: "string", description: "New event title." },
+        description: { type: "string", description: "New event description." },
+        startTime: {
+          type: "string",
+          description: "New start date-time in ISO 8601 format."
+        },
+        endTime: {
+          type: "string",
+          description: "New end date-time in ISO 8601 format."
+        },
+        location: { type: "string", description: "New event location." },
+        calendarId: {
+          type: "string",
+          description: 'Calendar ID (default "primary").'
+        }
+      },
+      required: ["eventId"]
+    },
+    handler: async (args) => {
+      try {
+        const calendarId = encodeURIComponent(
+          args.calendarId ?? "primary"
+        );
+        const eventId = encodeURIComponent(args.eventId);
+        const body = {};
+        if (args.summary !== void 0) body.summary = args.summary;
+        if (args.description !== void 0)
+          body.description = args.description;
+        if (args.startTime !== void 0)
+          body.start = { dateTime: args.startTime };
+        if (args.endTime !== void 0) body.end = { dateTime: args.endTime };
+        if (args.location !== void 0) body.location = args.location;
+        const event = await calendarFetch(
+          auth,
+          `/calendars/${calendarId}/events/${eventId}`,
+          { method: "PATCH", body: JSON.stringify(body) }
+        );
+        return `\u2705 Event updated successfully!
+
+${formatEvent(event)}`;
+      } catch (error) {
+        return `Error updating event: ${error.message}`;
+      }
+    }
+  };
+  const deleteEvent = {
+    name: "delete_event",
+    description: "Delete a calendar event by event ID.",
+    parameters: {
+      type: "object",
+      properties: {
+        eventId: { type: "string", description: "The event ID to delete." },
+        calendarId: {
+          type: "string",
+          description: 'Calendar ID (default "primary").'
+        }
+      },
+      required: ["eventId"]
+    },
+    handler: async (args) => {
+      try {
+        const calendarId = encodeURIComponent(
+          args.calendarId ?? "primary"
+        );
+        const eventId = encodeURIComponent(args.eventId);
+        await calendarFetch(
+          auth,
+          `/calendars/${calendarId}/events/${eventId}`,
+          { method: "DELETE" }
+        );
+        return `\u2705 Event ${args.eventId} deleted successfully.`;
+      } catch (error) {
+        return `Error deleting event: ${error.message}`;
+      }
+    }
+  };
+  return [listEvents, createEvent, updateEvent, deleteEvent];
+}
+
+// plugins/google-calendar/index.ts
+var createPlugin = () => {
+  let auth;
+  let tools = [];
+  let logger;
+  return {
+    id: "google-calendar",
+    name: "Google Calendar Plugin",
+    version: "1.0.0",
+    description: "View, create, and manage Google Calendar events",
+    requiredCredentials: [
+      "GCAL_CLIENT_ID",
+      "GCAL_CLIENT_SECRET",
+      "GCAL_REFRESH_TOKEN"
+    ],
+    async initialize(context) {
+      logger = context.logger;
+      logger.info("Initialising Google Calendar plugin\u2026");
+      auth = new CalendarAuth(
+        context.credentials.GCAL_CLIENT_ID,
+        context.credentials.GCAL_CLIENT_SECRET,
+        context.credentials.GCAL_REFRESH_TOKEN
+      );
+      if (!auth.isConfigured()) {
+        throw new Error(
+          "Google Calendar plugin is missing one or more required credentials."
+        );
+      }
+      tools = createCalendarTools(auth);
+      logger.info(`Registered ${tools.length} calendar tools`);
+    },
+    getTools() {
+      return tools;
+    },
+    async destroy() {
+      tools = [];
+      logger?.info("Google Calendar plugin destroyed");
+    },
+    async healthCheck() {
+      try {
+        await auth.getAccessToken();
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+};
+var index_default = createPlugin;
+export {
+  index_default as default
+};