@agent-native/scheduling 0.1.1

package/src/server/providers/builtin-video.ts

@@ -0,0 +1,62 @@
+/**
+ * Built-in video provider (Daily.co) — zero-OAuth video provider driven by a
+ * server-to-server API key. Creates a Daily.co room per booking.
+ */
+import type { VideoProvider } from "./types.js";
+
+export interface DailyVideoProviderConfig {
+  apiKey: string;
+  /** Prefix for Daily room names; defaults to "room-" */
+  roomPrefix?: string;
+}
+
+export function createDailyVideoProvider(
+  config: DailyVideoProviderConfig,
+): VideoProvider {
+  const prefix = config.roomPrefix ?? "room-";
+  async function apiCall<T>(path: string, init?: RequestInit): Promise<T> {
+    const res = await fetch(`https://api.daily.co/v1${path}`, {
+      ...init,
+      headers: {
+        ...(init?.headers ?? {}),
+        authorization: `Bearer ${config.apiKey}`,
+        "content-type": "application/json",
+      },
+    });
+    if (!res.ok) {
+      throw new Error(`Daily.co ${res.status}: ${await res.text()}`);
+    }
+    if (res.status === 204) return undefined as unknown as T;
+    return (await res.json()) as T;
+  }
+  return {
+    kind: "builtin_video",
+    label: "Built-in video",
+    async createMeeting({ booking }) {
+      const roomName = `${prefix}${booking.uid}`.slice(0, 40);
+      const resp = await apiCall<{ url: string; name: string }>("/rooms", {
+        method: "POST",
+        body: JSON.stringify({
+          name: roomName,
+          properties: {
+            nbf: Math.floor(new Date(booking.startTime).getTime() / 1000),
+            exp: Math.floor(new Date(booking.endTime).getTime() / 1000) + 3600,
+            enable_prejoin_ui: true,
+            enable_chat: true,
+            enable_knocking: true,
+            eject_at_room_exp: true,
+          },
+        }),
+      });
+      return {
+        meetingUrl: resp.url,
+        meetingId: resp.name,
+      };
+    },
+    async deleteMeeting({ meetingId }) {
+      await apiCall(`/rooms/${encodeURIComponent(meetingId)}`, {
+        method: "DELETE",
+      });
+    },
+  };
+}

package/src/server/providers/google-calendar.ts

