@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/mcp-oauth.js

@@ -2,15 +2,6 @@
  * Host-side MCP OAuth for `defineConnection({ url, oauth: true })`.
  * Local: mcp-auth.json. Prod secrets: `mcp oauth <name> --store`.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
@@ -38,13 +29,12 @@ export function mcpOauthSecretNames(connection) {
     };
 }
 export function tokensFromEnv(connection, env = process.env) {
-    var _a, _b;
     const names = mcpOauthSecretNames(connection);
-    const access = (_a = env[names.accessToken]) === null || _a === void 0 ? void 0 : _a.trim();
+    const access = env[names.accessToken]?.trim();
     if (access === undefined || access === "") {
         return undefined;
     }
-    const refresh = (_b = env[names.refreshToken]) === null || _b === void 0 ? void 0 : _b.trim();
+    const refresh = env[names.refreshToken]?.trim();
     return {
         access_token: access,
         refresh_token: refresh === undefined || refresh === "" ? undefined : refresh,
@@ -52,8 +42,7 @@ export function tokensFromEnv(connection, env = process.env) {
     };
 }
 export function clientIdFromEnv(connection, env = process.env) {
-    var _a;
-    const clientId = (_a = env[mcpOauthSecretNames(connection).clientId]) === null || _a === void 0 ? void 0 : _a.trim();
+    const clientId = env[mcpOauthSecretNames(connection).clientId]?.trim();
     if (clientId === undefined || clientId === "") {
         return undefined;
     }
@@ -87,127 +76,101 @@ export class FileMcpOAuthStore {
     constructor(path = defaultMcpAuthPath()) {
         this.path = path;
     }
-    loadTokens(id, resourceUrl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            return (_a = (yield this.entryFor(id, resourceUrl))) === null || _a === void 0 ? void 0 : _a.tokens;
-        });
-    }
-    loadClientInformation(id, resourceUrl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            return (_a = (yield this.entryFor(id, resourceUrl))) === null || _a === void 0 ? void 0 : _a.clientInfo;
-        });
-    }
-    saveTokens(id, resourceUrl, tokens) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.update(id, resourceUrl, entry => {
-                entry.tokens = tokens;
-            });
-        });
-    }
-    saveClientInformation(id, resourceUrl, clientInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.update(id, resourceUrl, entry => {
-                entry.clientInfo = clientInfo;
-            });
-        });
+    async loadTokens(id, resourceUrl) {
+        return (await this.entryFor(id, resourceUrl))?.tokens;
     }
-    deleteCredentials(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.withLock(() => __awaiter(this, void 0, void 0, function* () {
-                const data = yield this.read();
-                delete data[id];
-                yield this.write(data);
-            }));
-        });
+    async loadClientInformation(id, resourceUrl) {
+        return (await this.entryFor(id, resourceUrl))?.clientInfo;
     }
