@oomol-lab/open-connector 1.6.5 → 1.8.0

package/src/providers/googlechat/members.js

@@ -0,0 +1,293 @@
+import { compactObject, looseArray, optionalRecord, optionalString, recordOrEmpty } from "../../core/cast.js";
+import { ProviderRequestError, providerResponseError } from "../provider-runtime.js";
+import { encodeResourceName, googleChatApiBaseUrl, googleChatJsonRequest, stripPrefix } from "./runtime.js";
+const peopleApiBaseUrl = "https://people.googleapis.com/v1";
+// A direct message has at most two members, so this only guards against a
+// pagination token that never runs out.
+const maxDirectMessageMemberPages = 20;
+/** people:batchGet accepts at most this many resource names per call. */
+export const maxProfilesPerLookup = 200;
+// google.rpc.Code values a per-person batchGet status can carry.
+const rpcNotFound = 5;
+const rpcPermissionDenied = 7;
+/**
+ * Name the other participant of a direct message. The authenticated user and the
+ * peer are told apart by id, because a Chat membership never says which member is
+ * "me". BOT and SELF are ordinary outcomes, not failures: they keep whatever name
+ * and email Chat reports for the membership and skip the directory.
+ */
+export async function resolveDirectMessagePeer(spaceName, context) {
+    const [selfUser, members] = await Promise.all([readSelfUserName(context), listAllMembers(spaceName, context)]);
+    const humans = members.filter((member) => member.type === "HUMAN");
+    const bots = members.filter((member) => member.type === "BOT");
+    const others = humans.filter((member) => member.name !== selfUser);
+    const self = humans.find((member) => member.name === selfUser);
+    if (others.length === 1) {
+        const [peer] = others;
+        const profiles = await lookupProfiles(missingChatProfiles(others), context);
+        return { kind: "HUMAN", user: peer.name, ...mergeProfile(peer, profiles.get(peer.name)) };
+    }
+    if (others.length > 1) {
+        return ambiguousPeer(others);
+    }
+    if (bots.length === 1) {
+        const [peer] = bots;
+        return { kind: "BOT", user: peer.name, ...mergeProfile(peer, undefined) };
+    }
+    if (bots.length === 0 && self) {
+        return { kind: "SELF", user: self.name, ...mergeProfile(self, undefined) };
+    }
+    return ambiguousPeer(bots);
+}
+/**
+ * One page of a space's members. Every human Google Chat left without a name or
+ * email is looked up in a single batched directory call; the page size is capped
+ * so one call always covers the page.
+ */
+export async function listSpaceMembersPage(spaceName, request, context) {
+    const [selfUser, page] = await Promise.all([readSelfUserName(context), fetchMemberPage(spaceName, request, context)]);
+    const humans = page.members.filter((member) => member.type === "HUMAN");
+    const profiles = await lookupProfiles(missingChatProfiles(humans), context);
+    return {
+        members: page.members.map((member) => ({
+            user: member.name,
+            kind: member.type,
+            role: member.role,
+            isSelf: member.name === selfUser,
+            ...mergeProfile(member, profiles.get(member.name)),
+        })),
+        nextPageToken: page.nextPageToken ?? null,
+    };
+}
+function ambiguousPeer(candidates) {
+    return {
+        kind: "AMBIGUOUS",
+        user: null,
+        displayName: null,
+        email: null,
+        candidates: candidates.map((member) => member.name),
+    };
+}
+/** The authenticated user's own `users/{id}`; People and Chat share the id. */
+async function readSelfUserName(context) {
+    let payload;
+    try {
+        payload = recordOrEmpty(await googleChatJsonRequest(`${peopleApiBaseUrl}/people/me`, {
+            context,
+            query: { personFields: "metadata" },
+        }));
+    }
+    catch (error) {
+        if (context.signal?.aborted) {
+            throw error;
+        }
+        // Only a 403 can mean the People API is not enabled for the project.
+        throw explainLookupError("could not read the authenticated user's own id from the People API, so members cannot be told apart from the caller", error, "The People API must be enabled for the OAuth client's Google Cloud project.");
+    }
+    const resourceName = optionalString(payload.resourceName);
+    if (!resourceName?.startsWith("people/")) {
+        throw new ProviderRequestError(502, "the People API returned no resource name for the authenticated user");
+    }
+    return `users/${stripPrefix(resourceName, "people/")}`;
+}
+/**
+ * Say which Chat or People lookup failed. An HTTP failure keeps its status and
+ * details and gains forbiddenHint on a 403, the only status a console or consent
+ * change can fix; a 429, a 5xx, or a timeout needs a retry instead. A failure that
+ * is not an HTTP error, such as a response that is not JSON, becomes a 502 that
+ * names the lookup instead of reaching the caller as a raw internal error.
+ */
+function explainLookupError(summary, error, forbiddenHint) {
+    if (!(error instanceof ProviderRequestError)) {
+        return providerResponseError(`${summary}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const hint = error.status === 403 ? ` ${forbiddenHint}` : "";
+    // Google's messages usually end in a period already; drop it so the sentence ends once.
+    const detail = error.message.replace(/\.\s*$/, "");
+    return new ProviderRequestError(error.status, `${summary}: ${detail}.${hint}`, error.details);
+}
+async function listAllMembers(spaceName, context) {
+    let members = [];
+    let pageToken;
+    for (let page = 0; page < maxDirectMessageMemberPages; page += 1) {
+        let result;
+        try {
+            // Chat leaves invited members out by default. A peer who has not joined the
+            // conversation yet is still the peer; without it the caller would be the only
+            // member left and the direct message would be misreported as SELF.
+            result = await fetchMemberPage(spaceName, { pageSize: 100, pageToken, showInvited: true }, context);
+        }
+        catch (error) {
+            if (context.signal?.aborted) {
+                throw error;
+            }
+            // A 403 here is almost always the missing scope: the space itself was readable.
+            throw explainLookupError(`could not list the members of ${spaceName}, so the direct message's other participant is unknown`, error, "Listing members needs the chat.memberships.readonly scope, which service account connections never request; an OAuth connection authorized before this scope was added must be reconnected to grant it.");
+        }
+        members = [...members, ...result.members];
+        pageToken = result.nextPageToken;
+        if (!pageToken) {
+            return members;
+        }
+    }
+    throw new ProviderRequestError(502, `Google Chat kept paginating the members of ${spaceName}`);
+}
+async function fetchMemberPage(spaceName, request, context) {
+    const payload = await googleChatJsonRequest(`${googleChatApiBaseUrl}/${encodeResourceName(spaceName)}/members`, {
+        context,
+        query: compactObject({
+            pageSize: String(request.pageSize),
+            pageToken: request.pageToken,
+            showInvited: request.showInvited ? "true" : undefined,
+        }),
+    });
+    return {
+        members: looseArray(payload.memberships).flatMap((item) => toChatMember(item)),
+        nextPageToken: optionalString(payload.nextPageToken),
+    };
+}
+function toChatMember(value) {
+    const membership = recordOrEmpty(value);
+    const member = recordOrEmpty(membership.member);
+    const name = optionalString(member.name);
+    return name
+        ? [
+            {
+                name,
+                type: optionalString(member.type),
+                role: optionalString(membership.role),
+                displayName: optionalString(member.displayName),
+                email: optionalString(member.email),
+            },
+        ]
+        : [];
+}
+/**
+ * Fill in each human sender's name and email on normalized messages. Under user
+ * authentication Chat reports them itself only for members of the space and users
+ * with prior affinity to the caller, so every human sender missing either is
+ * looked up in the directory. Distinct senders are looked up together, so a page
+ * costs one extra request per 200 senders. A failed lookup leaves the message
+ * intact with a null name and a reason; bots and messages without a sender are
+ * left as they are.
+ */
+export async function attachSenderProfiles(messages, context) {
+    const profiles = await lookupProfiles(missingChatProfiles(messages.flatMap((message) => humanSender(message))), context);
+    return messages.map((message) => {
+        const [sender] = humanSender(message);
+        return sender
+            ? { ...message, sender: { ...recordOrEmpty(message.sender), ...mergeProfile(sender, profiles.get(sender.name)) } }
+            : message;
+    });
+}
+/** The human users/{id} sender of a normalized message, if it has one. */
+function humanSender(message) {
+    const sender = optionalRecord(message.sender);
+    const name = optionalString(sender?.name);
+    return sender?.type === "HUMAN" && name?.startsWith("users/")
+        ? [{ name, displayName: optionalString(sender.displayName), email: optionalString(sender.email) }]
+        : [];
+}
+/** The distinct users whose name or email Chat left out, which only the directory can fill in. */
+function missingChatProfiles(users) {
+    const missing = users.filter((user) => user.displayName === undefined || user.email === undefined);
+    return [...new Set(missing.map((user) => user.name))];
+}
+/**
+ * Combine what Chat reported with the directory profile. Chat's own name and email
+ * win and the directory only fills in what Chat left out, so a failed lookup never
+ * replaces a known value with null. profileUnavailableReason explains a null
+ * displayName, so it is only kept while the name is still missing.
+ */
+function mergeProfile(chat, directory) {
+    const displayName = chat.displayName ?? directory?.displayName ?? null;
+    return {
+        displayName,
+        email: chat.email ?? directory?.email ?? null,
+        profileUnavailableReason: displayName === null ? directory?.profileUnavailableReason : undefined,
+    };
+}
+/**
+ * Name `users/{id}` members through the Workspace directory, batching up to the
+ * People API limit per call. A member whose profile cannot be read keeps a null
+ * name and a reason; a failure of a whole call gives each member in it that reason.
+ */
+async function lookupProfiles(users, context) {
+    const batches = Array.from({ length: Math.ceil(users.length / maxProfilesPerLookup) }, (_, index) => users.slice(index * maxProfilesPerLookup, (index + 1) * maxProfilesPerLookup));
+    const results = await Promise.all(batches.map((batch) => lookupProfileBatch(batch, context)));
+    return new Map(results.flatMap((result) => [...result]));
+}
+async function lookupProfileBatch(users, context) {
+    let payload;
+    try {
+        payload = recordOrEmpty(await googleChatJsonRequest(`${peopleApiBaseUrl}/people:batchGet`, {
+            context,
+            query: {
+                resourceNames: users.map((user) => `people/${stripPrefix(user, "users/")}`),
+                personFields: "names,emailAddresses",
+                sources: "READ_SOURCE_TYPE_PROFILE",
+            },
+        }));
+    }
+    catch (error) {
+        // Naming is best effort, so only a cancelled request stops the action. Any
+        // other failure, including a network error or a 200 whose body is not JSON,
+        // leaves the users unnamed with a reason.
+        if (context.signal?.aborted) {
+            throw error;
+        }
+        const reason = error instanceof ProviderRequestError ? httpFailureReason(error.status) : "people_request_failed";
+        return new Map(users.map((user) => [user, unavailableProfile(reason)]));
+    }
+    const responses = new Map(looseArray(payload.responses).map((entry) => {
+        const response = recordOrEmpty(entry);
+        return [optionalString(response.requestedResourceName), response];
+    }));
+    return new Map(users.map((user) => [user, toMemberProfile(responses.get(`people/${stripPrefix(user, "users/")}`))]));
+}
+function toMemberProfile(response) {
+    // A missing entry says nothing about the person: a genuine miss comes back as its
+    // own NOT_FOUND status, so an absent or unmatched entry is a malformed response.
+    if (!response) {
+        return unavailableProfile("people_request_failed");
+    }
+    const rpcCode = optionalRecord(response.status)?.code;
+    if (typeof rpcCode === "number" && rpcCode !== 0) {
+        return unavailableProfile(rpcFailureReason(rpcCode));
+    }
+    const person = recordOrEmpty(response.person);
+    const displayName = primaryProfileValue(person.names, "displayName");
+    return {
+        displayName: displayName ?? null,
+        email: primaryProfileValue(person.emailAddresses, "value") ?? null,
+        // A 200 without a name is what a Workspace with profile sharing turned off returns.
+        profileUnavailableReason: displayName ? undefined : "profile_name_missing",
+    };
+}
+function unavailableProfile(reason) {
+    return { displayName: null, email: null, profileUnavailableReason: reason };
+}
+/** Only 403 and 404 say something about the profile; anything else is a failed request, not a hidden one. */
+function httpFailureReason(status) {
+    if (status === 403) {
+        return "people_forbidden";
+    }
+    if (status === 404) {
+        return "people_not_found";
+    }
+    return "people_request_failed";
+}
+function rpcFailureReason(code) {
+    if (code === rpcPermissionDenied) {
+        return "people_forbidden";
+    }
+    if (code === rpcNotFound) {
+        return "people_not_found";
+    }
+    return "people_request_failed";
+}
+function primaryProfileValue(value, field) {
+    const entries = looseArray(value).map((entry) => recordOrEmpty(entry));
+    const primary = entries.find((entry) => optionalRecord(entry.metadata)?.primary === true) ?? entries[0];
+    return optionalString(primary?.[field]);
+}