@@ -0,0 +1,237 @@
+/**
+ * Google Calendar provider.
+ *
+ * Thin adapter over the Google Calendar API. Consumers wire it up by
+ * calling `createGoogleCalendarProvider()` with accessors that return
+ * OAuth tokens from their preferred store (typically core's oauth_tokens).
+ *
+ * This lives in the package rather than the template because the logic is
+ * the same for every scheduling consumer. Custom token stores are supported
+ * via the `getAccessToken` callback.
+ */
+import type { CalendarProvider } from "./types.js";
+import type { BusyInterval, Booking } from "../../shared/index.js";
+
+export interface GoogleCalendarProviderConfig {
+  clientId: string;
+  clientSecret: string;
+  /** Resolve a fresh access token for a given credentialId (refresh if needed). */
+  getAccessToken: (credentialId: string) => Promise<string>;
+  /** Persist updated refresh/access tokens after a refresh. */
+  updateTokens?: (
+    credentialId: string,
+    tokens: { accessToken: string; refreshToken?: string; expiresAt?: Date },
+  ) => Promise<void>;
+  /** Called when the API returns 401/403; the consumer should mark the credential invalid. */
+  markInvalid?: (credentialId: string) => Promise<void>;
+}
+
+const SCOPES = [
+  "https://www.googleapis.com/auth/calendar",
+  "https://www.googleapis.com/auth/calendar.events",
+];
+
+export function createGoogleCalendarProvider(
+  config: GoogleCalendarProviderConfig,
+): CalendarProvider {
+  async function apiCall<T>(
+    credentialId: string,
+    url: string,
+    init?: RequestInit,
+  ): Promise<T> {
+    const token = await config.getAccessToken(credentialId);
+    const res = await fetch(url, {
+      ...init,
+      headers: {
+        ...(init?.headers ?? {}),
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json",
+      },
+    });
+    if (res.status === 401 || res.status === 403) {
+      await config.markInvalid?.(credentialId);
+      throw new Error(`Google Calendar: credential invalid (${res.status})`);
+    }
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Google Calendar API ${res.status}: ${body}`);
+    }
+    if (res.status === 204) return undefined as unknown as T;
+    return (await res.json()) as T;
+  }
+
+  return {
+    kind: "google_calendar",
+    label: "Google Calendar",
+
+    async startOAuth({ redirectUri, state }) {
+      const params = new URLSearchParams({
+        client_id: config.clientId,
+        redirect_uri: redirectUri,
+        response_type: "code",
+        scope: SCOPES.join(" "),
+        access_type: "offline",
+        include_granted_scopes: "true",
+        prompt: "consent",
+        state,
+      });
+      return {
+        authUrl: `https://accounts.google.com/o/oauth2/v2/auth?${params}`,
+      };
+    },
+
+    async completeOAuth({ code, redirectUri, credentialId, userEmail }) {
+      const body = new URLSearchParams({
+        code,
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        redirect_uri: redirectUri,
+        grant_type: "authorization_code",
+      });
+      const tokenRes = await fetch("https://oauth2.googleapis.com/token", {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body,
+      });
+      if (!tokenRes.ok) {
+        throw new Error(
+          `Google token exchange failed: ${tokenRes.status} ${await tokenRes.text()}`,
+        );
+      }
+      const tokens = await tokenRes.json();
+      await config.updateTokens?.(credentialId, {
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        expiresAt: new Date(Date.now() + (tokens.expires_in ?? 3600) * 1000),
+      });
+
+      // Discover external email + calendar list
+      const calendars = await apiCall<{
+        items: { id: string; summary: string; primary?: boolean }[];
+      }>(
+        credentialId,
+        "https://www.googleapis.com/calendar/v3/users/me/calendarList",
+      );
+      const primary = calendars.items.find((c) => c.primary);
+      return {
+        externalEmail: primary?.id ?? userEmail,
+        calendars: calendars.items.map((c) => ({
+          externalId: c.id,
+          name: c.summary,
+          primary: Boolean(c.primary),
+        })),
+      };
+    },
+
+    async listCalendars({ credentialId }) {
+      const resp = await apiCall<{
+        items: { id: string; summary: string; primary?: boolean }[];
+      }>(
+        credentialId,
+        "https://www.googleapis.com/calendar/v3/users/me/calendarList",
+      );
+      return resp.items.map((c) => ({
+        externalId: c.id,
+        name: c.summary,
+        primary: Boolean(c.primary),
+      }));
+    },
+
+    async getBusy({ credentialId, calendarExternalIds, start, end }) {
+      const resp = await apiCall<{
+        calendars: Record<string, { busy: { start: string; end: string }[] }>;
+      }>(credentialId, "https://www.googleapis.com/calendar/v3/freeBusy", {
+        method: "POST",
+        body: JSON.stringify({
+          timeMin: start.toISOString(),
+          timeMax: end.toISOString(),
+          items: calendarExternalIds.map((id) => ({ id })),
+        }),
+      });
+      const out: BusyInterval[] = [];
+      for (const [calId, data] of Object.entries(resp.calendars)) {
+        for (const b of data.busy) {
+          out.push({ start: b.start, end: b.end, source: calId });
+        }
+      }
+      return out;
+    },
+
+    async createEvent({
+      credentialId,
+      calendarExternalId,
+      booking,
+      includeConference,
+    }) {
+      const body: any = {
+        summary: booking.title,
+        description: booking.description,
+        start: { dateTime: booking.startTime, timeZone: booking.timezone },
+        end: { dateTime: booking.endTime, timeZone: booking.timezone },
+        attendees: [
+          { email: booking.hostEmail, organizer: true },
+          ...booking.attendees.map((a) => ({
+            email: a.email,
+            displayName: a.name,
+          })),
+        ],
+        iCalUID: booking.iCalUid,
+        sequence: booking.iCalSequence,
+      };
+      if (booking.location) {
+        if (booking.location.address) body.location = booking.location.address;
+        else if (booking.location.link) body.location = booking.location.link;
+      }
+      let query = "?sendUpdates=all";
+      if (includeConference) {
+        body.conferenceData = {
+          createRequest: {
+            requestId: booking.uid,
+            conferenceSolutionKey: { type: "hangoutsMeet" },
+          },
+        };
+        query += "&conferenceDataVersion=1";
+      }
+      const resp = await apiCall<any>(
+        credentialId,
+        `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarExternalId)}/events${query}`,
+        { method: "POST", body: JSON.stringify(body) },
+      );
+      return {
+        externalId: resp.id,
+        meetingUrl:
+          resp.hangoutLink ??
+          resp.conferenceData?.entryPoints?.find(
+            (e: any) => e.entryPointType === "video",
+          )?.uri,
+        icalUid: resp.iCalUID,
+      };
+    },
+
+    async updateEvent({ credentialId, externalId, booking }) {
+      // Bump sequence for RFC 5545 compliance
+      const newSeq = booking.iCalSequence + 1;
+      const body = {
+        summary: booking.title,
+        description: booking.description,
+        start: { dateTime: booking.startTime, timeZone: booking.timezone },
+        end: { dateTime: booking.endTime, timeZone: booking.timezone },
+        sequence: newSeq,
+      };
+      await apiCall(
+        credentialId,
+        `https://www.googleapis.com/calendar/v3/calendars/primary/events/${encodeURIComponent(externalId)}?sendUpdates=all`,
+        { method: "PATCH", body: JSON.stringify(body) },
+      );
+      return { iCalSequence: newSeq };
+    },
+
+    async deleteEvent({ credentialId, externalId }) {
+      await apiCall(
+        credentialId,
+        `https://www.googleapis.com/calendar/v3/calendars/primary/events/${encodeURIComponent(externalId)}?sendUpdates=all`,
+        { method: "DELETE" },
+      );
+    },
+  };
+}

