@vercel/connect 0.0.5-alpha.1 → 0.1.1

package/dist/ash/connection-authorization.d.ts

@@ -28,13 +28,13 @@
  * `@vercel/connect/ash` requires Ash to be installed in the consumer
  * project, but the rest of `@vercel/connect` works without it.
  */
-import { type InteractiveAuthorizationDefinition, type JsonValue, type NonInteractiveAuthorizationDefinition } from "experimental-ash/connections";
-import type { ConnectOptions, ConnectTokenParams } from "../token.js";
+import { type InteractiveAuthorizationDefinition, type JsonValue, type NonInteractiveAuthorizationDefinition } from 'experimental-ash/connections';
+import type { ConnectOptions, ConnectTokenParams } from '../token.js';
 /**
  * Authorization phase passed to {@link AshAuthorizationOptions.onError}
  * so consumers can branch their error translation per callback.
  */
-export type ConnectAuthorizationPhase = "getToken" | "startAuthorization" | "completeAuthorization";
+export type ConnectAuthorizationPhase = 'getToken' | 'startAuthorization' | 'completeAuthorization';
 /**
  * State journaled by Ash between
  * {@link InteractiveAuthorizationDefinition.startAuthorization} and
@@ -72,7 +72,7 @@ export interface AshAuthorizationOptions {
      *   failure so the channel can prompt an operator to install the
      *   Vercel Connect app.
      */
-    readonly principalType?: "app" | "user";
+    readonly principalType?: 'app' | 'user';
     /**
      * Extra parameters forwarded to every `getTokenResponse` /
      * `startAuthorization` call, minus `subject` — the helper derives
@@ -81,7 +81,7 @@ export interface AshAuthorizationOptions {
      * Use this to pin `scopes`, `audience`, `resources`, or
      * `authorizationDetails`. Passed through verbatim.
      */
-    readonly tokenParams?: Omit<ConnectTokenParams, "subject">;
+    readonly tokenParams?: Omit<ConnectTokenParams, 'subject'>;
     /**
      * Low-level Vercel Connect SDK options (currently `vercelToken`
      * for overriding the OIDC bearer). Most callers leave this unset
@@ -158,9 +158,9 @@ export type AshConnectAuthorizationDefinition<TAuthorization extends Interactive
  */
 export declare function connect(connector: string): AshConnectAuthorizationDefinition<InteractiveAuthorizationDefinition<ConnectAuthorizationState>>;
 export declare function connect(options: AshAuthorizationOptions & {
-    readonly principalType?: "user";
+    readonly principalType?: 'user';
 }): AshConnectAuthorizationDefinition<InteractiveAuthorizationDefinition<ConnectAuthorizationState>>;
 export declare function connect(options: AshAuthorizationOptions & {
-    readonly principalType: "app";
+    readonly principalType: 'app';
 }): AshConnectAuthorizationDefinition<NonInteractiveAuthorizationDefinition>;
 export declare function connect(options: AshAuthorizationInput): AshConnectAuthorizationDefinition<InteractiveAuthorizationDefinition<ConnectAuthorizationState> | NonInteractiveAuthorizationDefinition>;

package/dist/ash/connection-authorization.js

@@ -28,33 +28,33 @@
  * `@vercel/connect/ash` requires Ash to be installed in the consumer
  * project, but the rest of `@vercel/connect` works without it.
  */