package/src/providers/googlechat/runtime.d.ts

@@ -0,0 +1,16 @@
+import type { GoogleQueryValue } from "../googledrive/runtime-request.ts";
+import type { OAuthProviderContext } from "../provider-runtime.ts";
+export declare const googleChatApiBaseUrl = "https://chat.googleapis.com/v1";
+export type GoogleChatRuntimeContext = OAuthProviderContext;
+interface GoogleChatRequestInput {
+    context: Pick<GoogleChatRuntimeContext, "accessToken" | "fetcher" | "signal">;
+    method?: string;
+    query?: Record<string, GoogleQueryValue>;
+    body?: unknown;
+}
+/** Send an authenticated JSON request on behalf of the Google Chat connection, to Chat or another Google API. */
+export declare function googleChatJsonRequest<T>(url: string, input: GoogleChatRequestInput): Promise<T>;
+/** Percent-encode each segment of a resource name such as spaces/{space}, keeping the separators. */
+export declare function encodeResourceName(name: string): string;
+export declare function stripPrefix(value: string, prefix: string): string;
+export {};

package/src/providers/googlechat/runtime.js

@@ -0,0 +1,25 @@
+import { googleJsonRequest } from "../googledrive/runtime-request.js";
+export const googleChatApiBaseUrl = "https://chat.googleapis.com/v1";
+const service = "googlechat";
+/** Send an authenticated JSON request on behalf of the Google Chat connection, to Chat or another Google API. */
+export function googleChatJsonRequest(url, input) {
+    return googleJsonRequest(url, {
+        accessToken: input.context.accessToken,
+        fetcher: input.context.fetcher,
+        signal: input.context.signal,
+        method: input.method,
+        query: input.query,
+        body: input.body,
+        service,
+    });
+}
+/** Percent-encode each segment of a resource name such as spaces/{space}, keeping the separators. */
+export function encodeResourceName(name) {
+    return name
+        .split("/")
+        .map((segment) => encodeURIComponent(segment))
+        .join("/");
+}
+export function stripPrefix(value, prefix) {
+    return value.startsWith(prefix) ? value.slice(prefix.length) : value;
+}