package/src/server/providers/google-meet.ts

@@ -0,0 +1,22 @@
+/**
+ * Google Meet — piggy-backs on Google Calendar credentials. The meeting link
+ * is created as part of the calendar event (conferenceData). This provider
+ * exists so we can list Google Meet as an installable conferencing option in
+ * the UI; the actual meeting creation happens in `google-calendar.createEvent`
+ * when `includeConference` is true.
+ */
+import type { VideoProvider } from "./types.js";
+
+export const googleMeetProvider: VideoProvider = {
+  kind: "google_meet",
+  label: "Google Meet",
+  async createMeeting({ booking }) {
+    // Meeting URL is generated by Google Calendar. If the consumer calls this
+    // directly rather than via google_calendar.createEvent, return a
+    // placeholder to signal that the event creation flow should handle it.
+    return {
+      meetingUrl: "",
+      meetingId: `meet_${booking.uid}`,
+    };
+  },
+};

package/src/server/providers/index.ts

@@ -0,0 +1,7 @@
+export * from "./types.js";
+export * from "./registry.js";
+export { createGoogleCalendarProvider } from "./google-calendar.js";
+export { createOffice365Provider } from "./office365.js";
+export { createZoomProvider } from "./zoom.js";
+export { createDailyVideoProvider } from "./builtin-video.js";
+export { googleMeetProvider } from "./google-meet.js";

package/src/server/providers/office365.ts