-    entryFor(id, resourceUrl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const entry = (yield this.read())[id];
-            if (entry === undefined) {
-                return undefined;
-            }
-            const bound = entry.resourceUrl;
-            if (bound === undefined || bound !== normalizeMcpResourceUrl(resourceUrl)) {
-                return undefined;
-            }
-            return entry;
+    async saveTokens(id, resourceUrl, tokens) {
+        await this.update(id, resourceUrl, entry => {
+            entry.tokens = tokens;
         });
     }
-    update(id, resourceUrl, mutate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const normalized = normalizeMcpResourceUrl(resourceUrl);
-            yield this.withLock(() => __awaiter(this, void 0, void 0, function* () {
-                const data = yield this.read();
-                const existing = data[id];
-                const entry = (existing === null || existing === void 0 ? void 0 : existing.resourceUrl) === normalized ? Object.assign({}, existing) : {};
-                entry.resourceUrl = normalized;
-                mutate(entry);
-                data[id] = entry;
-                yield this.write(data);
-            }));
+    async saveClientInformation(id, resourceUrl, clientInfo) {
+        await this.update(id, resourceUrl, entry => {
+            entry.clientInfo = clientInfo;
         });
     }
-    read() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (this.cache !== undefined) {
-                return this.cache;
-            }
-            (_a = this.loading) !== null && _a !== void 0 ? _a : (this.loading = this.readDisk().then(data => {
-                this.cache = data;
-                return data;
-            }));
-            return this.loading;
+    async deleteCredentials(id) {
+        await this.withLock(async () => {
+            const data = await this.read();
+            delete data[id];
+            await this.write(data);
         });
     }
-    readDisk() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const parsed = JSON.parse(yield readFile(this.path, "utf8"));
-                if (typeof parsed !== "object" || parsed === null) {
-                    return {};
-                }
-                return parsed;
-            }
-            catch (error) {
-                if (typeof error === "object" &&
-                    error !== null &&
-                    "code" in error &&
-                    error.code === "ENOENT") {
-                    return {};
-                }
-                throw error;
-            }
+    async entryFor(id, resourceUrl) {
+        const entry = (await this.read())[id];
+        if (entry === undefined) {
+            return undefined;
+        }
+        const bound = entry.resourceUrl;
+        if (bound === undefined || bound !== normalizeMcpResourceUrl(resourceUrl)) {
+            return undefined;
+        }
+        return entry;
+    }
+    async update(id, resourceUrl, mutate) {
+        const normalized = normalizeMcpResourceUrl(resourceUrl);
+        await this.withLock(async () => {
+            const data = await this.read();
+            const existing = data[id];
+            const entry = existing?.resourceUrl === normalized ? { ...existing } : {};
+            entry.resourceUrl = normalized;
+            mutate(entry);
+            data[id] = entry;
+            await this.write(data);
         });
     }
-    write(data) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async read() {
+        if (this.cache !== undefined) {
+            return this.cache;
+        }
+        this.loading ??= this.readDisk().then(data => {
             this.cache = data;
-            yield mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
-            yield writeFile(this.path, `${JSON.stringify(data, null, 2)}\n`, {
-                mode: 0o600,
-            });
-            yield chmod(this.path, 0o600);
+            return data;
         });
+        return this.loading;
     }
-    withLock(fn) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const prev = (_a = locks.get(this.path)) !== null && _a !== void 0 ? _a : Promise.resolve();
-            let release;
-            locks.set(this.path, new Promise(resolve => {
-                release = resolve;
-            }));
-            try {
-                yield prev;
-                return yield fn();
+    async readDisk() {
+        try {
+            const parsed = JSON.parse(await readFile(this.path, "utf8"));
+            if (typeof parsed !== "object" || parsed === null) {
+                return {};
             }
-            finally {
-                release();
+            return parsed;
+        }
+        catch (error) {
+            if (typeof error === "object" &&
+                error !== null &&
+                "code" in error &&
+                error.code === "ENOENT") {
+                return {};
             }
+            throw error;
+        }
+    }
+    async write(data) {
+        this.cache = data;
+        await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
+        await writeFile(this.path, `${JSON.stringify(data, null, 2)}\n`, {
+            mode: 0o600,
         });
+        await chmod(this.path, 0o600);
+    }
+    async withLock(fn) {
+        const prev = locks.get(this.path) ?? Promise.resolve();
+        let release;
+        locks.set(this.path, new Promise(resolve => {
+            release = resolve;
+        }));
+        try {
+            await prev;
+            return await fn();
+        }
+        finally {
+            release();
+        }
     }
 }
 /**
@@ -218,43 +181,40 @@ export class FileMcpOAuthStore {
  * path shape on any origin so local translators work, and fails to the
  * default behavior (indicator kept) when the PRM is unreachable.
  */
-export function fetchOmitResourceIndicatorFromPrm(resourceUrl_1) {
-    return __awaiter(this, arguments, void 0, function* (resourceUrl, fetchImpl = fetch) {
-        let url;
-        try {
-            url = new URL(resourceUrl);
-        }
-        catch (_a) {
-            return false;
-        }
-        if (!/^\/rest-mcp\/[^/]+\/mcp\/?$/.test(url.pathname)) {
-            return false;
-        }
-        const prmUrl = `${url.origin}/.well-known/oauth-protected-resource${url.pathname.replace(/\/+$/, "")}`;
-        try {
-            const response = yield fetchImpl(prmUrl);
-            if (!response.ok) {
-                return false;
-            }
-            const document = (yield response.json());
-            return document.cursor_omit_resource_indicator === true;
-        }
-        catch (_b) {
+export async function fetchOmitResourceIndicatorFromPrm(resourceUrl, fetchImpl = fetch) {
+    let url;
+    try {
+        url = new URL(resourceUrl);
+    }
+    catch {
+        return false;
+    }
+    if (!/^\/rest-mcp\/[^/]+\/mcp\/?$/.test(url.pathname)) {
+        return false;
+    }
+    const prmUrl = `${url.origin}/.well-known/oauth-protected-resource${url.pathname.replace(/\/+$/, "")}`;
+    try {
+        const response = await fetchImpl(prmUrl);
+        if (!response.ok) {
             return false;
         }
-    });
+        const document = (await response.json());
+        return document.cursor_omit_resource_indicator === true;
+    }
+    catch {
+        return false;
+    }
 }
 export class HostMcpOAuthProvider {
     constructor(args) {
-        var _a;
         this.args = args;
         this.tokensValue = args.tokens;
         this.clientInfo = args.clientInformation;
         if (args.omitResourceIndicator === true) {
-            this.validateResourceURL = () => __awaiter(this, void 0, void 0, function* () { return undefined; });
+            this.validateResourceURL = async () => undefined;
         }
         this.meta = {
-            redirect_uris: [(_a = args.redirectUrl) !== null && _a !== void 0 ? _a : MCP_OAUTH_CALLBACK_URL],
+            redirect_uris: [args.redirectUrl ?? MCP_OAUTH_CALLBACK_URL],
             token_endpoint_auth_method: "none",
             grant_types: ["authorization_code", "refresh_token"],
             response_types: ["code"],
@@ -262,8 +222,7 @@ export class HostMcpOAuthProvider {
         };
     }
     get redirectUrl() {
-        var _a;
-        return (_a = this.args.redirectUrl) !== null && _a !== void 0 ? _a : MCP_OAUTH_CALLBACK_URL;
+        return this.args.redirectUrl ?? MCP_OAUTH_CALLBACK_URL;
     }
     get clientMetadata() {
         return this.meta;
@@ -277,30 +236,23 @@ export class HostMcpOAuthProvider {
     clientInformation() {
         return this.clientInfo;
     }
-    saveClientInformation(info) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.clientInfo = info;
-            yield this.args.store.saveClientInformation(this.args.identifier, this.args.resourceUrl, info);
-        });
+    async saveClientInformation(info) {
+        this.clientInfo = info;
+        await this.args.store.saveClientInformation(this.args.identifier, this.args.resourceUrl, info);
     }
     tokens() {
         return this.tokensValue;
     }
-    saveTokens(tokens) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.tokensValue = tokens;
-            yield this.args.store.saveTokens(this.args.identifier, this.args.resourceUrl, tokens);
-        });
+    async saveTokens(tokens) {
+        this.tokensValue = tokens;
+        await this.args.store.saveTokens(this.args.identifier, this.args.resourceUrl, tokens);
     }
     redirectToAuthorization(url) {
-        var _a, _b;
         this.redirect = url;
-        (_b = (_a = this.args).onRedirect) === null || _b === void 0 ? void 0 : _b.call(_a, url);
+        this.args.onRedirect?.(url);
     }
-    saveCodeVerifier(codeVerifier) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.verifier = codeVerifier;
-        });
+    async saveCodeVerifier(codeVerifier) {
+        this.verifier = codeVerifier;
     }
     codeVerifier() {
         if (this.verifier === undefined) {
@@ -308,22 +260,20 @@ export class HostMcpOAuthProvider {
         }
         return this.verifier;
     }
-    invalidateCredentials(scope) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (scope === "tokens" || scope === "all") {
-                this.tokensValue = undefined;
-            }
-            if (scope === "client" || scope === "all") {
-                this.clientInfo = undefined;
-            }
-            if (scope === "verifier" || scope === "all") {
-                this.verifier = undefined;
-                this.redirect = undefined;
-            }
-            if (scope === "all") {
-                yield this.args.store.deleteCredentials(this.args.identifier);
-            }
-        });
+    async invalidateCredentials(scope) {
+        if (scope === "tokens" || scope === "all") {
+            this.tokensValue = undefined;
+        }
+        if (scope === "client" || scope === "all") {
+            this.clientInfo = undefined;
+        }
+        if (scope === "verifier" || scope === "all") {
+            this.verifier = undefined;
+            this.redirect = undefined;
+        }
+        if (scope === "all") {
+            await this.args.store.deleteCredentials(this.args.identifier);
+        }
     }
 }
 function clientForRedirect(info, redirectUrl) {
@@ -332,26 +282,23 @@ function clientForRedirect(info, redirectUrl) {
     }
     return info;
 }
