@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/providers/vercel/runtime.js

@@ -1,8 +1,60 @@
+import { createHash } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 import { compactObject, looseArray, optionalBoolean, optionalNumber, optionalRecord, optionalString, } from "../../core/cast.js";
-import { jsonObject, queryFlag, queryParams } from "../../core/request.js";
-import { ProviderRequestError, providerUserAgent, requiredResponseRecord } from "../provider-runtime.js";
+import { jsonObject, queryParams } from "../../core/request.js";
+import { providerInputError, runProviderRequest, ProviderRequestError, providerUserAgent, requiredResponseRecord, } from "../provider-runtime.js";
 export const vercelApiBaseUrl = "https://api.vercel.com";
 export const vercelActionHandlers = {
+    create_git_deployment(input, context) {
+        return vercelCreateGitDeployment(input, context);
+    },
+    redeploy_deployment(input, context) {
+        return vercelRedeployDeployment(input, context);
+    },
+    upload_deployment_file_from_url(input, context) {
+        return vercelUploadDeploymentFileFromUrl(input, context);
+    },
+    create_file_deployment(input, context) {
+        return vercelCreateFileDeployment(input, context);
+    },
+    list_deployment_files(input, context) {
+        return vercelListDeploymentFiles(input, context);
+    },
+    get_deployment_file_contents(input, context) {
+        return vercelGetDeploymentFileContents(input, context);
+    },
+    list_deployment_aliases(input, context) {
+        return vercelListDeploymentAliases(input, context);
+    },
+    assign_deployment_alias(input, context) {
+        return vercelAssignDeploymentAlias(input, context);
+    },
+    update_deployment_integration_action(input, context) {
+        return vercelUpdateDeploymentIntegrationAction(input, context);
+    },
+    cancel_deployment(input, context) {
+        return vercelCancelDeployment(input, context);
+    },
+    delete_deployment(input, context) {
+        return vercelDeleteDeployment(input, context);
+    },
+    promote_deployment(input, context) {
+        return vercelPromoteDeployment(input, context);
+    },
+    rollback_deployment(input, context) {
+        return vercelRollbackDeployment(input, context);
+    },
+    get_latest_deployment_promotion_aliases(input, context) {
+        return vercelGetLatestDeploymentPromotionAliases(input, context);
+    },
+    update_deployment_rollback_description(input, context) {
+        return vercelUpdateDeploymentRollbackDescription(input, context);
+    },
     get_auth_user(input, context) {
         return vercelGetAuthUser(input, context);
     },
@@ -339,18 +391,26 @@ async function vercelUpdateProject(input, context) {
     };
 }
 async function vercelListDeployments(input, context) {
+    rejectConflictingDeploymentProjectFilters(input);
     const payload = await requestVercelJson({
-        path: "/v6/deployments",
+        path: "/v7/deployments",
         apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
         fetcher: context.fetcher,
         mode: "execute",
-        query: teamQuery(input, context, {
-            limit: optionalNumber(input.limit),
+        query: compactObject({
+            app: optionalString(input.app),
+            limit: toQueryString(optionalNumber(input.limit)),
             projectId: optionalString(input.projectId),
-            since: optionalNumber(input.since),
-            until: optionalNumber(input.until),
+            projectIds: normalizeStringArray(input.projectIds),
+            since: toQueryString(optionalNumber(input.since)),
+            until: toQueryString(optionalNumber(input.until)),
             target: optionalString(input.target),
-            state: optionalString(input.state),
+            state: toCommaSeparatedString(input.states),
+            users: toCommaSeparatedString(input.userIds),
+            rollbackCandidate: toQueryBoolean(optionalBoolean(input.rollbackCandidate)),
+            branch: optionalString(input.branch),
+            sha: optionalString(input.sha),
         }),
     });
     return compactObject({
@@ -363,10 +423,11 @@ async function vercelGetDeployment(input, context) {
     const payload = await requestVercelJson({
         path: `/v13/deployments/${encodeURIComponent(idOrUrl)}`,
         apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
         fetcher: context.fetcher,
         mode: "execute",
-        query: teamQuery(input, context, {
-            withGitRepoInfo: optionalBoolean(input.withGitRepoInfo),
+        query: compactObject({
+            withGitRepoInfo: toQueryBoolean(optionalBoolean(input.withGitRepoInfo)),
         }),
         notFoundAsInvalidInput: true,
     });
@@ -379,14 +440,18 @@ async function vercelGetDeploymentEvents(input, context) {
     const payload = await requestVercelJson({
         path: `/v3/deployments/${encodeURIComponent(idOrUrl)}/events`,
         apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
         fetcher: context.fetcher,
         mode: "execute",
-        query: teamQuery(input, context, {
-            builds: queryFlag(optionalBoolean(input.builds)),
+        query: compactObject({
+            builds: toQueryFlag(optionalBoolean(input.builds)),
+            delimiter: toQueryFlag(optionalBoolean(input.delimiter)),
             direction: optionalString(input.direction),
-            limit: optionalNumber(input.limit),
-            since: optionalNumber(input.since),
-            until: optionalNumber(input.until),
+            limit: toQueryString(optionalNumber(input.limit)),
+            name: optionalString(input.buildId),
+            since: toQueryString(optionalNumber(input.since)),
+            statusCode: optionalString(input.statusCode),
+            until: toQueryString(optionalNumber(input.until)),
         }),
         notFoundAsInvalidInput: true,
     });
@@ -644,6 +709,10 @@ async function requestVercelJson(options) {
     if (!response.ok) {
         throw await mapVercelError(response, options.mode, options.notFoundAsInvalidInput ?? false);
     }
+    if (options.responseBody === "none") {
+        await response.body?.cancel();
+        return undefined;
+    }
     if (response.status === 204) {
         throw new ProviderRequestError(502, "vercel returned 204 No Content for a JSON request");
     }
@@ -669,33 +738,47 @@ async function requestVercelNoContent(options) {
     throw new ProviderRequestError(502, "vercel returned a response body for a no-content request");
 }
 async function requestVercel(options) {
-    const url = buildVercelUrl(options.path, options.query);
+    const url = buildVercelUrl(options.path, {
+        ...options.query,
+        ...(options.includeTeamScope === false ? {} : options.scope),
+    });
     try {
         return await options.fetcher(url, {
+            signal: options.signal,
             method: options.method ?? "GET",
-            headers: vercelHeaders(options.apiKey, options.body !== undefined),
-            ...(options.body === undefined ? {} : { body: JSON.stringify(options.body) }),
+            headers: vercelHeaders(options.apiKey, options.body !== undefined, options.headers),
+            body: options.rawBody ?? (options.body === undefined ? undefined : JSON.stringify(options.body)),
+            ...(options.rawBody instanceof ReadableStream ? { duplex: "half" } : {}),
         });
     }
     catch (error) {
+        if (error instanceof ProviderRequestError)
+            throw error;
         throw new ProviderRequestError(502, error instanceof Error ? error.message : "vercel request failed");
     }
 }
 function buildVercelUrl(path, query) {
     const url = new URL(path, vercelApiBaseUrl);
     for (const [key, value] of Object.entries(query ?? {})) {
-        if (value !== undefined) {
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                url.searchParams.append(key, item);
+            }
+        }
+        else if (value !== undefined) {
             url.searchParams.set(key, value);
         }
     }
     return url.toString();
 }
-function vercelHeaders(apiKey, hasJsonBody) {
-    return {
-        authorization: `Bearer ${apiKey}`,
-        ...(hasJsonBody ? { "content-type": "application/json" } : {}),
-        "user-agent": providerUserAgent,
-    };
+function vercelHeaders(apiKey, hasJsonBody, additional) {
+    const headers = new Headers(additional);
+    headers.set("authorization", `Bearer ${apiKey}`);
+    headers.set("user-agent", providerUserAgent);
+    if (hasJsonBody && !headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+    }
+    return headers;
 }
 async function mapVercelError(response, mode, notFoundAsInvalidInput) {
     const error = await readVercelError(response);
@@ -703,7 +786,7 @@ async function mapVercelError(response, mode, notFoundAsInvalidInput) {
         return new ProviderRequestError(400, error.message, error);
     }
     if (response.status === 401) {
-        return new ProviderRequestError(mode === "validate" ? 400 : 401, error.message, error);
+        return new ProviderRequestError(response.status, error.message, error, "provider_error");
     }
     if ((response.status === 404 || response.status === 410) && notFoundAsInvalidInput) {
         return new ProviderRequestError(400, error.message, error);
@@ -789,7 +872,7 @@ function mapProject(value) {
 function mapDeployment(value) {
     const deployment = requiredResponseRecord(value, "deployment");
     return compactObject({
-        id: requireString(deployment.id, "deployment.id"),
+        id: requireString(deployment.id ?? deployment.uid, "deployment.id or deployment.uid"),
         name: optionalString(deployment.name),
         url: optionalString(deployment.url),
         state: optionalString(deployment.state),
@@ -896,3 +979,630 @@ function rejectSensitiveDevelopmentConflict(input) {
         throw new ProviderRequestError(400, "sensitive env does not support development target");
     }
 }
+async function vercelCreateGitDeployment(input, context) {
+    validateDeploymentGitSource(input);
+    const gitProvider = requireString(input.gitProvider, "gitProvider");
+    const payload = await requestVercelJson({
+        path: "/v13/deployments",
+        apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
+        fetcher: context.fetcher,
+        mode: "execute",
+        method: "POST",
+        query: deploymentSubmissionQuery(input),
+        body: compactObject({
+            ...deploymentSubmissionBody(input),
+            gitSource: buildVercelGitSource(gitProvider, input),
+            gitAccessToken: optionalString(input.gitAccessToken),
+            gitMetadata: optionalRecord(input.gitMetadata),
+        }),
+    });
+    return { deployment: mapDeployment(payload) };
+}
+async function vercelRedeployDeployment(input, context) {
+    const payload = await requestVercelJson({
+        path: "/v13/deployments",
+        apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
+        fetcher: context.fetcher,
+        mode: "execute",
+        method: "POST",
+        query: deploymentSubmissionQuery(input),
+        body: compactObject({
+            ...deploymentSubmissionBody(input),
+            deploymentId: optionalString(input.deploymentId),
+            withLatestCommit: optionalBoolean(input.withLatestCommit),
+        }),
+    });
+    return { deployment: mapDeployment(payload) };
+}
+async function vercelUploadDeploymentFileFromUrl(input, context) {
+    return runProviderRequest({ label: "Vercel file upload", signal: context.signal, timeoutMs: 300_000 }, async (signal) => {
+        validateOptionalUploadDigest(input);
+        const fileUrl = requireString(input.fileUrl, "fileUrl");
+        const suppliedSha = optionalString(input.sha);
+        const suppliedSize = optionalNumber(input.size);
+        const hasSuppliedMetadata = suppliedSha !== undefined && suppliedSize !== undefined;
+        if (suppliedSize !== undefined && suppliedSize > vercelConnectorMaxDeploymentFileBytes) {
+            throw new ProviderRequestError(413, `size exceeds the Connector deployment upload safety limit of ${vercelConnectorMaxDeploymentFileBytes} bytes`, undefined, "invalid_input");
+        }
+        const staged = hasSuppliedMetadata
+            ? undefined
+            : await stageRemoteDeploymentFile(fileUrl, context.fetcher, signal);
+        const metadata = staged
+            ? { sha: staged.sha, size: staged.size }
+            : { sha: requireSha1(suppliedSha ?? ""), size: suppliedSize ?? 0 };
+        const sourceResponse = staged ? undefined : await context.fetcher(fileUrl, { signal });
+        if (sourceResponse && (!sourceResponse.ok || !sourceResponse.body)) {
+            await sourceResponse.body?.cancel().catch(() => undefined);
+            throw new ProviderRequestError(502, `Vercel upload source download failed with HTTP ${sourceResponse.status}`, undefined, "provider_error");
+        }
+        const declaredSourceLength = sourceResponse?.headers.get("content-length");
+        const declaredSourceBytes = declaredSourceLength === undefined || declaredSourceLength === null ? undefined : Number(declaredSourceLength);
+        if (sourceResponse?.body &&
+            declaredSourceBytes !== undefined &&
+            Number.isFinite(declaredSourceBytes) &&
+            declaredSourceBytes !== metadata.size) {
+            await sourceResponse.body.cancel().catch(() => undefined);
+            throw new ProviderRequestError(400, `fileUrl content-length ${declaredSourceBytes} does not match size ${metadata.size}`, undefined, "invalid_input");
+        }
+        const stagedReadStream = staged ? createReadStream(staged.filePath) : undefined;
+        const rawBody = stagedReadStream
+            ? Readable.toWeb(stagedReadStream)
+            : sourceResponse?.body
+                ? createSizeCheckedUploadBody(sourceResponse.body, metadata.size)
+                : undefined;
+        try {
+            await requestVercelJson({
+                path: "/v2/files",
+                apiKey: context.apiKey,
+                scope: resolveTeamScope(input, context),
+                fetcher: context.fetcher,
+                signal,
+                mode: "execute",
+                method: "POST",
+                rawBody,
+                headers: {
+                    "content-length": String(metadata.size),
+                    "content-type": "application/octet-stream",
+                    "x-vercel-digest": metadata.sha,
+                },
+                responseBody: "none",
+            });
+            return metadata;
+        }
+        finally {
+            stagedReadStream?.destroy();
+            await sourceResponse?.body?.cancel().catch(() => undefined);
+            await staged?.cleanup();
+        }
+    });
+}
+async function vercelCreateFileDeployment(input, context) {
+    const payload = await requestVercelJson({
+        path: "/v13/deployments",
+        apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
+        fetcher: context.fetcher,
+        mode: "execute",
+        method: "POST",
+        query: deploymentSubmissionQuery(input),
+        body: compactObject({
+            ...deploymentSubmissionBody(input),
+            files: normalizeDeploymentFileReferences(input.files),
+        }),
+    });
+    return { deployment: mapDeployment(payload) };
+}
+async function vercelListDeploymentFiles(input, context) {
+    const deploymentId = requireString(input.deploymentId, "deploymentId");
+    const payload = await requestVercelJson({
+        path: `/v6/deployments/${encodeURIComponent(deploymentId)}/files`,
+        apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
+        fetcher: context.fetcher,
+        mode: "execute",
+        notFoundAsInvalidInput: true,
+    });
+    return {
+        files: normalizeArrayPayload(payload, "files").map((file) => mapDeploymentFile(file)),
+    };
+}
+async function vercelGetDeploymentFileContents(input, context) {
+    const deploymentId = requireString(input.deploymentId, "deploymentId");
+    const fileId = requireString(input.fileId, "fileId");
+    const response = await requestVercelResponse({
+        path: `/v8/deployments/${encodeURIComponent(deploymentId)}/files/${encodeURIComponent(fileId)}`,
+        apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
+        fetcher: context.fetcher,
+        mode: "execute",
+        query: compactObject({ path: optionalString(input.path) }),
+        notFoundAsInvalidInput: true,
+    });
+    return { contentBase64: await readDeploymentFileBase64(response) };
+}
+async function vercelListDeploymentAliases(input, context) {
+    const deploymentId = requireString(input.deploymentId, "deploymentId");
+    const payload = await requestVercelJson({
+        path: `/v2/deployments/${encodeURIComponent(deploymentId)}/aliases`,
+        apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
+        fetcher: context.fetcher,
+        mode: "execute",
+        notFoundAsInvalidInput: true,
+    });
+    return {
+        aliases: looseArray(payload.aliases).map((alias) => mapDeploymentAlias(alias)),
+    };
+}
+async function vercelAssignDeploymentAlias(input, context) {
+    const deploymentId = requireString(input.deploymentId, "deploymentId");
+    const payload = await requestVercelJson({
+        path: `/v2/deployments/${encodeURIComponent(deploymentId)}/aliases`,
+        apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
+        fetcher: context.fetcher,
+        mode: "execute",
+        method: "POST",
+        body: compactObject({
+            alias: optionalString(input.alias),
+            redirect: input.redirect === null ? null : optionalString(input.redirect),
+        }),
+        notFoundAsInvalidInput: true,
+    });
+    return { alias: mapDeploymentAlias(payload) };
+}
+async function vercelUpdateDeploymentIntegrationAction(input, context) {
+    validateIntegrationStatusUrl(input);
+    const deploymentId = requireString(input.deploymentId, "deploymentId");
+    const integrationConfigurationId = requireString(input.integrationConfigurationId, "integrationConfigurationId");
+    const resourceId = requireString(input.resourceId, "resourceId");
+    const action = requireString(input.action, "action");
+    await requestVercelJson({
+        path: `/v1/deployments/${encodeURIComponent(deploymentId)}/integrations/${encodeURIComponent(integrationConfigurationId)}/resources/${encodeURIComponent(resourceId)}/actions/${encodeURIComponent(action)}`,
+        apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
+        fetcher: context.fetcher,
+        mode: "execute",
+        method: "PATCH",
+        body: compactObject({
+            status: optionalString(input.status),
+            statusText: optionalString(input.statusText),
+            statusUrl: optionalString(input.statusUrl),
+            outcomes: Array.isArray(input.outcomes) ? input.outcomes : undefined,
+        }),
+        responseBody: "none",
+        notFoundAsInvalidInput: true,
+        includeTeamScope: false,
+    });
+    return { success: true, deploymentId, action };
+}
+function deploymentSubmissionBody(input) {
+    return compactObject({
+        name: optionalString(input.name),
+        project: optionalString(input.project),
+        target: optionalString(input.target),
+        customEnvironmentSlugOrId: optionalString(input.customEnvironmentSlugOrId),
+        buildMachine: optionalString(input.buildMachine),
+        monorepoManager: optionalString(input.monorepoManager),
+        meta: optionalRecord(input.meta),
+        projectSettings: optionalRecord(input.projectSettings),
+    });
+}
+function buildVercelGitSource(gitProvider, input) {
+    const repositoryId = optionalString(input.repositoryId);
+    const repositoryOwner = optionalString(input.repositoryOwner);
+    const repositoryName = optionalString(input.repositoryName);
+    const common = compactObject({
+        type: gitProvider,
+        ref: optionalString(input.ref),
+        sha: optionalString(input.sha),
+    });
+    if (gitProvider === "gitlab") {
+        return { ...common, projectId: repositoryId };
+    }
+    if (gitProvider === "bitbucket") {
+        return repositoryId
+            ? compactObject({
+                ...common,
+                repoUuid: repositoryId,
+                workspaceUuid: optionalString(input.workspaceUuid),
+            })
+            : { ...common, owner: repositoryOwner, slug: repositoryName };
+    }
+    if (gitProvider === "github" || gitProvider === "github-limited") {
+        return repositoryId
+            ? { ...common, repoId: repositoryId }
+            : { ...common, org: repositoryOwner, repo: repositoryName };
+    }
+    return compactObject({
+        ...common,
+        repoId: repositoryId,
+        owner: gitProvider === "cursor-origin" ? repositoryOwner : undefined,
+        repo: gitProvider === "cursor-origin" ? repositoryName : undefined,
+    });
+}
+async function vercelCancelDeployment(input, context) {
+    const deploymentId = requireString(input.deploymentId, "deploymentId");
+    const payload = await requestVercelJson({
+        path: `/v12/deployments/${encodeURIComponent(deploymentId)}/cancel`,
+        apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
+        fetcher: context.fetcher,
+        mode: "execute",
+        method: "PATCH",
+        notFoundAsInvalidInput: true,
+    });
+    return { deployment: mapDeployment(payload) };
+}
+async function vercelDeleteDeployment(input, context) {
+    validateDeploymentDeletionTarget(input);
+    const deploymentId = optionalString(input.deploymentId);
+    const deploymentUrl = optionalString(input.url);
+    const expectedDeploymentId = optionalString(input.expectedDeploymentId);
+    if ((deploymentId === undefined) === (deploymentUrl === undefined)) {
+        throw new ProviderRequestError(400, "Configure exactly one of deploymentId or url", undefined, "invalid_input");
+    }
+    let stableDeploymentId = deploymentId;
+    if (deploymentUrl) {
+        if (!expectedDeploymentId) {
+            throw new ProviderRequestError(400, "url deletion requires expectedDeploymentId", undefined, "invalid_input");
+        }
+        const resolved = await requestVercelJson({
+            path: `/v13/deployments/${encodeURIComponent(deploymentUrl)}`,
+            apiKey: context.apiKey,
+            scope: resolveTeamScope(input, context),
+            fetcher: context.fetcher,
+            mode: "execute",
+            notFoundAsInvalidInput: true,
+        });
+        const resolvedDeploymentId = requireString(resolved.id ?? resolved.uid, "resolved deployment.id or deployment.uid");
+        if (resolvedDeploymentId !== expectedDeploymentId) {
+            throw new ProviderRequestError(409, `url resolved to ${resolvedDeploymentId}, expected ${expectedDeploymentId}`, undefined, "invalid_input");
+        }
+        stableDeploymentId = resolvedDeploymentId;
+    }
+    const payload = await requestVercelJson({
+        path: `/v13/deployments/${encodeURIComponent(stableDeploymentId ?? "")}`,
+        apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
+        fetcher: context.fetcher,
+        mode: "execute",
+        method: "DELETE",
+        notFoundAsInvalidInput: true,
+    });
+    return {
+        deploymentId: requireString(payload.uid, "deployment.uid"),
+        state: requireString(payload.state, "deployment.state"),
+    };
+}
+async function vercelPromoteDeployment(input, context) {
+    const projectId = requireString(input.projectId, "projectId");
+    const deploymentId = requireString(input.deploymentId, "deploymentId");
+    const response = await requestVercelResponse({
+        path: `/v10/projects/${encodeURIComponent(projectId)}/promote/${encodeURIComponent(deploymentId)}`,
+        apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
+        fetcher: context.fetcher,
+        mode: "execute",
+        method: "POST",
+        notFoundAsInvalidInput: true,
+    });
+    return { accepted: true, statusCode: response.status, projectId, deploymentId };
+}
+async function vercelRollbackDeployment(input, context) {
+    const projectId = requireString(input.projectId, "projectId");
+    const deploymentId = requireString(input.deploymentId, "deploymentId");
+    await requestVercelJson({
+        path: `/v1/projects/${encodeURIComponent(projectId)}/rollback/${encodeURIComponent(deploymentId)}`,
+        apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
+        fetcher: context.fetcher,
+        mode: "execute",
+        method: "POST",
+        query: compactObject({
+            description: optionalString(input.description),
+        }),
+        responseBody: "none",
+        notFoundAsInvalidInput: true,
+    });
+    return { success: true, projectId, deploymentId };
+}
+async function vercelGetLatestDeploymentPromotionAliases(input, context) {
+    const projectId = requireString(input.projectId, "projectId");
+    const payload = await requestVercelJson({
+        path: `/v1/projects/${encodeURIComponent(projectId)}/promote/aliases`,
+        apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
+        fetcher: context.fetcher,
+        mode: "execute",
+        query: compactObject({
+            limit: toQueryString(optionalNumber(input.limit)),
+            since: toQueryString(optionalNumber(input.since)),
+            until: toQueryString(optionalNumber(input.until)),
+            failedOnly: toQueryBoolean(optionalBoolean(input.failedOnly)),
+        }),
+        notFoundAsInvalidInput: true,
+    });
+    return compactObject({
+        aliases: looseArray(payload.aliases).map((alias) => mapPromotionAlias(alias)),
+        pagination: optionalRecord(payload.pagination),
+    });
+}
+async function vercelUpdateDeploymentRollbackDescription(input, context) {
+    const projectId = requireString(input.projectId, "projectId");
+    const deploymentId = requireString(input.deploymentId, "deploymentId");
+    await requestVercelJson({
+        path: `/v1/projects/${encodeURIComponent(projectId)}/rollback/${encodeURIComponent(deploymentId)}/update-description`,
+        apiKey: context.apiKey,
+        scope: resolveTeamScope(input, context),
+        fetcher: context.fetcher,
+        mode: "execute",
+        method: "PATCH",
+        body: { description: optionalString(input.description) },
+        responseBody: "none",
+        includeTeamScope: false,
+    });
+    return { success: true, projectId, deploymentId };
+}
+function deploymentSubmissionQuery(input) {
+    return compactObject({
+        forceNew: toQueryFlag(optionalBoolean(input.forceNew)),
+        skipAutoDetectionConfirmation: toQueryFlag(optionalBoolean(input.skipAutoDetectionConfirmation)),
+    });
+}
+function mapDeploymentFile(value) {
+    const file = requiredResponseRecord(value, "deployment file");
+    return compactObject({
+        name: requireString(file.name, "deployment file.name"),
+        type: requireString(file.type, "deployment file.type"),
+        mode: requireNumber(file.mode, "deployment file.mode"),
+        uid: optionalString(file.uid),
+        contentType: optionalString(file.contentType),
+        children: Array.isArray(file.children) ? file.children.map((child) => mapDeploymentFile(child)) : undefined,
+    });
+}
+function mapDeploymentAlias(value) {
+    const alias = requiredResponseRecord(value, "deployment alias");
+    return compactObject({
+        uid: requireString(alias.uid, "deployment alias.uid"),
+        alias: requireString(alias.alias, "deployment alias.alias"),
+        created: requireString(alias.created, "deployment alias.created"),
+        redirect: alias.redirect === null ? null : optionalString(alias.redirect),
+        oldDeploymentId: alias.oldDeploymentId === null ? null : optionalString(alias.oldDeploymentId),
+        protectionBypass: optionalRecord(alias.protectionBypass),
+    });
+}
+function mapPromotionAlias(value) {
+    const alias = requiredResponseRecord(value, "promotion alias");
+    return {
+        id: requireString(alias.id, "promotion alias.id"),
+        alias: requireString(alias.alias, "promotion alias.alias"),
+        status: requireString(alias.status, "promotion alias.status"),
+    };
+}
+function normalizeDeploymentFileReferences(value) {
+    return looseArray(value).map((item, index) => {
+        const file = requiredResponseRecord(item, `files[${index}]`);
+        return {
+            file: requireString(file.path, `files[${index}].path`),
+            sha: requireSha1(requireString(file.sha, `files[${index}].sha`)),
+            size: requireNumber(file.size, `files[${index}].size`),
+        };
+    });
+}
+async function stageRemoteDeploymentFile(fileUrl, fetcher, signal) {
+    const response = await fetcher(fileUrl, { signal });
+    if (!response.ok || !response.body) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new ProviderRequestError(502, `Vercel upload source download failed with HTTP ${response.status}`, undefined, "provider_error");
+    }
+    const declaredSize = Number(response.headers.get("content-length"));
+    if (Number.isFinite(declaredSize) && declaredSize > vercelConnectorMaxDeploymentFileBytes) {
+        await response.body.cancel().catch(() => undefined);
+        throw new ProviderRequestError(413, `fileUrl exceeds the Connector deployment upload safety limit of ${vercelConnectorMaxDeploymentFileBytes} bytes`, undefined, "invalid_input");
+    }
+    const directory = await mkdtemp(join(tmpdir(), "oomol-connector-vercel-"));
+    const filePath = join(directory, "deployment-file");
+    const hasher = createHash("sha1");
+    let size = 0;
+    let completed = false;
+    const chunks = async function* () {
+        for await (const chunk of response.body) {
+            size += chunk.byteLength;
+            if (size > vercelConnectorMaxDeploymentFileBytes) {
+                throw new ProviderRequestError(413, `fileUrl exceeds the Connector deployment upload safety limit of ${vercelConnectorMaxDeploymentFileBytes} bytes`, undefined, "invalid_input");
+            }
+            hasher.update(chunk);
+            yield chunk;
+        }
+        completed = true;
+    };
+    try {
+        const destination = createWriteStream(filePath, { flags: "wx" });
+        const closed = new Promise((resolve) => destination.once("close", resolve));
+        try {
+            await pipeline(Readable.from(chunks()), destination, { signal });
+        }
+        finally {
+            if (!destination.destroyed)
+                destination.destroy();
+            await closed;
+        }
+        return {
+            filePath,
+            sha: hasher.digest("hex"),
+            size,
+            cleanup: () => rm(directory, { recursive: true, force: true }),
+        };
+    }
+    catch (error) {
+        await rm(directory, { recursive: true, force: true });
+        throw error;
+    }
+    finally {
+        if (!completed) {
+            await response.body.cancel().catch(() => undefined);
+        }
+    }
+}
+function createSizeCheckedUploadBody(body, expectedBytes) {
+    let receivedBytes = 0;
+    const chunks = async function* () {
+        for await (const chunk of body) {
+            receivedBytes += chunk.byteLength;
+            if (receivedBytes > expectedBytes) {
+                throw new ProviderRequestError(400, `fileUrl returned more than the declared size of ${expectedBytes} bytes`, undefined, "invalid_input");
+            }
+            yield chunk;
+        }
+        if (receivedBytes !== expectedBytes) {
+            throw new ProviderRequestError(400, `fileUrl returned ${receivedBytes} bytes, expected ${expectedBytes}`, undefined, "invalid_input");
+        }
+    };
+    return Readable.toWeb(Readable.from(chunks()));
+}
+function requireSha1(value) {
+    const normalized = value.toLowerCase();
+    if (normalized.length !== 40) {
+        throw new ProviderRequestError(400, "sha must be a 40-character SHA-1 digest", undefined, "invalid_input");
+    }
+    for (const character of normalized) {
+        const code = character.charCodeAt(0);
+        const isDigit = code >= 48 && code <= 57;
+        const isLowerHex = code >= 97 && code <= 102;
+        if (!isDigit && !isLowerHex) {
+            throw new ProviderRequestError(400, "sha must be a 40-character SHA-1 digest", undefined, "invalid_input");
+        }
+    }
+    return normalized;
+}
+async function readDeploymentFileBase64(response) {
+    const text = await readDeploymentFileResponseText(response);
+    if (!text) {
+        throw new ProviderRequestError(502, "Vercel deployment file response is empty", undefined, "provider_error");
+    }
+    try {
+        const payload = JSON.parse(text);
+        if (typeof payload === "string") {
+            return payload;
+        }
+        const object = optionalRecord(payload);
+        const content = optionalString(object?.content) ?? optionalString(object?.data);
+        if (content !== undefined) {
+            return content;
+        }
+    }
+    catch {
+        return text;
+    }
+    throw new ProviderRequestError(502, "Vercel deployment file response is missing base64 content", undefined, "provider_error");
+}
+async function readDeploymentFileResponseText(response) {
+    const declaredBytes = Number(response.headers.get("content-length"));
+    if (Number.isFinite(declaredBytes) && declaredBytes > vercelMaxDeploymentFileContentResponseBytes) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new ProviderRequestError(413, `Vercel deployment file response exceeds ${vercelMaxDeploymentFileContentResponseBytes} bytes`, undefined, "invalid_input");
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+        return "";
+    }
+    const decoder = new TextDecoder();
+    let text = "";
+    let receivedBytes = 0;
+    while (true) {
+        const next = await reader.read();
+        if (next.done) {
+            break;
+        }
+        receivedBytes += next.value.byteLength;
+        if (receivedBytes > vercelMaxDeploymentFileContentResponseBytes) {
+            await reader.cancel().catch(() => undefined);
+            throw new ProviderRequestError(413, `Vercel deployment file response exceeds ${vercelMaxDeploymentFileContentResponseBytes} bytes`, undefined, "invalid_input");
+        }
+        text += decoder.decode(next.value, { stream: true });
+    }
+    return text + decoder.decode();
+}
+function toQueryString(value) {
+    return value === undefined ? undefined : String(value);
+}
+function toQueryFlag(value) {
+    return value === undefined ? undefined : value ? "1" : "0";
+}
+function toQueryBoolean(value) {
+    return value === undefined ? undefined : String(value);
+}
+function toCommaSeparatedString(value) {
+    const items = normalizeStringArray(value);
+    return items && items.length > 0 ? items.join(",") : undefined;
+}
+const vercelConnectorMaxDeploymentFileBytes = 1024 * 1024 * 1024;
+const vercelMaxDeploymentFileContentResponseBytes = 16 * 1024 * 1024;
+async function requestVercelResponse(options) {
+    const response = await requestVercel(options);
+    if (!response.ok)
+        throw await mapVercelError(response, options.mode, options.notFoundAsInvalidInput ?? false);
+    return response;
+}
+function rejectConflictingDeploymentProjectFilters(value) {
+    if (value.projectId && value.projectIds) {
+        throw providerInputError("projectId and projectIds cannot be used together");
+    }
+}
+function validateDeploymentGitSource(value) {
+    const hasRepositoryId = Boolean(value.repositoryId);
+    const hasRepositoryName = Boolean(value.repositoryOwner && value.repositoryName);
+    if (value.gitProvider === "vercel") {
+        if (!hasRepositoryId || !value.sha) {
+            throw providerInputError("vercel git source requires repositoryId and sha");
+        }
+        return;
+    }
+    if (!value.ref) {
+        throw providerInputError(`${value.gitProvider ?? "git"} source requires ref`);
+    }
+    if (value.gitProvider === "github" || value.gitProvider === "github-limited") {
+        if (hasRepositoryId === hasRepositoryName) {
+            throw providerInputError("github source requires exactly one of repositoryId or repositoryOwner + repositoryName");
+        }
+        return;
+    }
+    if (value.gitProvider === "bitbucket") {
+        if (hasRepositoryId === hasRepositoryName) {
+            throw providerInputError("bitbucket source requires exactly one of repositoryId or repositoryOwner + repositoryName");
+        }
+        return;
+    }
+    if (!hasRepositoryId) {
+        throw providerInputError(`${value.gitProvider ?? "git"} source requires repositoryId`);
+    }
+}
+function validateOptionalUploadDigest(value) {
+    if (Boolean(value.sha) !== (value.size !== undefined)) {
+        throw providerInputError("sha and size must be supplied together or both omitted");
+    }
+}
+function validateIntegrationStatusUrl(value) {
+    if (!value.statusUrl || value.statusUrl.startsWith("sso:")) {
+        return;
+    }
+    try {
+        const url = new URL(value.statusUrl);
+        if (url.protocol === "http:" || url.protocol === "https:") {
+            return;
+        }
+    }
+    catch { }
+    throw providerInputError("statusUrl must use HTTP, HTTPS, or SSO");
+}
+function validateDeploymentDeletionTarget(value) {
+    if (value.url && !value.expectedDeploymentId) {
+        throw providerInputError("url deletion requires expectedDeploymentId");
+    }
+    if (value.deploymentId && value.expectedDeploymentId) {
+        throw providerInputError("expectedDeploymentId is only valid with url");
+    }
+}