package/src/providers/googlechat/scopes.d.ts

@@ -1,6 +1,25 @@
 export declare const googleChatSpacesReadonlyScope = "https://www.googleapis.com/auth/chat.spaces.readonly";
 export declare const googleChatMessagesReadonlyScope = "https://www.googleapis.com/auth/chat.messages.readonly";
-export declare const googleOpenIdScope = "openid";
-export declare const googleEmailScope = "email";
-export declare const googleProfileScope = "profile";
+/**
+ * Grants only "compose and send messages". Deliberately not `chat.messages`,
+ * which Google describes as "see, compose, send, update, and delete messages"
+ * plus reactions — far beyond what sending a message needs.
+ */
+export declare const googleChatMessagesCreateScope = "https://www.googleapis.com/auth/chat.messages.create";
+/** Lists the members of a space, which is the only way to learn a direct message's other participant. */
+export declare const googleChatMembershipsReadonlyScope = "https://www.googleapis.com/auth/chat.memberships.readonly";
+/**
+ * Reads Workspace directory profiles through the People API. Under user
+ * authentication Chat can report a member as just `users/{id}` with no name, and
+ * this is the narrowest scope that turns that id into a name. It exposes the organization directory, not
+ * just the peer, and Workspace admins can restrict it or disable profile sharing.
+ */
+export declare const googleDirectoryReadonlyScope = "https://www.googleapis.com/auth/directory.readonly";
+/**
+ * Scopes minted into service account tokens. Frozen at what existing domain-wide
+ * delegations already grant: a token request that asks for an undelegated scope
+ * fails as a whole, which would break every Chat action, not just the new ones.
+ * Service account connections therefore cannot send messages or name members.
+ */
+export declare const googleChatServiceAccountScopes: string[];
 export declare const googleChatOAuthScopes: string[];