-import { ConnectionAuthorizationFailedError, ConnectionAuthorizationRequiredError, } from "experimental-ash/connections";
-import { startAuthorization } from "../authorization.js";
-import { ConnectorInstallationRequiredError, getTokenResponse, NoValidTokenError, UserAuthorizationRequiredError, } from "../token.js";
+import { ConnectionAuthorizationFailedError, ConnectionAuthorizationRequiredError, } from 'experimental-ash/connections';
+import { startAuthorization } from '../authorization.js';
+import { ConnectorInstallationRequiredError, getTokenResponse, NoValidTokenError, UserAuthorizationRequiredError, } from '../token.js';
 export function connect(input) {
     const options = normalizeAuthorizationOptions(input);
     const vercelConnect = { connector: options.connector };
-    if (options.principalType === "app") {
+    if (options.principalType === 'app') {
         return { ...buildNonInteractiveDefinition(options), vercelConnect };
     }
     return { ...buildInteractiveDefinition(options), vercelConnect };
 }
 function normalizeAuthorizationOptions(input) {
-    if (typeof input === "string") {
+    if (typeof input === 'string') {
         return { connector: input };
     }
     return input;
 }
 function buildInteractiveDefinition(options) {
     return {
-        principalType: "user",
+        principalType: 'user',
         async getToken({ principal }) {
             try {
                 const response = await getTokenResponse(options.connector, buildTokenParams(options, principal), options.connectOptions);
                 return { token: response.token, expiresAt: response.expiresAt };
             }
             catch (error) {
-                throw translate(error, "getToken", options);
+                throw translate(error, 'getToken', options);
             }
         },
         async startAuthorization({ principal, callbackUrl, webhook, }) {
@@ -80,14 +80,27 @@ function buildInteractiveDefinition(options) {
                 // mints one URL, Vercel Connect redirects there" mental
                 // model. Revisit if tab-close timeouts become a real problem
                 // in production.
-                const response = await startAuthorization(options.connector, buildTokenParams(options, principal), { ...options.connectOptions, callbackUrl: callbackUrl ?? webhook });
+                const response = await startAuthorization(options.connector, buildTokenParams(options, principal), {
+                    ...options.connectOptions,
+                    callbackUrl: callbackUrl ?? webhook,
+                    deviceCode: true,
+                });
                 return {
-                    challenge: buildChallenge(options, response.url),
+                    challenge: {
+                        url: response.url,
+                        ...(response.deviceCode ? { userCode: response.deviceCode } : null),
+                        ...(response.expiresAt
+                            ? { expiresAt: new Date(response.expiresAt).toISOString() }
+                            : null),
+                        ...(options.instructions
+                            ? { instructions: options.instructions }
+                            : null),
+                    },
                     state: { verifier: response.verifier },
                 };
             }
             catch (error) {
-                throw translate(error, "startAuthorization", options);
+                throw translate(error, 'startAuthorization', options);
             }
         },
         async completeAuthorization({ principal, }) {
@@ -96,21 +109,21 @@ function buildInteractiveDefinition(options) {
                 return { token: response.token, expiresAt: response.expiresAt };
             }
             catch (error) {
-                throw translate(error, "completeAuthorization", options);
+                throw translate(error, 'completeAuthorization', options);
             }
         },
     };
 }
 function buildNonInteractiveDefinition(options) {
     return {
-        principalType: "app",
+        principalType: 'app',
         async getToken({ principal }) {
             try {
                 const response = await getTokenResponse(options.connector, buildTokenParams(options, principal), options.connectOptions);
                 return { token: response.token, expiresAt: response.expiresAt };
             }
             catch (error) {
-                throw translate(error, "getToken", options);
+                throw translate(error, 'getToken', options);
             }
         },
     };
@@ -122,16 +135,10 @@ function buildTokenParams(options, principal) {
     };
 }
 function principalToSubject(principal) {
-    if (principal.type === "app") {
-        return { type: "app" };
+    if (principal.type === 'app') {
+        return { type: 'app' };
     }
-    return { type: "user", id: principal.id, issuer: principal.issuer };
-}
-function buildChallenge(options, url) {
-    if (options.instructions === undefined) {
-        return { url };
-    }
-    return { url, instructions: options.instructions };
+    return { type: 'user', id: principal.id, issuer: principal.issuer };
 }
 /**
  * Translates raw Vercel Connect errors into Ash's public
@@ -154,24 +161,24 @@ function translate(error, phase, options) {
     // `retryable: false`.
     if (error instanceof UserAuthorizationRequiredError ||
         error instanceof NoValidTokenError) {
-        if (options.principalType === "app") {
-            return new ConnectionAuthorizationFailedError("connect", {
+        if (options.principalType === 'app') {
+            return new ConnectionAuthorizationFailedError('connect', {
                 message: error.message,
-                reason: "app_not_installed",
+                reason: 'app_not_installed',
                 retryable: false,
             });
         }
-        if (phase === "completeAuthorization") {
+        if (phase === 'completeAuthorization') {
             // The consent leg reported success (Ash would not call us
             // otherwise) but Vercel Connect still says the user is
             // unauthorized. Default to retryable so the model can
             // re-prompt; most cases (network blip, replay) resolve on
             // retry.
-            return new ConnectionAuthorizationFailedError("connect", {
-                message: "Authorization did not complete. Vercel Connect still reports the user as unauthorized.",
+            return new ConnectionAuthorizationFailedError('connect', {
+                message: 'Authorization did not complete. Vercel Connect still reports the user as unauthorized.',
             });
         }
-        return new ConnectionAuthorizationRequiredError("connect", {
+        return new ConnectionAuthorizationRequiredError('connect', {
             message: error.message,
         });
     }
@@ -179,9 +186,9 @@ function translate(error, phase, options) {
     // the operator has not installed the Vercel Connect connector for
     // this team.
     if (error instanceof ConnectorInstallationRequiredError) {
-        return new ConnectionAuthorizationFailedError("connect", {
+        return new ConnectionAuthorizationFailedError('connect', {
             message: error.message,
-            reason: "connector_installation_required",
+            reason: 'connector_installation_required',
             retryable: false,
         });
     }

package/dist/ash/index.d.ts

@@ -6,6 +6,6 @@
  * this barrel re-exports the public API so consumers import
  * everything from `@vercel/connect/ash`.
  */
-export { connect, type AshAuthorizationInput, type AshAuthorizationOptions, type AshConnectAuthorizationDefinition, type ConnectAuthorizationPhase, type ConnectAuthorizationState, type VercelConnectMetadata, } from "./connection-authorization.js";
-export { CONNECT_OAUTH_ISSUER, connectOAuth, type ConnectOAuthAudienceEnvironment, type ConnectOAuthEnvironment, type ConnectOAuthOptions, } from "./connect-oauth.js";
-export { connectSlackCredentials } from "./slack-credentials.js";
+export { connect, type AshAuthorizationInput, type AshAuthorizationOptions, type AshConnectAuthorizationDefinition, type ConnectAuthorizationPhase, type ConnectAuthorizationState, type VercelConnectMetadata, } from './connection-authorization.js';
+export { CONNECT_OAUTH_ISSUER, connectOAuth, type ConnectOAuthAudienceEnvironment, type ConnectOAuthEnvironment, type ConnectOAuthOptions, } from './connect-oauth.js';
+export { connectSlackCredentials } from './slack-credentials.js';

package/dist/ash/index.js

@@ -6,6 +6,6 @@
  * this barrel re-exports the public API so consumers import
  * everything from `@vercel/connect/ash`.
  */
-export { connect, } from "./connection-authorization.js";
-export { CONNECT_OAUTH_ISSUER, connectOAuth, } from "./connect-oauth.js";
-export { connectSlackCredentials } from "./slack-credentials.js";
+export { connect, } from './connection-authorization.js';
+export { CONNECT_OAUTH_ISSUER, connectOAuth, } from './connect-oauth.js';
+export { connectSlackCredentials } from './slack-credentials.js';

package/dist/ash/slack-credentials.d.ts

@@ -1,4 +1,4 @@
-import type { SlackChannelCredentials } from "experimental-ash/channels/slack";
+import type { SlackChannelCredentials } from 'experimental-ash/channels/slack';
 /**
  * Build {@link SlackChannelCredentials} backed by a Vercel Connect
  * connector that stores a Slack workspace's bot token.

package/dist/ash/slack-credentials.js

@@ -1,5 +1,5 @@
-import { getToken } from "../index.js";
-import { vercelOidc } from "experimental-ash/channels/auth";
+import { getToken } from '../index.js';
+import { vercelOidc } from 'experimental-ash/channels/auth';
 /**
  * Build {@link SlackChannelCredentials} backed by a Vercel Connect
  * connector that stores a Slack workspace's bot token.
@@ -25,7 +25,7 @@ import { vercelOidc } from "experimental-ash/channels/auth";
  */
 export function connectSlackCredentials(connector) {
     return {
-        botToken: () => getToken(connector, { subject: { type: "app" } }),
+        botToken: () => getToken(connector, { subject: { type: 'app' } }),
         webhookVerifier: vercelOidc(),
     };
 }

package/dist/authjs/connect-provider.d.ts

@@ -1,4 +1,4 @@
-import type { OAuth2Config } from "@auth/core/providers";
+import type { OAuth2Config } from '@auth/core/providers';
 /** Userinfo payload returned by Vercel Connect's OIDC userinfo endpoint. */
 export interface ConnectProfile {
     sub: string;

package/dist/authjs/connect-provider.js

@@ -23,29 +23,29 @@
  * };
  * ```
  */
-import { customFetch } from "@auth/core";
-import { getVercelOidcToken } from "@vercel/oidc";
-import { tryGetVercelTeamId, withTeamId } from "../internal/team-id.js";
-const CONNECT_AUTHORIZATION_URL = "https://connect.vercel.com/oauth/authorize";
-const CONNECT_TOKEN_URL = "https://connect.vercel.com/oauth/token";
-const CONNECT_USERINFO_URL = "https://connect.vercel.com/oauth/userinfo";
+import { customFetch } from '@auth/core';
+import { getVercelOidcToken } from '@vercel/oidc';
+import { tryGetVercelTeamId, withTeamId } from '../internal/team-id.js';
+const CONNECT_AUTHORIZATION_URL = 'https://connect.vercel.com/oauth/authorize';
+const CONNECT_TOKEN_URL = 'https://connect.vercel.com/oauth/token';
+const CONNECT_USERINFO_URL = 'https://connect.vercel.com/oauth/userinfo';
 /**
  * Builds an Auth.js `OAuth2Config` for Vercel Connect. Push the
  * result into `AuthConfig.providers`.
  */
 export function connect(options) {
     const fetchVercelToken = options.getVercelOidcToken ?? getVercelOidcToken;
-    const scope = Array.from(new Set([...(options.scopes ?? ["openid"]), "offline_access"])).join(" ");
+    const scope = Array.from(new Set([...(options.scopes ?? ['openid']), 'offline_access'])).join(' ');
     return {
         id: options.id,
         name: options.name,
-        type: "oauth",
+        type: 'oauth',
         clientId: options.connector,
         // The token endpoint expects client_secret_basic, but the secret
         // is a Vercel OIDC token that has to be fetched per-request. We
         // rely on the customFetch hook below to inject the token endpoint
         // Authorization header.
-        client: { token_endpoint_auth_method: "none" },
+        client: { token_endpoint_auth_method: 'none' },
         authorization: {
             // Best-effort: scope the Vercel Connect consent UI to the
             // deployment's Vercel team when we can read it from the OIDC
@@ -56,7 +56,7 @@ export function connect(options) {
         },
         token: CONNECT_TOKEN_URL,
         userinfo: CONNECT_USERINFO_URL,
-        checks: ["pkce"],
+        checks: ['pkce'],
         profile(profile) {
             return {
                 id: profile.sub,
@@ -66,7 +66,7 @@ export function connect(options) {
             };
         },
         [customFetch]: async (input, init) => {
-            const url = typeof input === "string"
+            const url = typeof input === 'string'
                 ? input
                 : input instanceof URL
                     ? input.href
@@ -75,7 +75,7 @@ export function connect(options) {
                 const vercelToken = await fetchVercelToken();
                 const credentials = `${encodeURIComponent(options.connector)}:${encodeURIComponent(vercelToken)}`;
                 const headers = new Headers(init?.headers);
-                headers.set("authorization", `Basic ${btoa(credentials)}`);
+                headers.set('authorization', `Basic ${btoa(credentials)}`);
                 return fetch(input, { ...init, headers });
             }
             return fetch(input, init);

package/dist/authjs/index.d.ts

@@ -7,4 +7,4 @@
  * installed in the consumer project, but the rest of
  * `@vercel/connect` works without it.
  */
-export { connect, type AuthJsConnectOptions, type ConnectProfile, } from "./connect-provider.js";
+export { connect, type AuthJsConnectOptions, type ConnectProfile, } from './connect-provider.js';

package/dist/authjs/index.js

@@ -7,4 +7,4 @@
  * installed in the consumer project, but the rest of
  * `@vercel/connect` works without it.
  */
-export { connect, } from "./connect-provider.js";
+export { connect, } from './connect-provider.js';

package/dist/authorization.d.ts

@@ -1,12 +1,16 @@
-import type { ConnectTokenParams } from "./token.js";
+import type { ConnectTokenParams } from './token.js';
 export interface ConnectAuthorizationOptions {
     vercelToken?: string;
     callbackUrl?: string;
     webhook?: string;
+    deviceCode?: boolean;
+    expiresInMs?: number;
 }
 export interface ConnectAuthorizationResponse {
     request: string;
     verifier: string;
     url: string;
+    deviceCode?: string;
+    expiresAt?: number;
 }
 export declare function startAuthorization(connector: string, params: ConnectTokenParams, options?: ConnectAuthorizationOptions): Promise<ConnectAuthorizationResponse>;

package/dist/authorization.js

@@ -1,7 +1,7 @@
-import { getVercelOidcToken } from "@vercel/oidc";
+import { getVercelOidcToken } from '@vercel/oidc';
 export async function startAuthorization(connector, params, options) {
     if (!connector) {
-        throw new Error("connector is required");
+        throw new Error('connector is required');
     }
     if (options?.callbackUrl !== undefined) {
         validateCallbackUrl(options.callbackUrl);
@@ -17,12 +17,18 @@ export async function startAuthorization(connector, params, options) {
             returnUrl: options.callbackUrl,
         }),
         ...(options?.webhook !== undefined && { webhook: options.webhook }),
+        ...(options?.deviceCode !== undefined && {
+            deviceCode: options.deviceCode,
+        }),
+        ...(options?.expiresInMs !== undefined && {
+            expiresInMs: options.expiresInMs,
+        }),
     };
     const response = await fetch(endpoint, {
-        method: "POST",
+        method: 'POST',
         headers: {
-            Accept: "application/json",
-            "Content-Type": "application/json",
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
             Authorization: `Bearer ${vercelToken}`,
         },
         body: JSON.stringify(body),
@@ -33,10 +39,10 @@ export async function startAuthorization(connector, params, options) {
             errorText = await response.text();
         }
         catch { }
-        throw new Error(`Failed to start authorization: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`);
+        throw new Error(`Failed to start authorization: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ''}`);
     }
-    const { request, verifier, url } = await response.json();
-    return { request, verifier, url };
+    const data = await response.json();
+    return data;
 }
 function validateCallbackUrl(value) {
     let url;
@@ -46,10 +52,10 @@ function validateCallbackUrl(value) {
     catch {
         throw new Error(`Invalid callbackUrl: ${value}`);
     }
-    if (url.protocol === "https:")
+    if (url.protocol === 'https:')
         return;
-    if (url.protocol === "http:" &&
-        (url.hostname === "localhost" || url.hostname === "127.0.0.1")) {
+    if (url.protocol === 'http:' &&
+        (url.hostname === 'localhost' || url.hostname === '127.0.0.1')) {
         return;
     }
     throw new Error(`callbackUrl must be https:// or http://localhost, got: ${value}`);
@@ -62,7 +68,7 @@ function validateWebhookUrl(value) {
     catch {
         throw new Error(`Invalid webhook URL: ${value}`);
     }
-    if (url.protocol !== "https:") {
+    if (url.protocol !== 'https:') {
         throw new Error(`webhook must be https://, got: ${value}`);
     }
 }

package/dist/betterauth/connect-provider.d.ts

@@ -1,4 +1,4 @@
-import type { GenericOAuthConfig } from "better-auth/plugins/generic-oauth";
+import type { GenericOAuthConfig } from 'better-auth/plugins/generic-oauth';
 /** Options accepted by {@link connect}. */
 export interface BetterAuthConnectOptions {
     /**

package/dist/betterauth/connect-provider.js

@@ -27,19 +27,20 @@
  * });
  * ```
  */
-import { getVercelOidcToken } from "@vercel/oidc";
-import { getOAuth2Tokens } from "better-auth/oauth2";
-import { tryGetVercelTeamId, withTeamId } from "../internal/team-id.js";
-const CONNECT_AUTHORIZATION_URL = "https://connect.vercel.com/oauth/authorize";
-const CONNECT_TOKEN_URL = "https://connect.vercel.com/oauth/token";
-const CONNECT_USERINFO_URL = "https://connect.vercel.com/oauth/userinfo";
+import { getVercelOidcToken } from '@vercel/oidc';
+import { getOAuth2Tokens } from 'better-auth/oauth2';
+import { tryGetVercelTeamId, withTeamId } from '../internal/team-id.js';
+import { ConnectError, createConnectErrorFromResponse } from '../token.js';
+const CONNECT_AUTHORIZATION_URL = 'https://connect.vercel.com/oauth/authorize';
+const CONNECT_TOKEN_URL = 'https://connect.vercel.com/oauth/token';
+const CONNECT_USERINFO_URL = 'https://connect.vercel.com/oauth/userinfo';
 /**
  * Builds a `GenericOAuthConfig` entry for Vercel Connect. Pass the
  * result into `genericOAuth({ config: [...] })`.
  */
 export function connect(options) {
     const fetchVercelToken = options.getVercelOidcToken ?? getVercelOidcToken;
-    const scopes = Array.from(new Set([...(options.scopes ?? ["openid"]), "offline_access"]));
+    const scopes = Array.from(new Set([...(options.scopes ?? ['openid']), 'offline_access']));
     return {
         providerId: options.providerId,
         clientId: options.connector,
@@ -56,37 +57,39 @@ export function connect(options) {
             const credentials = `${encodeURIComponent(options.connector)}:${encodeURIComponent(vercelToken)}`;
             const basicAuth = btoa(credentials);
             const body = new URLSearchParams({
-                grant_type: "authorization_code",
+                grant_type: 'authorization_code',
                 code,
                 redirect_uri: redirectURI,
             });
             if (codeVerifier)
-                body.set("code_verifier", codeVerifier);
+                body.set('code_verifier', codeVerifier);
             if (deviceId)
-                body.set("device_id", deviceId);
+                body.set('device_id', deviceId);
             const response = await fetch(CONNECT_TOKEN_URL, {
-                method: "POST",
+                method: 'POST',
                 headers: {
-                    "Content-Type": "application/x-www-form-urlencoded",
-                    Accept: "application/json",
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Accept: 'application/json',
                     Authorization: `Basic ${basicAuth}`,
                 },
                 body: body.toString(),
             });
             if (!response.ok) {
-                throw new Error(`Failed to exchange Vercel Connect authorization code: ${response.status} ${response.statusText}: ${await response.text()}`);
+                throw await createConnectErrorFromResponse(response, 'Failed to exchange Vercel Connect authorization code');
             }
             return getOAuth2Tokens(await response.json());
         },
         getUserInfo: async (tokens) => {
             if (!tokens.accessToken) {
-                throw new Error("Missing access token for Vercel Connect userinfo request");
+                throw new ConnectError('Missing access token for Vercel Connect userinfo request', {
+                    code: 'missing_access_token',
+                });
             }
             const response = await fetch(CONNECT_USERINFO_URL, {
                 headers: { Authorization: `Bearer ${tokens.accessToken}` },
             });
             if (!response.ok) {
-                throw new Error(`Failed to fetch Vercel Connect user info: ${response.status} ${response.statusText}: ${await response.text()}`);
+                throw await createConnectErrorFromResponse(response, 'Failed to fetch Vercel Connect user info');
             }
             const user = (await response.json());
             return {

package/dist/betterauth/index.d.ts

@@ -7,4 +7,5 @@
  * in the consumer project, but the rest of `@vercel/connect` works
  * without it.
  */
-export { connect, type BetterAuthConnectOptions } from "./connect-provider.js";
+export { connect, type BetterAuthConnectOptions } from './connect-provider.js';
+export { ConnectError, type ConnectErrorOptions, type ConnectVendorErrorPayload, } from '../token.js';

package/dist/betterauth/index.js

@@ -7,4 +7,5 @@
  * in the consumer project, but the rest of `@vercel/connect` works
  * without it.
  */
-export { connect } from "./connect-provider.js";
+export { connect } from './connect-provider.js';
+export { ConnectError, } from '../token.js';

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { getToken, getTokenResponse, NoValidTokenError, UserAuthorizationRequiredError, ConnectorInstallationRequiredError, type ConnectOptions, type ConnectTokenParams, type ConnectTokenResponse, } from "./token.js";
-export { startAuthorization, type ConnectAuthorizationOptions, type ConnectAuthorizationResponse, } from "./authorization.js";
+export { getToken, getTokenResponse, ConnectError, NoValidTokenError, UserAuthorizationRequiredError, ConnectorInstallationRequiredError, type ConnectErrorOptions, type ConnectOptions, type ConnectTokenParams, type ConnectTokenResponse, type ConnectVendorErrorPayload, } from './token.js';
+export { startAuthorization, type ConnectAuthorizationOptions, type ConnectAuthorizationResponse, } from './authorization.js';

package/dist/index.js

@@ -1,2 +1,2 @@
-export { getToken, getTokenResponse, NoValidTokenError, UserAuthorizationRequiredError, ConnectorInstallationRequiredError, } from "./token.js";
-export { startAuthorization, } from "./authorization.js";
+export { getToken, getTokenResponse, ConnectError, NoValidTokenError, UserAuthorizationRequiredError, ConnectorInstallationRequiredError, } from './token.js';
+export { startAuthorization, } from './authorization.js';

package/dist/internal/team-id.js

@@ -13,7 +13,7 @@
  * be decoded. Adapters then fall back to an unqualified
  * authorization URL.
  */
-import { getVercelOidcTokenSync } from "@vercel/oidc";
+import { getVercelOidcTokenSync } from '@vercel/oidc';
 export function tryGetVercelTeamId() {
     let token;
     try {
@@ -26,13 +26,13 @@ export function tryGetVercelTeamId() {
 }
 export function extractTeamIdFromOidcToken(token) {
     try {
-        const parts = token.split(".");
+        const parts = token.split('.');
         if (parts.length < 2)
             return undefined;
-        const padded = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+        const padded = parts[1].replace(/-/g, '+').replace(/_/g, '/');
         const padLen = (4 - (padded.length % 4)) % 4;
-        const claims = JSON.parse(atob(padded + "=".repeat(padLen)));
-        return typeof claims.owner_id === "string" ? claims.owner_id : undefined;
+        const claims = JSON.parse(atob(padded + '='.repeat(padLen)));
+        return typeof claims.owner_id === 'string' ? claims.owner_id : undefined;
     }
     catch {
         return undefined;
@@ -42,6 +42,6 @@ export function withTeamId(baseUrl, teamId) {
     if (!teamId)
         return baseUrl;
     const url = new URL(baseUrl);
-    url.searchParams.set("teamId", teamId);
+    url.searchParams.set('teamId', teamId);
     return url.toString();
 }

package/dist/token.d.ts

@@ -1,8 +1,8 @@
 export interface ConnectTokenParams {
     subject: {
-        type: "app";
+        type: 'app';
     } | {
-        type: "user";
+        type: 'user';
         id: string;
         issuer?: string;
     };
@@ -39,17 +39,32 @@ export interface ConnectTokenResponse {
     /** Driver-specific metadata stored during OAuth */
     metadata?: Record<string, unknown>;
 }
-export declare class NoValidTokenError extends Error {
-    constructor(message: string);
+export type ConnectVendorErrorPayload = Record<string, unknown>;
+export interface ConnectErrorOptions {
+    code?: string;
+    status?: number;
+    statusText?: string;
+    vendor?: ConnectVendorErrorPayload;
 }
-export declare class UserAuthorizationRequiredError extends Error {
-    constructor(message: string);
+export declare class ConnectError extends Error {
+    readonly code?: string;
+    readonly status?: number;
+    readonly statusText?: string;
+    readonly vendor?: ConnectVendorErrorPayload;
+    constructor(message: string, options?: ConnectErrorOptions);
 }
-export declare class ConnectorInstallationRequiredError extends Error {
-    constructor(message: string);
+export declare class NoValidTokenError extends ConnectError {
+    constructor(message: string, options?: ConnectErrorOptions);
+}
+export declare class UserAuthorizationRequiredError extends ConnectError {
+    constructor(message: string, options?: ConnectErrorOptions);
+}
+export declare class ConnectorInstallationRequiredError extends ConnectError {
+    constructor(message: string, options?: ConnectErrorOptions);
 }
 export interface ConnectOptions {
     vercelToken?: string;
 }
 export declare function getToken(connector: string, params: ConnectTokenParams, options?: ConnectOptions): Promise<string>;
 export declare function getTokenResponse(connector: string, params: ConnectTokenParams, options?: ConnectOptions): Promise<ConnectTokenResponse>;
+export declare function createConnectErrorFromResponse(response: Response, fallbackMessage: string): Promise<ConnectError>;