@agent-native/scheduling 0.1.23 → 0.1.25

package/src/server/bookings-repo.ts

@@ -225,56 +225,62 @@ export async function insertBooking(
   const id = nanoid();
   const uid = nanoid(12);
   const iCalUid = input.iCalUid ?? `${uid}@agent-native-scheduling`;
-  await db.insert(schema.bookings).values({
-    id,
-    uid,
-    eventTypeId: input.eventTypeId,
-    hostEmail: input.hostEmail,
-    title: input.title,
-    description: input.description ?? null,
-    startTime: input.startTime,
-    endTime: input.endTime,
-    timezone: input.timezone,
-    status: input.status ?? "confirmed",
-    location: input.location ? JSON.stringify(input.location) : null,
-    customResponses: input.customResponses
-      ? JSON.stringify(input.customResponses)
-      : null,
-    cancelToken: nanoid(24),
-    rescheduleToken: nanoid(24),
-    fromReschedule: input.fromReschedule ?? null,
-    iCalUid,
-    iCalSequence: input.iCalSequence ?? 0,
-    paid: false,
-    createdAt: now,
-    updatedAt: now,
-    ownerEmail: input.ownerEmail,
-    orgId: input.orgId ?? null,
-  });
-  for (const a of input.attendees) {
-    await db.insert(schema.bookingAttendees).values({
-      id: nanoid(),
-      bookingId: id,
-      email: a.email,
-      name: a.name,
-      timezone: a.timezone ?? null,
-      locale: a.locale ?? null,
-      noShow: false,
-      createdAt: now,
-    });
-  }
-  for (const r of input.references ?? []) {
-    await db.insert(schema.bookingReferences).values({
-      id: nanoid(),
-      bookingId: id,
-      type: r.type,
-      externalId: r.externalId,
-      meetingUrl: r.meetingUrl ?? null,
-      meetingPassword: r.meetingPassword ?? null,
-      credentialId: r.credentialId ?? null,
+  await db.transaction(async (tx: any) => {
+    await tx.insert(schema.bookings).values({
+      id,
+      uid,
+      eventTypeId: input.eventTypeId,
+      hostEmail: input.hostEmail,
+      title: input.title,
+      description: input.description ?? null,
+      startTime: input.startTime,
+      endTime: input.endTime,
+      timezone: input.timezone,
+      status: input.status ?? "confirmed",
+      location: input.location ? JSON.stringify(input.location) : null,
+      customResponses: input.customResponses
+        ? JSON.stringify(input.customResponses)
+        : null,
+      cancelToken: nanoid(24),
+      rescheduleToken: nanoid(24),
+      fromReschedule: input.fromReschedule ?? null,
+      iCalUid,
+      iCalSequence: input.iCalSequence ?? 0,
+      paid: false,
       createdAt: now,
+      updatedAt: now,
+      ownerEmail: input.ownerEmail,
+      orgId: input.orgId ?? null,
     });
-  }
+    if (input.attendees.length > 0) {
+      await tx.insert(schema.bookingAttendees).values(
+        input.attendees.map((a) => ({
+          id: nanoid(),
+          bookingId: id,
+          email: a.email,
+          name: a.name,
+          timezone: a.timezone ?? null,
+          locale: a.locale ?? null,
+          noShow: false,
+          createdAt: now,
+        })),
+      );
+    }
+    if (input.references && input.references.length > 0) {
+      await tx.insert(schema.bookingReferences).values(
+        input.references.map((r) => ({
+          id: nanoid(),
+          bookingId: id,
+          type: r.type,
+          externalId: r.externalId,
+          meetingUrl: r.meetingUrl ?? null,
+          meetingPassword: r.meetingPassword ?? null,
+          credentialId: r.credentialId ?? null,
+          createdAt: now,
+        })),
+      );
+    }
+  });
   const created = await getBookingByUid(uid);
   if (!created) throw new Error("Failed to create booking");
   return created;

package/src/server/providers/index.ts

@@ -3,5 +3,7 @@ export * from "./registry.js";
 export { createGoogleCalendarProvider } from "./google-calendar.js";
 export { createOffice365Provider } from "./office365.js";
 export { createZoomProvider } from "./zoom.js";
+export { createTeamsProvider } from "./teams.js";
+export type { TeamsProviderConfig } from "./teams.js";
 export { createDailyVideoProvider } from "./builtin-video.js";
 export { googleMeetProvider } from "./google-meet.js";

package/src/server/providers/teams.test.ts

@@ -0,0 +1,246 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { Booking } from "../../shared/index.js";
+import { createTeamsProvider } from "./teams.js";
+
+const booking: Booking = {
+  id: "booking-example",
+  uid: "booking-uid-example",
+  eventTypeId: "event-type-example",
+  hostEmail: "host@example.com",
+  title: "Example planning call",
+  startTime: "2026-07-15T17:00:00.000Z",
+  endTime: "2026-07-15T17:30:00.000Z",
+  timezone: "UTC",
+  status: "confirmed",
+  attendees: [{ email: "guest@example.com", name: "Example Guest" }],
+  references: [],
+  iCalUid: "ical-example",
+  iCalSequence: 0,
+  createdAt: "2026-07-10T00:00:00.000Z",
+  updatedAt: "2026-07-10T00:00:00.000Z",
+};
+
+describe("createTeamsProvider", () => {
+  const fetchMock = vi.fn<typeof fetch>();
+  const getAccessToken = vi.fn(async () => "access-token-example");
+  const updateTokens = vi.fn();
+  const markInvalid = vi.fn();
+
+  beforeEach(() => {
+    vi.stubGlobal("fetch", fetchMock);
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-07-10T00:00:00.000Z"));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    vi.clearAllMocks();
+  });
+
+  function provider(tenant?: string) {
+    return createTeamsProvider({
+      clientId: "client-id-example",
+      clientSecret: "client-secret-example",
+      tenant,
+      getAccessToken,
+      updateTokens,
+      markInvalid,
+    });
+  }
+
+  it("uses the Teams kind and a work-or-school OAuth default", async () => {
+    const teams = provider();
+    expect(teams).toMatchObject({
+      kind: "teams_video",
+      label: "Microsoft Teams",
+    });
+    const result = await teams.startOAuth!({
+      redirectUri: "https://calendar.example.com/oauth/callback",
+      state: "state-example",
+    });
+    const url = new URL(result.authUrl);
+    expect(url.pathname).toBe("/organizations/oauth2/v2.0/authorize");
+    expect(url.searchParams.get("client_id")).toBe("client-id-example");
+    expect(url.searchParams.get("redirect_uri")).toBe(
+      "https://calendar.example.com/oauth/callback",
+    );
+    expect(url.searchParams.get("state")).toBe("state-example");
+    expect(url.searchParams.get("response_type")).toBe("code");
+    expect(url.searchParams.get("response_mode")).toBe("query");
+    expect(url.searchParams.get("scope")?.split(" ")).toEqual([
+      "offline_access",
+      "OnlineMeetings.ReadWrite",
+      "User.Read",
+    ]);
+    expect(result.authUrl).not.toContain("client-secret-example");
+  });
+
+  it("uses an explicit Microsoft tenant", async () => {
+    const result = await provider("tenant-example").startOAuth!({
+      redirectUri: "https://calendar.example.com/oauth/callback",
+      state: "state-example",
+    });
+    expect(new URL(result.authUrl).pathname).toBe(
+      "/tenant-example/oauth2/v2.0/authorize",
+    );
+  });
+
+  it("exchanges OAuth tokens and resolves the Microsoft identity", async () => {
+    fetchMock
+      .mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({
+            access_token: "new-access-token-example",
+            refresh_token: "refresh-token-example",
+            expires_in: 1800,
+          }),
+          { status: 200 },
+        ),
+      )
+      .mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({
+            id: "microsoft-user-example",
+            mail: "microsoft-user@example.com",
+            displayName: "Example User",
+          }),
+          { status: 200 },
+        ),
+      );
+
+    const result = await provider("tenant-example").completeOAuth!({
+      credentialId: "credential-example",
+      userEmail: "fallback@example.com",
+      code: "authorization-code-example",
+      redirectUri: "https://calendar.example.com/oauth/callback",
+    });
+
+    expect(fetchMock.mock.calls[0]?.[0]).toBe(
+      "https://login.microsoftonline.com/tenant-example/oauth2/v2.0/token",
+    );
+    const tokenInit = fetchMock.mock.calls[0]?.[1];
+    expect(tokenInit?.method).toBe("POST");
+    const tokenBody = tokenInit?.body as URLSearchParams;
+    expect(tokenBody.get("grant_type")).toBe("authorization_code");
+    expect(tokenBody.get("code")).toBe("authorization-code-example");
+    expect(updateTokens).toHaveBeenCalledWith(
+      "credential-example",
+      expect.objectContaining({
+        accessToken: "new-access-token-example",
+        refreshToken: "refresh-token-example",
+        expiresAt: new Date("2026-07-10T00:30:00.000Z"),
+      }),
+    );
+    expect(fetchMock.mock.calls[1]?.[1]).toMatchObject({
+      headers: { authorization: "Bearer new-access-token-example" },
+    });
+    expect(result).toEqual({
+      externalAccountId: "microsoft-user-example",
+      externalEmail: "microsoft-user@example.com",
+      displayName: "Example User",
+    });
+  });
+
+  it("does not persist tokens after a failed exchange", async () => {
+    fetchMock.mockResolvedValueOnce(new Response(null, { status: 400 }));
+    await expect(
+      provider().completeOAuth!({
+        credentialId: "credential-example",
+        userEmail: "user@example.com",
+        code: "authorization-code-example",
+        redirectUri: "https://calendar.example.com/oauth/callback",
+      }),
+    ).rejects.toThrow("token exchange failed (400)");
+    expect(updateTokens).not.toHaveBeenCalled();
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("creates a Teams meeting and maps id plus joinWebUrl", async () => {
+    fetchMock.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          id: "meeting/id example",
+          joinWebUrl: "https://teams.microsoft.com/l/meetup-join/example",
+        }),
+        { status: 201 },
+      ),
+    );
+    const result = await provider().createMeeting({
+      credentialId: "credential-example",
+      booking,
+    });
+    expect(getAccessToken).toHaveBeenCalledWith("credential-example");
+    expect(fetchMock.mock.calls[0]?.[0]).toBe(
+      "https://graph.microsoft.com/v1.0/me/onlineMeetings",
+    );
+    expect(fetchMock.mock.calls[0]?.[1]).toMatchObject({ method: "POST" });
+    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
+      subject: booking.title,
+      startDateTime: booking.startTime,
+      endDateTime: booking.endTime,
+    });
+    expect(result).toEqual({
+      meetingId: "meeting/id example",
+      meetingUrl: "https://teams.microsoft.com/l/meetup-join/example",
+    });
+  });
+
+  it("requires a credential before creating a meeting", async () => {
+    await expect(provider().createMeeting({ booking })).rejects.toThrow(
+      "requires credentialId",
+    );
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it.each([401, 403])(
+    "marks a credential invalid on create HTTP %s",
+    async (status) => {
+      fetchMock.mockResolvedValueOnce(new Response(null, { status }));
+      await expect(
+        provider().createMeeting({
+          credentialId: "credential-example",
+          booking,
+        }),
+      ).rejects.toThrow(`creation failed (${status})`);
+      expect(markInvalid).toHaveBeenCalledWith("credential-example");
+    },
+  );
+
+  it("deletes a meeting using an encoded opaque id", async () => {
+    fetchMock.mockResolvedValueOnce(new Response(null, { status: 204 }));
+    await provider().deleteMeeting!({
+      credentialId: "credential-example",
+      meetingId: "meeting/id example",
+    });
+    expect(fetchMock.mock.calls[0]?.[0]).toBe(
+      "https://graph.microsoft.com/v1.0/me/onlineMeetings/meeting%2Fid%20example",
+    );
+    expect(fetchMock.mock.calls[0]?.[1]).toMatchObject({ method: "DELETE" });
+  });
+
+  it("treats an already-deleted meeting as success", async () => {
+    fetchMock.mockResolvedValueOnce(new Response(null, { status: 404 }));
+    await expect(
+      provider().deleteMeeting!({
+        credentialId: "credential-example",
+        meetingId: "missing-meeting-example",
+      }),
+    ).resolves.toBeUndefined();
+  });
+
+  it.each([401, 403])(
+    "marks a credential invalid on delete HTTP %s",
+    async (status) => {
+      fetchMock.mockResolvedValueOnce(new Response(null, { status }));
+      await expect(
+        provider().deleteMeeting!({
+          credentialId: "credential-example",
+          meetingId: "meeting-example",
+        }),
+      ).rejects.toThrow(`deletion failed (${status})`);
+      expect(markInvalid).toHaveBeenCalledWith("credential-example");
+    },
+  );
+});