package/src/providers/googlechat/scopes.js

@@ -1,12 +1,35 @@
+import { googleIdentityScopes } from "../googleads/scopes.js";
 export const googleChatSpacesReadonlyScope = "https://www.googleapis.com/auth/chat.spaces.readonly";
 export const googleChatMessagesReadonlyScope = "https://www.googleapis.com/auth/chat.messages.readonly";
-export const googleOpenIdScope = "openid";
-export const googleEmailScope = "email";
-export const googleProfileScope = "profile";
-export const googleChatOAuthScopes = [
+/**
+ * Grants only "compose and send messages". Deliberately not `chat.messages`,
+ * which Google describes as "see, compose, send, update, and delete messages"
+ * plus reactions — far beyond what sending a message needs.
+ */
+export const googleChatMessagesCreateScope = "https://www.googleapis.com/auth/chat.messages.create";
+/** Lists the members of a space, which is the only way to learn a direct message's other participant. */
+export const googleChatMembershipsReadonlyScope = "https://www.googleapis.com/auth/chat.memberships.readonly";
+/**
+ * Reads Workspace directory profiles through the People API. Under user
+ * authentication Chat can report a member as just `users/{id}` with no name, and
+ * this is the narrowest scope that turns that id into a name. It exposes the organization directory, not
+ * just the peer, and Workspace admins can restrict it or disable profile sharing.
+ */
+export const googleDirectoryReadonlyScope = "https://www.googleapis.com/auth/directory.readonly";
+/**
+ * Scopes minted into service account tokens. Frozen at what existing domain-wide
+ * delegations already grant: a token request that asks for an undelegated scope
+ * fails as a whole, which would break every Chat action, not just the new ones.
+ * Service account connections therefore cannot send messages or name members.
+ */
+export const googleChatServiceAccountScopes = [
     googleChatSpacesReadonlyScope,
     googleChatMessagesReadonlyScope,
-    googleOpenIdScope,
-    googleEmailScope,
-    googleProfileScope,
+    ...googleIdentityScopes,
+];
+export const googleChatOAuthScopes = [
+    ...googleChatServiceAccountScopes,
+    googleChatMessagesCreateScope,
+    googleChatMembershipsReadonlyScope,
+    googleDirectoryReadonlyScope,
 ];

package/src/providers/googledocs/executors.js

@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer";
 import { integer, objectArray } from "../../core/cast.js";
-import { googleJsonRequest as googleJsonRequestShared, googleRequest as googleRequestShared, } from "../google-runtime.js";
+import { googleJsonRequest as googleJsonRequestShared, googleRequest as googleRequestShared, } from "../googledrive/runtime-request.js";
 import { asObject, asOptionalObject, asStringArray, compactObject, optionalBoolean, } from "../googledrive/runtime-shared.js";
 import { defineProviderExecutors, defineProviderProxy, ProviderRequestError, requireOAuthCredential, } from "../provider-runtime.js";
 const docsApiBaseUrl = "https://docs.googleapis.com/v1";

package/src/providers/googledrive/executors.d.ts

@@ -1,4 +1,7 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 export declare const executors: ProviderExecutors;
 export declare const credentialValidators: CredentialValidators;
 export declare const proxy: ProviderProxyExecutor;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];