-export function createHostMcpOAuthProvider(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const store = (_a = args.store) !== null && _a !== void 0 ? _a : new FileMcpOAuthStore();
-        const redirectUrl = (_b = args.redirectUrl) !== null && _b !== void 0 ? _b : MCP_OAUTH_CALLBACK_URL;
-        const [fileTokens, fileClient, omitResourceIndicator] = yield Promise.all([
-            store.loadTokens(args.identifier, args.resourceUrl),
-            store.loadClientInformation(args.identifier, args.resourceUrl),
-            fetchOmitResourceIndicatorFromPrm(args.resourceUrl),
-        ]);
-        return new HostMcpOAuthProvider({
-            identifier: args.identifier,
-            resourceUrl: args.resourceUrl,
-            store,
-            redirectUrl,
-            tokens: fileTokens !== null && fileTokens !== void 0 ? fileTokens : tokensFromEnv(args.identifier),
-            clientInformation: clientForRedirect(fileClient !== null && fileClient !== void 0 ? fileClient : clientIdFromEnv(args.identifier), redirectUrl),
-            onRedirect: args.onRedirect,
-            omitResourceIndicator,
-        });
+export async function createHostMcpOAuthProvider(args) {
+    const store = args.store ?? new FileMcpOAuthStore();
+    const redirectUrl = args.redirectUrl ?? MCP_OAUTH_CALLBACK_URL;
+    const [fileTokens, fileClient, omitResourceIndicator] = await Promise.all([
+        store.loadTokens(args.identifier, args.resourceUrl),
+        store.loadClientInformation(args.identifier, args.resourceUrl),
+        fetchOmitResourceIndicatorFromPrm(args.resourceUrl),
+    ]);
+    return new HostMcpOAuthProvider({
+        identifier: args.identifier,
+        resourceUrl: args.resourceUrl,
+        store,
+        redirectUrl,
+        tokens: fileTokens ?? tokensFromEnv(args.identifier),
+        clientInformation: clientForRedirect(fileClient ?? clientIdFromEnv(args.identifier), redirectUrl),
+        onRedirect: args.onRedirect,
+        omitResourceIndicator,
     });
 }
 /**
@@ -360,75 +307,71 @@ export function createHostMcpOAuthProvider(args) {
  * public npm with no private workspace dependencies, and its OAuth state is a
  * bare UUID rather than the payload that module's validator expects.
  */
-export function waitForMcpOAuthCallback(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
-        const port = (_a = args.port) !== null && _a !== void 0 ? _a : MCP_OAUTH_CALLBACK_PORT;
-        const path = (_b = args.path) !== null && _b !== void 0 ? _b : MCP_OAUTH_CALLBACK_PATH;
-        const timeoutMs = (_c = args.timeoutMs) !== null && _c !== void 0 ? _c : 5 * 60 * 1000;
-        const expectedState = new URL(args.authorizationUrl).searchParams.get("state");
-        return new Promise((resolve, reject) => {
-            let done = false;
-            const finish = (result, error) => {
-                if (done) {
-                    return;
-                }
-                done = true;
-                clearTimeout(timer);
-                server.close();
-                if (error !== undefined) {
-                    reject(error);
-                    return;
-                }
-                if (result !== undefined) {
-                    resolve(result);
-                }
-            };
-            const server = createServer((req, res) => {
-                var _a, _b;
-                if (req.url === "/favicon.ico") {
-                    res.writeHead(404).end();
-                    return;
-                }
-                const url = new URL((_a = req.url) !== null && _a !== void 0 ? _a : "", `http://localhost:${port}`);
-                if (url.pathname !== path) {
-                    res.writeHead(404).end("Not found");
-                    return;
-                }
-                const code = url.searchParams.get("code");
-                const oauthError = url.searchParams.get("error");
-                const state = (_b = url.searchParams.get("state")) !== null && _b !== void 0 ? _b : undefined;
-                // Without this, any page that can reach the loopback port during a login
-                // can inject its own authorization code into the exchange. Ignore what is
-                // not ours rather than failing the login: treating a stray request as
-                // fatal would let any page cancel a login, and free the port for someone
-                // else to bind before the real callback arrives.
-                if (state !== (expectedState !== null && expectedState !== void 0 ? expectedState : undefined)) {
-                    res
-                        .writeHead(404, { "content-type": "text/html; charset=utf-8" })
-                        .end("<!doctype html><html><body><h1>Not found</h1></body></html>");
-                    return;
-                }
-                if (code) {
-                    res
-                        .writeHead(200, { "content-type": "text/html; charset=utf-8" })
-                        .end("<!doctype html><html><body><h1>Authorized</h1><p>Return to Agent SDK.</p></body></html>");
-                    finish({ code, state });
-                    return;
-                }
+export async function waitForMcpOAuthCallback(args) {
+    const port = args.port ?? MCP_OAUTH_CALLBACK_PORT;
+    const path = args.path ?? MCP_OAUTH_CALLBACK_PATH;
+    const timeoutMs = args.timeoutMs ?? 5 * 60 * 1000;
+    const expectedState = new URL(args.authorizationUrl).searchParams.get("state");
+    return new Promise((resolve, reject) => {
+        let done = false;
+        const finish = (result, error) => {
+            if (done) {
+                return;
+            }
+            done = true;
+            clearTimeout(timer);
+            server.close();
+            if (error !== undefined) {
+                reject(error);
+                return;
+            }
+            if (result !== undefined) {
+                resolve(result);
+            }
+        };
+        const server = createServer((req, res) => {
+            if (req.url === "/favicon.ico") {
+                res.writeHead(404).end();
+                return;
+            }
+            const url = new URL(req.url ?? "", `http://localhost:${port}`);
+            if (url.pathname !== path) {
+                res.writeHead(404).end("Not found");
+                return;
+            }
+            const code = url.searchParams.get("code");
+            const oauthError = url.searchParams.get("error");
+            const state = url.searchParams.get("state") ?? undefined;
+            // Without this, any page that can reach the loopback port during a login
+            // can inject its own authorization code into the exchange. Ignore what is
+            // not ours rather than failing the login: treating a stray request as
+            // fatal would let any page cancel a login, and free the port for someone
+            // else to bind before the real callback arrives.
+            if (state !== (expectedState ?? undefined)) {
                 res
-                    .writeHead(400, { "content-type": "text/html; charset=utf-8" })
-                    .end(`<!doctype html><html><body><h1>Authorization failed</h1><p>${oauthError !== null && oauthError !== void 0 ? oauthError : "missing code"}</p></body></html>`);
-                finish(undefined, new Error(`OAuth authorization failed: ${oauthError !== null && oauthError !== void 0 ? oauthError : "missing code"}`));
-            });
-            const timer = setTimeout(() => {
-                finish(undefined, new Error(`Timed out waiting for OAuth callback on http://localhost:${port}${path}`));
-            }, timeoutMs);
-            server.on("error", error => {
-                finish(undefined, new Error(`OAuth callback port ${port} failed: ${error instanceof Error ? error.message : String(error)}`));
-            });
-            server.listen(port, "127.0.0.1");
+                    .writeHead(404, { "content-type": "text/html; charset=utf-8" })
+                    .end("<!doctype html><html><body><h1>Not found</h1></body></html>");
+                return;
+            }
+            if (code) {
+                res
+                    .writeHead(200, { "content-type": "text/html; charset=utf-8" })
+                    .end("<!doctype html><html><body><h1>Authorized</h1><p>Return to Agent SDK.</p></body></html>");
+                finish({ code, state });
+                return;
+            }
+            res
+                .writeHead(400, { "content-type": "text/html; charset=utf-8" })
+                .end(`<!doctype html><html><body><h1>Authorization failed</h1><p>${oauthError ?? "missing code"}</p></body></html>`);
+            finish(undefined, new Error(`OAuth authorization failed: ${oauthError ?? "missing code"}`));
+        });
+        const timer = setTimeout(() => {
+            finish(undefined, new Error(`Timed out waiting for OAuth callback on http://localhost:${port}${path}`));
+        }, timeoutMs);
+        server.on("error", error => {
+            finish(undefined, new Error(`OAuth callback port ${port} failed: ${error instanceof Error ? error.message : String(error)}`));
         });
+        server.listen(port, "127.0.0.1");
     });
 }
 export function openBrowser(url) {

package/dist/internal/named-webhook-secret.d.ts

@@ -0,0 +1,39 @@
+import { type SecretRef } from "../types.js";
+/**
+ * The shapes an SCM channel accepts for its webhook secret. Only the
+ * {@link SecretRef} form names the secret, which is what lets `deploy` write
+ * it into the manifest and the control plane verify the sender at ingestion.
+ */
+export type WebhookSecretValue = string | SecretRef | (() => string | undefined);
+/**
+ * The omitted-`webhookSecret` fallback: a {@link SecretRef} naming `envName`,
+ * present only while that env var is non-empty at channel construction.
+ * Named rather than read so the fallback keeps the same route policy (and
+ * the same control-plane catch declaration) as an authored
+ * `{ secretName: envName }`.
+ */
+export declare function envSecretRef(envName: string): SecretRef | undefined;
+/**
+ * The secret's value for the handler's own check. A named secret resolves
+ * from the environment: locally the shell's, hosted the bound deployment
+ * secrets. Empty and whitespace-only values count as unset.
+ */
+export declare function resolveWebhookSecretValue(value: WebhookSecretValue | undefined): string | undefined;
+/**
+ * Why an SCM channel cannot deploy onto architecture v2 as authored, or
+ * `undefined` when it can. v2 terminates the provider's webhook check on
+ * the control plane, which can only do that for a secret it can name: a
+ * literal or getter value never reaches the manifest, so the check would
+ * run inside the guest only — after compute was spent and after the SCM
+ * already got its 202. Omitting the field (the env fallback) is allowed.
+ */
+export declare function namedWebhookSecretArchitectureError(args: {
+    /** Author-facing option path, e.g. `githubChannel credentials.webhookSecret`. */
+    option: string;
+    webhookSecret: unknown;
+    /** Env var / deployment secret name the fallback and the fix use. */
+    envName: string;
+    /** What the control plane checks, e.g. `X-Hub-Signature-256`. */
+    verifies: string;
+}): string | undefined;
+//# sourceMappingURL=named-webhook-secret.d.ts.map

package/dist/internal/named-webhook-secret.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"named-webhook-secret.d.ts","sourceRoot":"","sources":["../../src/internal/named-webhook-secret.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE1D;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,SAAS,GAAG,CAAC,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC;AAEjF;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAGnE;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,kBAAkB,GAAG,SAAS,GACpC,MAAM,GAAG,SAAS,CAYpB;AAED;;;;;;;GAOG;AACH,wBAAgB,mCAAmC,CAAC,IAAI,EAAE;IACxD,iFAAiF;IACjF,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,OAAO,CAAC;IACvB,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,MAAM,GAAG,SAAS,CAWrB"}