package/src/server/providers/teams.ts

@@ -0,0 +1,183 @@
+/**
+ * Microsoft Teams provider — delegated Microsoft OAuth with Graph-backed
+ * standalone online meetings.
+ */
+import type { VideoProvider } from "./types.js";
+
+export interface TeamsProviderConfig {
+  clientId: string;
+  clientSecret: string;
+  /** Microsoft tenant id/domain; defaults to work-or-school accounts. */
+  tenant?: string;
+  getAccessToken: (credentialId: string) => Promise<string>;
+  updateTokens?: (
+    credentialId: string,
+    tokens: {
+      accessToken: string;
+      refreshToken?: string;
+      expiresAt?: Date;
+      rawResponse?: Record<string, unknown>;
+    },
+  ) => Promise<void>;
+  /** Called when Graph returns 401/403; mark the credential invalid in UI. */
+  markInvalid?: (credentialId: string) => Promise<void>;
+}
+
+const SCOPES = ["offline_access", "OnlineMeetings.ReadWrite", "User.Read"];
+const GRAPH_BASE_URL = "https://graph.microsoft.com/v1.0";
+
+export function createTeamsProvider(
+  config: TeamsProviderConfig,
+): VideoProvider {
+  const tenant = config.tenant ?? "organizations";
+  const oauthBaseUrl = `https://login.microsoftonline.com/${encodeURIComponent(tenant)}/oauth2/v2.0`;
+
+  async function graphRequest(
+    credentialId: string,
+    path: string,
+    init?: RequestInit,
+  ): Promise<Response> {
+    const token = await config.getAccessToken(credentialId);
+    const response = await fetch(`${GRAPH_BASE_URL}${path}`, {
+      ...init,
+      headers: {
+        ...(init?.headers ?? {}),
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json",
+      },
+    });
+    if (response.status === 401 || response.status === 403) {
+      await config.markInvalid?.(credentialId);
+    }
+    return response;
+  }
+
+  return {
+    kind: "teams_video",
+    label: "Microsoft Teams",
+
+    async startOAuth({ redirectUri, state }) {
+      const params = new URLSearchParams({
+        client_id: config.clientId,
+        redirect_uri: redirectUri,
+        response_type: "code",
+        response_mode: "query",
+        scope: SCOPES.join(" "),
+        prompt: "consent",
+        state,
+      });
+      return { authUrl: `${oauthBaseUrl}/authorize?${params}` };
+    },
+
+    async completeOAuth({ code, redirectUri, credentialId, userEmail }) {
+      const requestBody = new URLSearchParams({
+        client_id: config.clientId,
+        client_secret: config.clientSecret,
+        code,
+        redirect_uri: redirectUri,
+        grant_type: "authorization_code",
+        scope: SCOPES.join(" "),
+      });
+      const tokenResponse = await fetch(`${oauthBaseUrl}/token`, {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: requestBody,
+      });
+      if (!tokenResponse.ok) {
+        throw new Error(
+          `Microsoft Teams token exchange failed (${tokenResponse.status})`,
+        );
+      }
+      const tokens = (await tokenResponse.json()) as {
+        access_token?: string;
+        refresh_token?: string;
+        expires_in?: number;
+        [key: string]: unknown;
+      };
+      if (!tokens.access_token) {
+        throw new Error(
+          "Microsoft Teams token exchange returned no access token",
+        );
+      }
+
+      await config.updateTokens?.(credentialId, {
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        expiresAt: new Date(Date.now() + (tokens.expires_in ?? 3600) * 1000),
+        rawResponse: tokens,
+      });
+
+      // Use the token from this exchange directly. The consumer's token store
+      // may not be observable through getAccessToken until after this callback.
+      const identityResponse = await fetch(
+        `${GRAPH_BASE_URL}/me?$select=id,mail,userPrincipalName,displayName`,
+        { headers: { authorization: `Bearer ${tokens.access_token}` } },
+      );
+      if (!identityResponse.ok) {
+        throw new Error(
+          `Microsoft Teams identity lookup failed (${identityResponse.status})`,
+        );
+      }
+      const identity = (await identityResponse.json()) as {
+        id?: string;
+        mail?: string;
+        userPrincipalName?: string;
+        displayName?: string;
+      };
+      if (!identity.id) {
+        throw new Error(
+          "Microsoft Teams identity lookup returned no account id",
+        );
+      }
+      return {
+        externalAccountId: identity.id,
+        externalEmail: identity.mail ?? identity.userPrincipalName ?? userEmail,
+        displayName: identity.displayName,
+      };
+    },
+
+    async createMeeting({ credentialId, booking }) {
+      if (!credentialId) {
+        throw new Error("Microsoft Teams requires credentialId");
+      }
+      const response = await graphRequest(credentialId, "/me/onlineMeetings", {
+        method: "POST",
+        body: JSON.stringify({
+          subject: booking.title,
+          startDateTime: booking.startTime,
+          endDateTime: booking.endTime,
+        }),
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Microsoft Teams meeting creation failed (${response.status})`,
+        );
+      }
+      const meeting = (await response.json()) as {
+        id?: string;
+        joinWebUrl?: string;
+      };
+      if (!meeting.id || !meeting.joinWebUrl) {
+        throw new Error(
+          "Microsoft Teams meeting response is missing id or joinWebUrl",
+        );
+      }
+      return { meetingId: meeting.id, meetingUrl: meeting.joinWebUrl };
+    },
+
+    async deleteMeeting({ credentialId, meetingId }) {
+      if (!credentialId) return;
+      const response = await graphRequest(
+        credentialId,
+        `/me/onlineMeetings/${encodeURIComponent(meetingId)}`,
+        { method: "DELETE" },
+      );
+      if (response.status === 204 || response.status === 404) return;
+      if (!response.ok) {
+        throw new Error(
+          `Microsoft Teams meeting deletion failed (${response.status})`,
+        );
+      }
+    },
+  };
+}