package/src/providers/googledrive/executors.js

@@ -1,12 +1,14 @@
 import { randomUUID } from "node:crypto";
 import { requiredRawString, requiredString } from "../../core/cast.js";
 import { readBoundedResponseBytes } from "../../core/request.js";
-import { defineGoogleProviderExecutors, googleBearerProxyAuth, googleServiceAccountValidator } from "../google-auth.js";
-import { googleJsonRequest, googleRequest } from "../google-runtime.js";
 import { defineProviderProxy, providerProxyEndpointPrefixes, ProviderRequestError, providerResponseError, } from "../provider-runtime.js";
+import { defineGoogleProviderExecutors, googleBearerProxyAuth, googleServiceAccountValidator } from "./runtime-auth.js";
 import { createComment, createPermission, createReply, deleteComment, deletePermission, deleteReply, deleteRevision, getAbout, getApp, getComment, getPermission, getReply, getRevision, listComments, listFileLabels, listPermissions, listReplies, listRevisions, modifyFileLabels, updateComment, updateFileRevisionMetadata, updatePermission, updateReply, } from "./runtime-collaboration.js";
+import { googleJsonRequest, googleRequest } from "./runtime-request.js";
 import { asObject, asOptionalObject, asOptionalInteger, asStringArray, asStringRecord, compactObject, compactUnknownObject, optionalBoolean, optionalNestedString, optionalString, parseSizeBytes, pickOptionalBoolean, pickOptionalInteger, pickOptionalString, resolveFileId, resolveRequiredString, resolveSupportsAllDrives, } from "./runtime-shared.js";
 import { googledriveOAuthScopes } from "./scopes.js";
