@pellux/goodvibes-sdk 0.38.0 → 1.1.0

package/dist/platform/calendar/calendar-api-shared.js

@@ -0,0 +1,100 @@
+/**
+ * calendar-api-shared.ts — the bearer-auth HTTP helper and honest degraded-state
+ * mapping shared by the Google Calendar and Microsoft Graph clients. Every failed
+ * response is turned into a NAMED ApiDegradedState (never a generic throw): a 401 is
+ * `reconnect-needed`, a 403 that names a missing scope is `insufficient-scope` naming
+ * that scope, a 429 is `rate-limited` carrying the honored Retry-After, everything
+ * else is `provider-error` with the status.
+ */
+/** A named, honest API failure. */
+export class CalendarApiError extends Error {
+    degraded;
+    constructor(degraded) {
+        super(degraded.detail);
+        this.name = 'CalendarApiError';
+        this.degraded = degraded;
+    }
+}
+function retryAfterMs(res) {
+    const header = res.header('retry-after');
+    if (!header)
+        return 1000;
+    const seconds = Number(header);
+    if (Number.isFinite(seconds))
+        return Math.max(0, seconds * 1000);
+    const when = Date.parse(header);
+    return Number.isFinite(when) ? Math.max(0, when - Date.now()) : 1000;
+}
+/**
+ * Best-effort extraction of the scope a 403 says is missing. Google returns it in
+ * the error message / details; Graph names it in the error message. When we cannot
+ * pin the exact scope, we say so honestly rather than invent one.
+ */
+function missingScopeFrom(bodyText, provider) {
+    const scopeMatch = /scope[s]?['"\s:=]+([A-Za-z0-9_.:/-]+)/i.exec(bodyText);
+    if (scopeMatch)
+        return scopeMatch[1];
+    const graphPerm = /(Calendars\.[A-Za-z]+)/.exec(bodyText);
+    if (graphPerm)
+        return graphPerm[1];
+    return provider === 'google'
+        ? 'a Google Calendar scope not granted to this connection'
+        : 'a Microsoft Graph Calendars permission not granted to this connection';
+}
+/** Map a non-OK response to a CalendarApiError with a named degraded state. */
+export async function errorFromResponse(res, provider) {
+    const bodyText = await res.text().catch(() => '');
+    if (res.status === 401) {
+        return new CalendarApiError({
+            kind: 'reconnect-needed',
+            detail: `${provider} rejected the access token (401). Reconnect the account.`,
+        });
+    }
+    if (res.status === 403) {
+        return new CalendarApiError({
+            kind: 'insufficient-scope',
+            missingScope: missingScopeFrom(bodyText, provider),
+            detail: `${provider} refused the request for lack of a granted scope (403).`,
+        });
+    }
+    if (res.status === 429) {
+        return new CalendarApiError({
+            kind: 'rate-limited',
+            retryAfterMs: retryAfterMs(res),
+            detail: `${provider} rate-limited the request (429).`,
+        });
+    }
+    return new CalendarApiError({
+        kind: 'provider-error',
+        status: res.status,
+        detail: `${provider} returned ${res.status}${bodyText ? `: ${bodyText.slice(0, 200)}` : ''}.`,
+    });
+}
+/** Issue a bearer-authorized request, throwing a CalendarApiError on failure. */
+export async function authedRequest(fetchImpl, provider, input) {
+    const headers = {
+        Authorization: `Bearer ${input.token}`,
+        Accept: 'application/json',
+        ...input.extraHeaders,
+    };
+    if (input.body !== undefined)
+        headers['Content-Type'] = 'application/json';
+    let res;
+    try {
+        res = await fetchImpl({
+            url: input.url,
+            method: input.method,
+            headers,
+            ...(input.body !== undefined ? { body: JSON.stringify(input.body) } : {}),
+        });
+    }
+    catch (error) {
+        throw new CalendarApiError({
+            kind: 'network-error',
+            detail: `Reaching ${provider} failed: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+    if (!res.ok)
+        throw await errorFromResponse(res, provider);
+    return res.json();
+}

package/dist/platform/calendar/calendar-connector.d.ts

@@ -0,0 +1,79 @@
+/**
+ * calendar-connector.ts — the high-level connector the agent drives. It ties the
+ * provider profiles, the OAuth flows, the secret-backed token store, and the two API
+ * clients into one surface: connect (auth-code or device-code), disconnect, list
+ * accounts + their honest state, list calendars, list events (normalized + source-
+ * labeled) across a window, and create an event routed to an explicitly chosen
+ * provider. The network and (for the loopback flow) the redirect listener are
+ * injected, so the whole thing runs against fakes with no real network or port.
+ */
+import { type Sleep } from './oauth-flow.js';
+import type { AuthCodeFlowStart, CalendarProviderId, Clock, ConnectedAccount, ConnectionState, DeviceCodeFlowStart, HttpFetch, LoopbackListenerFactory, LoopbackWaiter, MergedCalendarEvent, NewCalendarEvent, OAuthClientOverrides, ProviderCalendar, ResolvedClientConfig, SecretStoreSlice } from './oauth-types.js';
+export interface CalendarConnectorOptions {
+    readonly secrets: SecretStoreSlice;
+    readonly fetchImpl: HttpFetch;
+    readonly clock?: Clock;
+    /** Required only for the auth-code (loopback) flow; device-code needs no listener. */
+    readonly listenerFactory?: LoopbackListenerFactory;
+    /** Injected delay for device-code polling; defaults to a real timer. */
+    readonly sleep?: Sleep;
+    readonly refreshLeewayMs?: number;
+}
+/** A time window for event listing, as ISO strings. */
+export interface EventWindow {
+    readonly timeMin: string;
+    readonly timeMax: string;
+}
+export declare class CalendarConnector {
+    private readonly secrets;
+    private readonly fetchImpl;
+    private readonly clock;
+    private readonly listenerFactory?;
+    private readonly sleep;
+    private readonly store;
+    constructor(options: CalendarConnectorOptions);
+    /** Resolve the client config for a provider (profile + optional user overrides). */
+    resolveConfig(provider: CalendarProviderId, overrides?: OAuthClientOverrides): ResolvedClientConfig;
+    listAccounts(): Promise<ConnectedAccount[]>;
+    connectionState(provider: CalendarProviderId): Promise<ConnectionState>;
+    /** Begin the loopback auth-code flow; returns the URL to open and the waiter. */
+    beginConnectAuthCode(config: ResolvedClientConfig): Promise<{
+        readonly start: AuthCodeFlowStart;
+        readonly waiter: LoopbackWaiter;
+    }>;
+    /** Complete the auth-code flow after the redirect delivered a code; saves tokens. */
+    completeConnectAuthCode(config: ResolvedClientConfig, input: {
+        readonly code: string;
+        readonly verifier: string;
+        readonly redirectUri: string;
+    }): Promise<ConnectedAccount>;
+    /** Begin the device-code flow; returns the user code + verification URL to show. */
+    beginConnectDeviceCode(config: ResolvedClientConfig): Promise<DeviceCodeFlowStart>;
+    /** Poll until the device code is approved, then save tokens. */
+    completeConnectDeviceCode(config: ResolvedClientConfig, start: DeviceCodeFlowStart): Promise<ConnectedAccount>;
+    disconnect(provider: CalendarProviderId, overrides?: OAuthClientOverrides): Promise<{
+        readonly revokedRemotely: boolean;
+    }>;
+    /** List the provider's calendars (refreshing the token first when due). */
+    listCalendars(config: ResolvedClientConfig): Promise<ProviderCalendar[]>;
+    /**
+     * List events across all of the provider's calendars in a window, normalized into
+     * the merged model, source-labeled, and sorted chronologically (through the ONE
+     * documented cross-zone comparator, `compareMergedCalendarEventsByStart` — see
+     * merged-calendar-model.ts for why a raw string/localeCompare sort of `start.value`
+     * is wrong once utc and tzid/floating events are mixed). Callers merge this with
+     * A9's ICS/local events into the unified /calendar view.
+     */
+    listEvents(config: ResolvedClientConfig, window: EventWindow): Promise<MergedCalendarEvent[]>;
+    createEvent(config: ResolvedClientConfig, calendarId: string, calendarLabel: string, event: NewCalendarEvent): Promise<MergedCalendarEvent>;
+    /** Save tokens + a best-effort enriched account label, and return the account. */
+    private persistConnection;
+    /**
+     * Best-effort account label: the primary calendar id is the account email for
+     * Google, and the primary calendar's name is a reasonable Outlook label. A failure
+     * here must NOT fail the connection (the token is already valid), so it falls back
+     * to the provider display name.
+     */
+    private deriveLabel;
+}
+//# sourceMappingURL=calendar-connector.d.ts.map

package/dist/platform/calendar/calendar-connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendar-connector.d.ts","sourceRoot":"","sources":["../../../src/platform/calendar/calendar-connector.ts"],"names":[],"mappings":"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"}

package/dist/platform/calendar/calendar-connector.js

@@ -0,0 +1,155 @@
+/**
+ * calendar-connector.ts — the high-level connector the agent drives. It ties the
+ * provider profiles, the OAuth flows, the secret-backed token store, and the two API
+ * clients into one surface: connect (auth-code or device-code), disconnect, list
+ * accounts + their honest state, list calendars, list events (normalized + source-
+ * labeled) across a window, and create an event routed to an explicitly chosen
+ * provider. The network and (for the loopback flow) the redirect listener are
+ * injected, so the whole thing runs against fakes with no real network or port.
+ */
+import { beginAuthCodeFlow, beginDeviceCodeFlow, completeAuthCodeFlow, pollDeviceCodeFlow, } from './oauth-flow.js';
+import { providerProfile, resolveClientConfig } from './oauth-providers.js';
+import { CalendarTokenStore } from './oauth-token-store.js';
+import { createGoogleEvent, listGoogleCalendars, listGoogleEvents, } from './google-calendar-api.js';
+import { createGraphEvent, listGraphCalendars, listGraphEvents, } from './microsoft-graph-api.js';
+import { compareMergedCalendarEventsByStart } from './merged-calendar-model.js';
+export class CalendarConnector {
+    secrets;
+    fetchImpl;
+    clock;
+    listenerFactory;
+    sleep;
+    store;
+    constructor(options) {
+        this.secrets = options.secrets;
+        this.fetchImpl = options.fetchImpl;
+        this.clock = options.clock ?? (() => Date.now());
+        if (options.listenerFactory)
+            this.listenerFactory = options.listenerFactory;
+        this.sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+        const storeOptions = {
+            secrets: options.secrets,
+            clock: this.clock,
+            ...(typeof options.refreshLeewayMs === 'number' ? { refreshLeewayMs: options.refreshLeewayMs } : {}),
+        };
+        this.store = new CalendarTokenStore(storeOptions);
+    }
+    /** Resolve the client config for a provider (profile + optional user overrides). */
+    resolveConfig(provider, overrides) {
+        return resolveClientConfig(providerProfile(provider), overrides);
+    }
+    // --- Accounts / state -----------------------------------------------------
+    listAccounts() {
+        return this.store.listAccounts();
+    }
+    connectionState(provider) {
+        return this.store.connectionState(provider);
+    }
+    // --- Connect: authorization-code (loopback) flow --------------------------
+    /** Begin the loopback auth-code flow; returns the URL to open and the waiter. */
+    async beginConnectAuthCode(config) {
+        if (!this.listenerFactory) {
+            throw new Error('No loopback listener is available; use the device-code flow for headless connect.');
+        }
+        return beginAuthCodeFlow(config, this.listenerFactory);
+    }
+    /** Complete the auth-code flow after the redirect delivered a code; saves tokens. */
+    async completeConnectAuthCode(config, input) {
+        const tokens = await completeAuthCodeFlow(config, this.fetchImpl, input, this.clock());
+        return this.persistConnection(config, tokens);
+    }
+    // --- Connect: device-code (headless) flow ---------------------------------
+    /** Begin the device-code flow; returns the user code + verification URL to show. */
+    beginConnectDeviceCode(config) {
+        return beginDeviceCodeFlow(config, this.fetchImpl, this.clock());
+    }
+    /** Poll until the device code is approved, then save tokens. */
+    async completeConnectDeviceCode(config, start) {
+        const tokens = await pollDeviceCodeFlow(config, this.fetchImpl, start, this.clock, this.sleep);
+        return this.persistConnection(config, tokens);
+    }
+    // --- Disconnect -----------------------------------------------------------
+    disconnect(provider, overrides) {
+        return this.store.disconnect(provider, this.resolveConfig(provider, overrides), this.fetchImpl);
+    }
+    // --- Read: calendars + events ---------------------------------------------
+    /** List the provider's calendars (refreshing the token first when due). */
+    async listCalendars(config) {
+        const token = await this.store.getFreshAccessToken(config.provider, config, this.fetchImpl);
+        return config.provider === 'google'
+            ? listGoogleCalendars(this.fetchImpl, token)
+            : listGraphCalendars(this.fetchImpl, token);
+    }
+    /**
+     * List events across all of the provider's calendars in a window, normalized into
+     * the merged model, source-labeled, and sorted chronologically (through the ONE
+     * documented cross-zone comparator, `compareMergedCalendarEventsByStart` — see
+     * merged-calendar-model.ts for why a raw string/localeCompare sort of `start.value`
+     * is wrong once utc and tzid/floating events are mixed). Callers merge this with
+     * A9's ICS/local events into the unified /calendar view.
+     */
+    async listEvents(config, window) {
+        const token = await this.store.getFreshAccessToken(config.provider, config, this.fetchImpl);
+        const calendars = config.provider === 'google'
+            ? await listGoogleCalendars(this.fetchImpl, token)
+            : await listGraphCalendars(this.fetchImpl, token);
+        const out = [];
+        for (const calendar of calendars) {
+            const events = config.provider === 'google'
+                ? await listGoogleEvents(this.fetchImpl, token, {
+                    calendarId: calendar.id,
+                    calendarLabel: calendar.name,
+                    timeMin: window.timeMin,
+                    timeMax: window.timeMax,
+                })
+                : await listGraphEvents(this.fetchImpl, token, {
+                    calendarId: calendar.id,
+                    calendarLabel: calendar.name,
+                    start: window.timeMin,
+                    end: window.timeMax,
+                });
+            out.push(...events);
+        }
+        return [...out].sort(compareMergedCalendarEventsByStart);
+    }
+    // --- Write: create an event on an explicitly chosen provider --------------
+    async createEvent(config, calendarId, calendarLabel, event) {
+        const token = await this.store.getFreshAccessToken(config.provider, config, this.fetchImpl);
+        return config.provider === 'google'
+            ? createGoogleEvent(this.fetchImpl, token, calendarId, calendarLabel, event)
+            : createGraphEvent(this.fetchImpl, token, calendarId, calendarLabel, event);
+    }
+    // --- internals ------------------------------------------------------------
+    /** Save tokens + a best-effort enriched account label, and return the account. */
+    async persistConnection(config, tokens) {
+        const account = {
+            provider: config.provider,
+            accountId: config.provider,
+            label: await this.deriveLabel(config, tokens),
+            scopes: tokens.scopes ?? config.scopes,
+            connectedAt: this.clock(),
+        };
+        await this.store.save(config.provider, tokens, account);
+        return account;
+    }
+    /**
+     * Best-effort account label: the primary calendar id is the account email for
+     * Google, and the primary calendar's name is a reasonable Outlook label. A failure
+     * here must NOT fail the connection (the token is already valid), so it falls back
+     * to the provider display name.
+     */
+    async deriveLabel(config, tokens) {
+        try {
+            const calendars = config.provider === 'google'
+                ? await listGoogleCalendars(this.fetchImpl, tokens.accessToken)
+                : await listGraphCalendars(this.fetchImpl, tokens.accessToken);
+            const primary = calendars.find((c) => c.primary) ?? calendars[0];
+            if (primary)
+                return config.provider === 'google' ? primary.id : primary.name;
+        }
+        catch {
+            // fall through to the honest default
+        }
+        return config.provider === 'google' ? 'Google Calendar' : 'Microsoft Outlook';
+    }
+}

package/dist/platform/calendar/google-calendar-api.d.ts

@@ -0,0 +1,25 @@
+/**
+ * google-calendar-api.ts — the Google Calendar API v3 client over an access token
+ * and the injected HttpFetch. Lists calendars (calendarList.list), lists events
+ * (events.list with timeMin/timeMax paging and singleEvents=true so instances are
+ * already expanded), and creates events (events.insert). Every event is normalized
+ * into the merged model; every failure is a named degraded state via CalendarApiError.
+ */
+import type { HttpFetch, MergedCalendarEvent, NewCalendarEvent, ProviderCalendar } from './oauth-types.js';
+/** List the user's calendars. Write access is inferred from accessRole. */
+export declare function listGoogleCalendars(fetchImpl: HttpFetch, token: string): Promise<ProviderCalendar[]>;
+export interface GoogleEventsQuery {
+    readonly calendarId: string;
+    readonly calendarLabel: string;
+    /** RFC3339 lower bound (inclusive), e.g. '2026-07-01T00:00:00Z'. */
+    readonly timeMin: string;
+    /** RFC3339 upper bound (exclusive). */
+    readonly timeMax: string;
+    /** Page size cap per request; the client pages until exhausted. */
+    readonly pageSize?: number;
+}
+/** List events in a window, paging through every page. Instances are pre-expanded. */
+export declare function listGoogleEvents(fetchImpl: HttpFetch, token: string, query: GoogleEventsQuery): Promise<MergedCalendarEvent[]>;
+/** Insert a new event; returns it normalized into the merged model. */
+export declare function createGoogleEvent(fetchImpl: HttpFetch, token: string, calendarId: string, calendarLabel: string, event: NewCalendarEvent): Promise<MergedCalendarEvent>;
+//# sourceMappingURL=google-calendar-api.d.ts.map

package/dist/platform/calendar/google-calendar-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-calendar-api.d.ts","sourceRoot":"","sources":["../../../src/platform/calendar/google-calendar-api.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,SAAS,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAI3G,2EAA2E;AAC3E,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA0B1G;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uCAAuC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,mEAAmE;IACnE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,sFAAsF;AACtF,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAwBhC;AAED,uEAAuE;AACvE,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,mBAAmB,CAAC,CAa9B"}

package/dist/platform/calendar/google-calendar-api.js

@@ -0,0 +1,89 @@
+/**
+ * google-calendar-api.ts — the Google Calendar API v3 client over an access token
+ * and the injected HttpFetch. Lists calendars (calendarList.list), lists events
+ * (events.list with timeMin/timeMax paging and singleEvents=true so instances are
+ * already expanded), and creates events (events.insert). Every event is normalized
+ * into the merged model; every failure is a named degraded state via CalendarApiError.
+ */
+import { authedRequest } from './calendar-api-shared.js';
+import { normalizeGoogleEvent } from './merged-calendar-model.js';
+const BASE = 'https://www.googleapis.com/calendar/v3';
+/** List the user's calendars. Write access is inferred from accessRole. */
+export async function listGoogleCalendars(fetchImpl, token) {
+    const out = [];
+    let pageToken;
+    do {
+        const url = new URL(`${BASE}/users/me/calendarList`);
+        url.searchParams.set('maxResults', '250');
+        if (pageToken)
+            url.searchParams.set('pageToken', pageToken);
+        const body = (await authedRequest(fetchImpl, 'google', { url: url.toString(), method: 'GET', token }));
+        for (const raw of body.items ?? []) {
+            const item = (raw ?? {});
+            if (typeof item.id !== 'string')
+                continue;
+            const accessRole = typeof item.accessRole === 'string' ? item.accessRole : 'reader';
+            out.push({
+                id: item.id,
+                name: typeof item.summary === 'string' ? item.summary : item.id,
+                provider: 'google',
+                ...(item.primary === true ? { primary: true } : {}),
+                canWrite: accessRole === 'owner' || accessRole === 'writer',
+            });
+        }
+        pageToken = typeof body.nextPageToken === 'string' ? body.nextPageToken : undefined;
+    } while (pageToken);
+    return out;
+}
+/** List events in a window, paging through every page. Instances are pre-expanded. */
+export async function listGoogleEvents(fetchImpl, token, query) {
+    const out = [];
+    let pageToken;
+    do {
+        const url = new URL(`${BASE}/calendars/${encodeURIComponent(query.calendarId)}/events`);
+        url.searchParams.set('timeMin', query.timeMin);
+        url.searchParams.set('timeMax', query.timeMax);
+        url.searchParams.set('singleEvents', 'true');
+        url.searchParams.set('orderBy', 'startTime');
+        url.searchParams.set('maxResults', String(query.pageSize ?? 250));
+        if (pageToken)
+            url.searchParams.set('pageToken', pageToken);
+        const body = (await authedRequest(fetchImpl, 'google', { url: url.toString(), method: 'GET', token }));
+        for (const raw of body.items ?? []) {
+            const status = raw.status;
+            if (status === 'cancelled')
+                continue;
+            const event = normalizeGoogleEvent(raw, query.calendarId, query.calendarLabel);
+            if (event)
+                out.push(event);
+        }
+        pageToken = typeof body.nextPageToken === 'string' ? body.nextPageToken : undefined;
+    } while (pageToken);
+    return out;
+}
+/** Insert a new event; returns it normalized into the merged model. */
+export async function createGoogleEvent(fetchImpl, token, calendarId, calendarLabel, event) {
+    const payload = {
+        summary: event.summary,
+        start: googleEventDate(event.start),
+        ...(event.end ? { end: googleEventDate(event.end) } : {}),
+        ...(event.location ? { location: event.location } : {}),
+        ...(event.description ? { description: event.description } : {}),
+    };
+    const url = `${BASE}/calendars/${encodeURIComponent(calendarId)}/events`;
+    const created = await authedRequest(fetchImpl, 'google', { url, method: 'POST', token, body: payload });
+    const normalized = normalizeGoogleEvent(created, calendarId, calendarLabel);
+    if (!normalized)
+        throw new Error('Google accepted the event but returned an unreadable body.');
+    return normalized;
+}
+/** Map an EventDateTime to a Google event start/end object. */
+function googleEventDate(dt) {
+    if (dt.kind === 'date')
+        return { date: dt.value };
+    if (dt.zone === 'tzid' && dt.tzid)
+        return { dateTime: dt.value, timeZone: dt.tzid };
+    // utc or floating: send an explicit UTC anchor so Google does not guess.
+    const iso = dt.value.endsWith('Z') ? dt.value : `${dt.value}Z`;
+    return { dateTime: iso, timeZone: 'UTC' };
+}

package/dist/platform/calendar/http-fetch-adapter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * http-fetch-adapter.ts — a pure adapter turning a standard WHATWG `fetch` into the
+ * connector's injected HttpFetch boundary. This module references only the global
+ * fetch/Response (no node:*), so it stays within the calendar module's purity
+ * contract; the actual `fetch` used is supplied by the caller (the agent passes the
+ * runtime fetch, tests pass a fake server's fetch).
+ */
+import type { HttpFetch } from './oauth-types.js';
+type FetchLike = (url: string, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}) => Promise<{
+    status: number;
+    ok: boolean;
+    headers: {
+        get(name: string): string | null;
+    };
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+}>;
+/** Wrap a WHATWG-style fetch into an HttpFetch. Defaults to the global fetch. */
+export declare function fetchAdapter(fetchImpl?: FetchLike): HttpFetch;
+export {};
+//# sourceMappingURL=http-fetch-adapter.d.ts.map

package/dist/platform/calendar/http-fetch-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-fetch-adapter.d.ts","sourceRoot":"","sources":["../../../src/platform/calendar/http-fetch-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAA6B,MAAM,kBAAkB,CAAC;AAE7E,KAAK,SAAS,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,KAAK,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE;QAAE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IAC9C,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IACzB,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACzB,CAAC,CAAC;AAEH,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,SAAS,CAAC,EAAE,SAAS,GAAG,SAAS,CAgB7D"}

package/dist/platform/calendar/http-fetch-adapter.js

@@ -0,0 +1,25 @@
+/**
+ * http-fetch-adapter.ts — a pure adapter turning a standard WHATWG `fetch` into the
+ * connector's injected HttpFetch boundary. This module references only the global
+ * fetch/Response (no node:*), so it stays within the calendar module's purity
+ * contract; the actual `fetch` used is supplied by the caller (the agent passes the
+ * runtime fetch, tests pass a fake server's fetch).
+ */
+/** Wrap a WHATWG-style fetch into an HttpFetch. Defaults to the global fetch. */
+export function fetchAdapter(fetchImpl) {
+    const impl = fetchImpl ?? (globalThis.fetch);
+    return async (req) => {
+        const res = await impl(req.url, {
+            method: req.method,
+            ...(req.headers ? { headers: { ...req.headers } } : {}),
+            ...(req.body !== undefined ? { body: req.body } : {}),
+        });
+        return {
+            status: res.status,
+            ok: res.ok,
+            header: (name) => res.headers.get(name),
+            json: () => res.json(),
+            text: () => res.text(),
+        };
+    };
+}

package/dist/platform/calendar/ics-parser.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ics-parser.ts — a pure, dependency-free iCalendar (RFC 5545) reader.
+ *
+ * Vendored on purpose. The SDK's `packages/sdk` ships ZERO third-party runtime
+ * dependencies (workspace packages only — see packages/sdk/package.json), and it
+ * guards that with bundle-budget / browser-compat / no-any gates. Pulling a general
+ * ICS library in for the read-focused subset we actually need would break that
+ * convention for little gain; this focused reader matches repo style and is easy to
+ * hold honest. See the decision record for the vendored-vs-dependency ruling and the
+ * exact supported subset.
+ *
+ * Scope of what this reads (documented, not faked):
+ *  - VCALENDAR framing, X-WR-CALNAME for a calendar display name.
+ *  - VEVENT: UID, SUMMARY, LOCATION, DESCRIPTION, DTSTART, DTEND, RRULE.
+ *  - DTSTART/DTEND as VALUE=DATE ('YYYYMMDD') or date-time ('YYYYMMDDTHHMMSS'),
+ *    with honest zone anchoring: trailing 'Z' => utc; TZID=... => tzid (wall time
+ *    kept, NOT offset-converted, because this build has no tz database); otherwise
+ *    floating. RRULE is captured raw and handed to the recurrence expander.
+ *  - RFC 5545 line unfolding (a leading space/tab continues the previous line) and
+ *    TEXT unescaping (\\n \\, \\; \\, \\\\).
+ *
+ * Everything unrecognised is ignored quietly EXCEPT the two things a caller must be
+ * told about: a VEVENT with no usable DTSTART is `skipped` with a reason, and an
+ * RRULE we do not fully expand is flagged on the event (in rrule.ts) — never dropped.
+ *
+ * PURE: no fs, no network, no process globals. Input is text; output is data.
+ */
+import type { ParsedCalendar } from './types.js';
+/**
+ * Parse .ics text into typed events plus honest skip/diagnostic lists.
+ *
+ * @param text raw .ics content (file body or fetched feed body).
+ */
+export declare function parseIcs(text: string): ParsedCalendar;
+//# sourceMappingURL=ics-parser.d.ts.map

package/dist/platform/calendar/ics-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ics-parser.d.ts","sourceRoot":"","sources":["../../../src/platform/calendar/ics-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAIV,cAAc,EACf,MAAM,YAAY,CAAC;AA2HpB;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CA6ErD"}