@@ -0,0 +1,208 @@
+/**
+ * Office 365 / Outlook calendar provider via Microsoft Graph.
+ *
+ * Token flow is identical to Google but against login.microsoftonline.com.
+ * Uses Microsoft Graph API for calendars and events.
+ */
+import type { CalendarProvider } from "./types.js";
+import type { BusyInterval } from "../../shared/index.js";
+
+export interface Office365ProviderConfig {
+  clientId: string;
+  clientSecret: string;
+  tenant?: string;
+  getAccessToken: (credentialId: string) => Promise<string>;
+  updateTokens?: (
+    credentialId: string,
+    tokens: { accessToken: string; refreshToken?: string; expiresAt?: Date },
+  ) => Promise<void>;
+  markInvalid?: (credentialId: string) => Promise<void>;
+}
+
+const SCOPES = ["offline_access", "Calendars.ReadWrite", "User.Read"];
+
+export function createOffice365Provider(
+  config: Office365ProviderConfig,
+): CalendarProvider {
+  const tenant = config.tenant ?? "common";
+  async function graph<T>(
+    credentialId: string,
+    path: string,
+    init?: RequestInit,
+  ): Promise<T> {
+    const token = await config.getAccessToken(credentialId);
+    const res = await fetch(`https://graph.microsoft.com/v1.0${path}`, {
+      ...init,
+      headers: {
+        ...(init?.headers ?? {}),
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json",
+      },
+    });
+    if (res.status === 401 || res.status === 403) {
+      await config.markInvalid?.(credentialId);
+      throw new Error(`Office 365 credential invalid (${res.status})`);
+    }
+    if (!res.ok) {
+      throw new Error(`Graph ${res.status}: ${await res.text()}`);
+    }
+    if (res.status === 204) return undefined as unknown as T;
+    return (await res.json()) as T;
+  }
+  return {
+    kind: "office365_calendar",
+    label: "Outlook / Office 365",
+    async startOAuth({ redirectUri, state }) {
+      const params = new URLSearchParams({
+        client_id: config.clientId,
+        redirect_uri: redirectUri,
+        response_type: "code",
+        scope: SCOPES.join(" "),
+        response_mode: "query",
+        prompt: "consent",
+        state,
+      });
+      return {
+        authUrl: `https://login.microsoftonline.com/${tenant}/oauth2/v2.0/authorize?${params}`,
+      };
+    },
+    async completeOAuth({ code, redirectUri, credentialId, userEmail }) {
+      const body = new URLSearchParams({
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        code,
+        redirect_uri: redirectUri,
+        grant_type: "authorization_code",
+        scope: SCOPES.join(" "),
+      });
+      const res = await fetch(
+        `https://login.microsoftonline.com/${tenant}/oauth2/v2.0/token`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/x-www-form-urlencoded" },
+          body,
+        },
+      );
+      if (!res.ok) {
+        throw new Error(
+          `Office 365 token exchange failed: ${res.status} ${await res.text()}`,
+        );
+      }
+      const tokens = await res.json();
+      await config.updateTokens?.(credentialId, {
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        expiresAt: new Date(Date.now() + (tokens.expires_in ?? 3600) * 1000),
+      });
+      const me = await graph<{ mail: string; userPrincipalName: string }>(
+        credentialId,
+        "/me",
+      );
+      const calendars = await graph<{
+        value: { id: string; name: string; isDefaultCalendar: boolean }[];
+      }>(credentialId, "/me/calendars");
+      return {
+        externalEmail: me.mail ?? me.userPrincipalName ?? userEmail,
+        calendars: calendars.value.map((c) => ({
+          externalId: c.id,
+          name: c.name,
+          primary: c.isDefaultCalendar,
+        })),
+      };
+    },
+    async listCalendars({ credentialId }) {
+      const resp = await graph<{
+        value: { id: string; name: string; isDefaultCalendar: boolean }[];
+      }>(credentialId, "/me/calendars");
+      return resp.value.map((c) => ({
+        externalId: c.id,
+        name: c.name,
+        primary: c.isDefaultCalendar,
+      }));
+    },
+    async getBusy({ credentialId, calendarExternalIds, start, end }) {
+      const resp = await graph<{
+        value: {
+          scheduleId: string;
+          scheduleItems: {
+            start: { dateTime: string };
+            end: { dateTime: string };
+            status: string;
+          }[];
+        }[];
+      }>(credentialId, "/me/calendar/getSchedule", {
+        method: "POST",
+        body: JSON.stringify({
+          schedules: calendarExternalIds,
+          startTime: { dateTime: start.toISOString(), timeZone: "UTC" },
+          endTime: { dateTime: end.toISOString(), timeZone: "UTC" },
+          availabilityViewInterval: 30,
+        }),
+      });
+      const out: BusyInterval[] = [];
+      for (const entry of resp.value) {
+        for (const item of entry.scheduleItems) {
+          if (item.status === "free") continue;
+          out.push({
+            start: item.start.dateTime + "Z",
+            end: item.end.dateTime + "Z",
+            source: entry.scheduleId,
+          });
+        }
+      }
+      return out;
+    },
+    async createEvent({ credentialId, calendarExternalId, booking }) {
+      const body = {
+        subject: booking.title,
+        body: { contentType: "HTML", content: booking.description ?? "" },
+        start: { dateTime: booking.startTime, timeZone: booking.timezone },
+        end: { dateTime: booking.endTime, timeZone: booking.timezone },
+        attendees: booking.attendees.map((a) => ({
+          emailAddress: { address: a.email, name: a.name },
+          type: "required",
+        })),
+        transactionId: booking.uid,
+      };
+      const resp = await graph<{
+        id: string;
+        iCalUId: string;
+        onlineMeeting?: { joinUrl: string };
+      }>(
+        credentialId,
+        `/me/calendars/${encodeURIComponent(calendarExternalId)}/events`,
+        { method: "POST", body: JSON.stringify(body) },
+      );
+      return {
+        externalId: resp.id,
+        meetingUrl: resp.onlineMeeting?.joinUrl,
+        icalUid: resp.iCalUId,
+      };
+    },
+    async updateEvent({ credentialId, externalId, booking }) {
+      const newSeq = booking.iCalSequence + 1;
+      await graph(
+        credentialId,
+        `/me/events/${encodeURIComponent(externalId)}`,
+        {
+          method: "PATCH",
+          body: JSON.stringify({
+            subject: booking.title,
+            start: { dateTime: booking.startTime, timeZone: booking.timezone },
+            end: { dateTime: booking.endTime, timeZone: booking.timezone },
+          }),
+        },
+      );
+      return { iCalSequence: newSeq };
+    },
+    async deleteEvent({ credentialId, externalId }) {
+      await graph(
+        credentialId,
+        `/me/events/${encodeURIComponent(externalId)}`,
+        {
+          method: "DELETE",
+        },
+      );
+    },
+  };
+}