+import { googleDriveChanges, googleDriveChangeListener } from "./trigger-changes.js";
+import { googleDriveFileChange } from "./trigger-on-file-change.js";
 const service = "googledrive";
 const driveApiBaseUrl = "https://www.googleapis.com/drive/v3";
 const driveUploadApiBaseUrl = "https://www.googleapis.com/upload/drive/v3";
@@ -863,3 +865,8 @@ export const proxy = defineProviderProxy({
     auth: googleBearerProxyAuth(googledriveOAuthScopes),
     allowedEndpoint: providerProxyEndpointPrefixes("/drive/v3", "/upload/drive/v3"),
 });
+export const triggers = [
+    googleDriveChanges,
+    googleDriveChangeListener,
+    googleDriveFileChange,
+];

package/src/providers/{google-auth.d.ts → googledrive/runtime-auth.d.ts}

@@ -1,5 +1,5 @@
-import type { CredentialValidators, ProviderExecutors, ResolvedCredential } from "../core/types.ts";
-import type { OAuthProviderContext, ProviderFetch, ProviderProxyAuth, ProviderRuntimeHandler } from "./provider-runtime.ts";
+import type { CredentialValidators, ProviderExecutors, ResolvedCredential } from "../../core/types.ts";
+import type { OAuthProviderContext, ProviderFetch, ProviderProxyAuth, ProviderRuntimeHandler } from "../provider-runtime.ts";
 /**
  * A Google service account identity read from a stored custom credential.
  */

package/src/providers/{google-auth.js → googledrive/runtime-auth.js}

@@ -1,7 +1,7 @@
 import { importPKCS8, SignJWT } from "jose";
-import { sha256Hex } from "../core/aws-sigv4.js";
-import { optionalNumberLike, optionalRecord, optionalString } from "../core/cast.js";
-import { defineProviderExecutors, providerInputError, ProviderRequestError, providerUserAgent, requiredInputString, runProviderRequest, } from "./provider-runtime.js";
+import { sha256Hex } from "../../core/aws-sigv4.js";
+import { optionalNumberLike, optionalRecord, optionalString } from "../../core/cast.js";
+import { defineProviderExecutors, providerInputError, ProviderRequestError, providerUserAgent, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
 const googleTokenUrl = "https://oauth2.googleapis.com/token";
 const jwtBearerGrantType = "urn:ietf:params:oauth:grant-type:jwt-bearer";
 /** Google issues one-hour access tokens for JWT bearer grants; assertions may ask for at most one hour. */

package/src/providers/googledrive/runtime-collaboration.js

@@ -1,5 +1,5 @@
-import { googleJsonRequest, googleRequest } from "../google-runtime.js";
 import { ProviderRequestError } from "../provider-runtime.js";
+import { googleJsonRequest, googleRequest } from "./runtime-request.js";
 import { asObject, asOptionalObject, asStringArray, asStringRecordOrUndefined, compactObject, compactUnknownObject, optionalBoolean, optionalString, parseSizeBytes, pickOptionalBoolean, pickOptionalInteger, pickOptionalString, resolveFileId, resolveRequiredString, resolveSupportsAllDrives, } from "./runtime-shared.js";
 const driveApiBaseUrl = "https://www.googleapis.com/drive/v3";
 const permissionFields = [

package/src/providers/{google-runtime.d.ts → googledrive/runtime-request.d.ts}

@@ -1,4 +1,4 @@
-import type { ProviderFetch } from "./provider-runtime.ts";
+import type { ProviderFetch } from "../provider-runtime.ts";
 export type GoogleQueryValue = string | readonly string[] | undefined;
 export interface GoogleRequestOptions {
     accessToken: string;

package/src/providers/{google-runtime.js → googledrive/runtime-request.js}

@@ -1,5 +1,5 @@
-import { optionalRecord, optionalString } from "../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, } from "./provider-runtime.js";
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
 const defaultService = "googledrive";
 const googleDefaultRequestTimeoutMs = 30_000;
 export async function googleJsonRequest(url, input) {

package/src/providers/googledrive/trigger-changes.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { ConnectorProxy } from "../../triggers/common/proxy.ts";
+import type { JsonValue } from "../../triggers/common/types.ts";
+interface ReadContext {
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly connector: ConnectorProxy;
+    readonly signal?: AbortSignal;
+}
+export declare const googleDriveChanges: IntegrationDefinition;
+export declare function googleDriveStartPageToken(context: ReadContext): Promise<string>;
+export declare const googleDriveChangeListener: IntegrationDefinition;
+export {};

package/src/providers/googledrive/trigger-changes.definition.d.ts

@@ -0,0 +1,7 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "integration";
+};
+export declare const additionalSnapshot0: TriggerKeySnapshot & {
+    readonly type: "integration";
+};

package/src/providers/googledrive/trigger-changes.definition.js

@@ -0,0 +1,101 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const defaultPageSize = 100;
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "driveId",
+            jsonSchema: s.string({ maxLength: 256, minLength: 1 }),
+            nullable: true,
+            description: "Optional shared drive ID. Omit it to monitor the connected account.",
+        },
+        {
+            handle: "includeCorpusRemovals",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+            description: "Include the accessible file resource when an item leaves the change corpus.",
+        },
+        {
+            handle: "includeItemsFromAllDrives",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: true,
+            description: "Include items from My Drive and shared drives.",
+        },
+        {
+            handle: "includeRemoved",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: true,
+            description: "Include changes caused by deletion or loss of access.",
+        },
+        {
+            handle: "pageSize",
+            jsonSchema: s.integer({ maximum: 100, minimum: 1 }),
+            nullable: false,
+            value: defaultPageSize,
+            description: "Maximum changes included in one Flow Run.",
+        },
+        {
+            handle: "restrictToMyDrive",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+            description: "Restrict changes to the My Drive hierarchy.",
+        },
+    ],
+    definitionVersion: 2,
+    description: "Uses a Google Drive changes.watch channel and triggers when Drive changes are available.",
+    displayName: "Changes Detected",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: true, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 204,
+    },
+    key: "googledrive.changes_detected",
+    name: "changes_detected",
+    outputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array(s.object({
+                changeId: s.string(),
+                changeType: { type: ["string", "null"] },
+                driveId: { type: ["string", "null"] },
+                file: { type: ["object", "null"] },
+                fileId: { type: ["string", "null"] },
+                notification: s.object({
+                    changedTypes: s.array(s.string()),
+                    messageNumber: { type: ["string", "null"] },
+                    resourceState: s.string(),
+                    resourceUri: { type: ["string", "null"] },
+                }, {
+                    additionalProperties: false,
+                    required: ["resourceState", "changedTypes", "messageNumber", "resourceUri"],
+                }),
+                removed: s.boolean(),
+                time: { type: ["string", "null"] },
+            }, {
+                additionalProperties: false,
+                required: ["changeId", "changeType", "removed", "time", "fileId", "driveId", "file", "notification"],
+            })),
+            nullable: false,
+        },
+    ],
+    provider: "googledrive",
+    type: "integration",
+};
+export const additionalSnapshot0 = {
+    ...snapshot,
+    configInputs: snapshot.configInputs,
+    key: "googledrive.watch_changes",
+    name: "watch_changes",
+    displayName: "Watch Changes",
+    description: "Monitors Drive changes using notifications and periodic scans of the same change stream.",
+    outputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array({ type: "object" }),
+            nullable: false,
+        },
+    ],
+};