package/src/server/providers/registry.ts

@@ -0,0 +1,43 @@
+/**
+ * Provider registry — consumers register calendar/video/SMS providers at
+ * startup. Actions look up providers by kind.
+ */
+import type { CalendarProvider, VideoProvider, SmsProvider } from "./types.js";
+
+const calendarProviders = new Map<string, CalendarProvider>();
+const videoProviders = new Map<string, VideoProvider>();
+const smsProviders = new Map<string, SmsProvider>();
+
+export function registerCalendarProvider(p: CalendarProvider): void {
+  calendarProviders.set(p.kind, p);
+}
+
+export function registerVideoProvider(p: VideoProvider): void {
+  videoProviders.set(p.kind, p);
+}
+
+export function registerSmsProvider(p: SmsProvider): void {
+  smsProviders.set(p.kind, p);
+}
+
+export function getCalendarProvider(
+  kind: string,
+): CalendarProvider | undefined {
+  return calendarProviders.get(kind);
+}
+
+export function getVideoProvider(kind: string): VideoProvider | undefined {
+  return videoProviders.get(kind);
+}
+
+export function getSmsProvider(kind: string): SmsProvider | undefined {
+  return smsProviders.get(kind);
+}
+
+export function listCalendarProviders(): CalendarProvider[] {
+  return Array.from(calendarProviders.values());
+}
+
+export function listVideoProviders(): VideoProvider[] {
+  return Array.from(videoProviders.values());
+}