@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/cnb/actions.js

@@ -0,0 +1,341 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const repo = s.nonWhitespaceString("Repository path without .git, including parent organizations, for example team/project.");
+const number = s.string("Issue or pull request number as a decimal string.", {
+    pattern: "^[0-9]+$",
+});
+const page = s.optional(s.integer("Page number, starting at 1.", { minimum: 1, default: 1 }));
+const pageSize = s.optional(s.integer("Number of items per page.", { minimum: 1, default: 10 }));
+const pagination = { page, page_size: pageSize };
+const title = s.nonWhitespaceString("Issue or pull request title.");
+const body = s.optional(s.string("Markdown body content."));
+const priority = s.optional(s.stringEnum("Issue priority.", ["-2P", "-1P", "P0", "P1", "P2", "P3"]));
+const state = s.optional(s.stringEnum("Issue or pull request state.", ["open", "closed"]));
+const labels = s.optional(s.string("Comma-separated label names."));
+const authors = s.optional(s.string("Comma-separated author names."));
+const assignees = s.optional(s.string("Comma-separated assignee names; use - for unassigned."));
+const operator = s.optional(s.stringEnum("Match any or all supplied values.", ["contains_any", "contains_all"]));
+const updated = {
+    updated_time_begin: s.optional(s.string("Start of the update date range, for example 2026-01-01.")),
+    updated_time_end: s.optional(s.string("End of the update date range, for example 2026-12-31.")),
+};
+const issueDates = {
+    start_date: s.optional(s.string("Issue start date, for example 2026-01-01.")),
+    end_date: s.optional(s.string("Issue end date, for example 2026-12-31.")),
+};
+const commonOutput = {
+    number: s.string("Issue or pull request number."),
+    title: s.string("Issue or pull request title."),
+    body: s.string("Markdown body content."),
+    state: s.string("Current state returned by CNB."),
+};
+const repositoryOutput = s.looseObject("Repository information, including any additional CNB fields.", {
+    id: s.string("Repository ID."),
+    name: s.string("Repository name."),
+    path: s.string("Full repository path."),
+    web_url: s.string("Repository web URL."),
+    description: s.string("Repository description."),
+});
+const issueFields = {
+    number: commonOutput.number,
+    title: commonOutput.title,
+    state: commonOutput.state,
+    priority: s.string("Issue priority."),
+    state_reason: s.string("Reason for the current issue state."),
+};
+const issueListOutput = s.looseObject("Issue information, including any additional CNB fields.", issueFields);
+const issueOutput = s.looseObject("Issue information, including any additional CNB fields.", {
+    ...issueFields,
+    body: commonOutput.body,
+});
+const pullOutput = s.looseObject("Pull request information, including any additional CNB fields.", {
+    ...commonOutput,
+    is_merged: s.boolean("Whether the pull request has been merged."),
+    mergeable_state: s.string("Current mergeability state."),
+    head: s.looseObject("Source branch information.", {}),
+    base: s.looseObject("Target branch information.", {}),
+});
+const commentOutput = s.looseObject("Issue comment information, including any additional CNB fields.", {
+    id: s.string("Comment ID."),
+    body: s.string("Comment content."),
+    created_at: s.string("Comment creation time."),
+});
+export const cnbActions = [
+    defineProviderAction("cnb", {
+        name: "list_repositories",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List repositories accessible to the current user. Requires account-engage:r. The default minimum role is Guest; increase page until an empty page is returned.",
+        inputSchema: s.requiredObject("Repository list filters.", {
+            ...pagination,
+            search: s.optional(s.string("Filter repositories by name.")),
+            filter_type: s.optional(s.stringEnum("Repository visibility.", ["private", "public", "secret"])),
+            role: s.optional({
+                ...s.stringEnum("Minimum repository role; defaults to Guest to include all accessible repositories.", [
+                    "Guest",
+                    "Reporter",
+                    "Developer",
+                    "Master",
+                    "Owner",
+                ]),
+                default: "Guest",
+            }),
+            flags: s.optional(s.string("Comma-separated repository flags: KnowledgeBase, NPC, Skills.")),
+            flags_match: s.optional(s.stringEnum("How multiple repository flags are matched.", ["intersection", "union"])),
+            status: s.optional(s.stringEnum("Repository status.", ["active", "archived"])),
+            order_by: s.optional(s.stringEnum("Repository sort field.", ["created_at", "last_updated_at", "stars", "slug_path", "forks"])),
+            desc: s.optional(s.boolean("Whether to sort in descending order.")),
+        }),
+        outputSchema: s.requiredObject("One page of repositories.", {
+            items: s.array("Repositories on this page.", repositoryOutput),
+        }),
+    }),
+    defineProviderAction("cnb", {
+        name: "get_repository",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get repository information. Requires repo-basic-info:r.",
+        inputSchema: s.requiredObject("Repository selection.", { repo }),
+        outputSchema: repositoryOutput,
+    }),
+    defineProviderAction("cnb", {
+        name: "list_issues",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List and filter repository issues. Requires repo-issue:r. Increase page until an empty page is returned.",
+        inputSchema: s.requiredObject("Issue list filters.", {
+            repo,
+            ...pagination,
+            page_size: s.optional(s.integer("Number of issues per page, at most 100.", {
+                minimum: 1,
+                maximum: 100,
+                default: 10,
+            })),
+            state,
+            keyword: s.optional(s.string("Search issue titles and content.")),
+            priority: s.optional(s.string("Comma-separated priorities: -2P, -1P, P0, P1, P2, P3.")),
+            labels,
+            labels_operator: operator,
+            authors,
+            assignees,
+            ...updated,
+            close_time_begin: s.optional(s.string("Start of the issue closure date range.")),
+            close_time_end: s.optional(s.string("End of the issue closure date range.")),
+            order_by: s.optional(s.stringEnum("Issue sort field; a leading minus means descending.", [
+                "created_at",
+                "-created_at",
+                "-updated_at",
+                "-last_acted_at",
+            ])),
+        }),
+        outputSchema: s.requiredObject("One page of issues.", {
+            items: s.array("Issues on this page.", issueListOutput),
+        }),
+    }),
+    defineProviderAction("cnb", {
+        name: "get_issue",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get an issue with its full description and metadata. Requires repo-issue:r.",
+        inputSchema: s.requiredObject("Issue selection.", { repo, number }),
+        outputSchema: issueOutput,
+    }),
+    defineProviderAction("cnb", {
+        name: "create_issue",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Create a repository issue with optional labels, assignees, dates and priority. Requires repo-issue:rw.",
+        inputSchema: s.requiredObject("Issue creation parameters.", {
+            repo,
+            title,
+            body,
+            priority,
+            ...issueDates,
+            invisible: s.optional(s.boolean("Whether the issue is private.")),
+            work_mode: s.optional(s.boolean("Whether work mode is enabled.")),
+            assignees: s.optional(s.array("Issue assignee names, at most 8.", s.string("Assignee name."), { maxItems: 8 })),
+            labels: s.optional(s.array("Issue label names, at most 10.", s.string("Label name."), { maxItems: 10 })),
+        }),
+        outputSchema: issueOutput,
+    }),
+    defineProviderAction("cnb", {
+        name: "update_issue",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Update issue content, dates, visibility, priority or workflow state. Supply state and state_reason together. Requires repo-issue:rw.",
+        inputSchema: {
+            ...s.object("Issue changes; omitted fields are unchanged.", {
+                repo,
+                number,
+                title: s.optional(title),
+                body,
+                priority,
+                ...issueDates,
+                invisible: s.optional(s.boolean("Whether the issue is private.")),
+                state,
+                state_reason: s.optional(s.stringEnum("Issue state reason; use reopened with open, completed or not_planned with closed.", [
+                    "completed",
+                    "not_planned",
+                    "reopened",
+                ])),
+            }),
+            minProperties: 3,
+            dependentRequired: { state: ["state_reason"], state_reason: ["state"] },
+        },
+        outputSchema: issueOutput,
+    }),
+    defineProviderAction("cnb", {
+        name: "list_issue_comments",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List issue comments. Requires repo-notes:r. Increase page until an empty page is returned.",
+        inputSchema: s.requiredObject("Issue comment list filters.", {
+            repo,
+            number,
+            ...pagination,
+            sort: s.optional(s.stringEnum("Comment sort order; a leading minus means descending.", [
+                "created",
+                "updated",
+                "-created",
+                "-updated",
+            ])),
+        }),
+        outputSchema: s.requiredObject("One page of comments.", {
+            items: s.array("Comments on this page.", commentOutput),
+        }),
+    }),
+    defineProviderAction("cnb", {
+        name: "create_issue_comment",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Add a comment to an issue. Requires repo-notes:rw.",
+        inputSchema: s.requiredObject("Issue comment creation parameters.", {
+            repo,
+            number,
+            body: s.nonWhitespaceString("Comment content."),
+            work_mode: s.optional(s.boolean("Whether work mode is enabled.")),
+        }),
+        outputSchema: commentOutput,
+    }),
+    defineProviderAction("cnb", {
+        name: "list_pull_requests",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List repository pull requests with filters. Requires repo-pr:r. Increase page until an empty page is returned.",
+        inputSchema: s.requiredObject("Pull request list filters.", {
+            repo,
+            ...pagination,
+            state: s.optional(s.stringEnum("Pull request state filter; CNB defaults to open.", ["open", "closed", "all"])),
+            authors,
+            assignees,
+            labels,
+            assignees_operator: operator,
+            labels_operator: operator,
+            reviewers: s.optional(s.string("Comma-separated reviewer names; use - for no reviewer.")),
+            reviewers_operator: operator,
+            base_ref: s.optional(s.string("Target branch name.")),
+            ...updated,
+            order_by: s.optional(s.stringEnum("Pull request sort field; a leading minus means descending.", [
+                "created_at",
+                "-created_at",
+                "-updated_at",
+            ])),
+        }),
+        outputSchema: s.requiredObject("One page of pull requests.", {
+            items: s.array("Pull requests on this page.", pullOutput),
+        }),
+    }),
+    defineProviderAction("cnb", {
+        name: "get_pull_request",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get pull request details and mergeability information. Requires repo-pr:r.",
+        inputSchema: s.requiredObject("Pull request selection.", { repo, number }),
+        outputSchema: pullOutput,
+    }),
+    defineProviderAction("cnb", {
+        name: "create_pull_request",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Create a pull request from a source branch into a target branch. Requires repo-pr:rw.",
+        inputSchema: s.requiredObject("Pull request creation parameters.", {
+            repo,
+            title,
+            body,
+            head: s.nonWhitespaceString("Source branch name."),
+            base: s.nonWhitespaceString("Target branch name."),
+            head_repo: s.optional(s.nonWhitespaceString("Source repository path for a cross-repository pull request.")),
+        }),
+        outputSchema: pullOutput,
+    }),
+    defineProviderAction("cnb", {
+        name: "update_pull_request",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Update a pull request title, description or open/closed workflow state. Requires repo-pr:rw.",
+        inputSchema: {
+            ...s.object("Pull request changes; omitted fields are unchanged.", {
+                repo,
+                number,
+                title: s.optional(title),
+                body,
+                state,
+            }),
+            minProperties: 3,
+        },
+        outputSchema: pullOutput,
+    }),
+    defineProviderAction("cnb", {
+        name: "list_builds",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List pipeline build history, filtered by branch, event, commit or status. Requires repo-cnb-history:r.",
+        inputSchema: s.requiredObject("Build history filters.", {
+            repo,
+            page,
+            page_size: s.optional(s.integer("Builds per page, at most 100; defaults to 30.", {
+                minimum: 1,
+                maximum: 100,
+                default: 30,
+            })),
+            createTime: s.optional(s.string("Start date in YYYY-MM-DD format.")),
+            endTime: s.optional(s.string("End date in YYYY-MM-DD format.")),
+            event: s.optional(s.string("Build event, for example push.")),
+            sha: s.optional(s.string("Commit SHA.")),
+            sn: s.optional(s.string("Build serial number.")),
+            sourceRef: s.optional(s.string("Source branch name.")),
+            targetRef: s.optional(s.string("Target branch name.")),
+            status: s.optional(s.stringEnum("Build status filter.", ["pending", "success", "error", "cancel"])),
+            userId: s.optional(s.string("Build user ID.")),
+            userName: s.optional(s.string("Build username.")),
+        }),
+        outputSchema: s.looseObject("Build history page and total count.", {
+            data: s.array("Build records on this page.", s.looseObject("Build history record.", {
+                sn: s.string("Build serial number."),
+                status: s.string("Build status."),
+                sha: s.string("Commit SHA."),
+                buildLogUrl: s.string("Build log URL."),
+            })),
+            total: s.integer("Total number of builds matching the filters."),
+            timestamp: s.integer("Current timestamp returned by CNB."),
+        }),
+    }),
+    defineProviderAction("cnb", {
+        name: "get_build_status",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get the current state and pipeline progress of an existing build. Requires repo-cnb-trigger:r.",
+        inputSchema: s.requiredObject("Build selection.", {
+            repo,
+            sn: s.nonWhitespaceString("Build serial number."),
+        }),
+        outputSchema: s.looseObject("Build status and pipeline progress.", {
+            status: s.string("Build status."),
+            pipelinesStatus: s.record("Pipeline states keyed by pipeline ID.", s.looseObject("Pipeline progress.", {
+                id: s.string("Pipeline ID."),
+                name: s.string("Pipeline name."),
+                status: s.string("Pipeline status."),
+            })),
+        }),
+    }),
+];

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

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const credentialValidators: CredentialValidators;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/cnb/executors.js

@@ -0,0 +1,135 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, ProviderRequestError, runProviderRequest, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { cnbActions } from "./actions.js";
+const baseUrl = "https://api.cnb.cool";
+const defaultHeaders = { accept: "application/vnd.cnb.api+json" };
+const routes = {
+    list_repositories: { method: "GET", suffix: "/user/repos", list: true },
+    get_repository: { method: "GET", suffix: "" },
+    list_issues: { method: "GET", suffix: "/-/issues", list: true },
+    get_issue: { method: "GET", suffix: "/-/issues/{number}" },
+    create_issue: { method: "POST", suffix: "/-/issues" },
+    update_issue: { method: "PATCH", suffix: "/-/issues/{number}" },
+    list_issue_comments: { method: "GET", suffix: "/-/issues/{number}/comments", list: true },
+    create_issue_comment: { method: "POST", suffix: "/-/issues/{number}/comments" },
+    list_pull_requests: { method: "GET", suffix: "/-/pulls", list: true },
+    get_pull_request: { method: "GET", suffix: "/-/pulls/{number}" },
+    create_pull_request: { method: "POST", suffix: "/-/pulls" },
+    update_pull_request: { method: "PATCH", suffix: "/-/pulls/{number}" },
+    list_builds: { method: "GET", suffix: "/-/build/logs" },
+    get_build_status: { method: "GET", suffix: "/-/build/status/{sn}" },
+};
+function encodeSegment(value) {
+    if (value === "." || value === ".." || value.includes("\\") || value.length === 0) {
+        throw new ProviderRequestError(400, "Invalid CNB path segment", undefined, "invalid_input");
+    }
+    return encodeURIComponent(value);
+}
+function encodeRepository(value) {
+    const segments = value.split("/");
+    if (segments.length < 2) {
+        throw new ProviderRequestError(400, "CNB repo must include an organization and repository", undefined, "invalid_input");
+    }
+    return segments.map(encodeSegment).join("/");
+}
+async function request({ pathname, method, parameters, apiKey, fetcher, parentSignal }) {
+    return runProviderRequest({ signal: parentSignal, label: "CNB" }, async (signal) => {
+        const url = new URL(`${baseUrl}${pathname}`);
+        if (method === "GET") {
+            for (const [key, value] of Object.entries(parameters)) {
+                if (value !== undefined)
+                    url.searchParams.set(key, String(value));
+            }
+        }
+        const response = await fetcher(url.toString(), {
+            method,
+            signal,
+            headers: {
+                ...defaultHeaders,
+                authorization: `Bearer ${apiKey}`,
+                "content-type": "application/json",
+            },
+            body: method === "GET" ? undefined : JSON.stringify(parameters),
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = undefined;
+        }
+        const error = optionalRecord(payload);
+        if (!response.ok || (typeof error?.errcode === "number" && error.errcode !== 0)) {
+            const message = optionalRawString(error?.errmsg);
+            const code = typeof error?.errcode === "number" ? ` (errcode ${error.errcode})` : "";
+            const detail = (message || `HTTP ${response.status}`).split(apiKey).join("[REDACTED]");
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `CNB request failed${code}: ${detail}`, undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        return payload;
+    });
+}
+const handlers = mapProviderActionHandlers("cnb", cnbActions, (action) => async (dataInput, context) => {
+    const route = routes[action.name];
+    const { repo, number, ...parameters } = dataInput;
+    if (route.list || action.name === "list_builds") {
+        parameters.page ??= 1;
+        parameters.page_size ??= action.name === "list_builds" ? 30 : 10;
+    }
+    if (action.name === "list_repositories")
+        parameters.role ??= "Guest";
+    let suffix = route.suffix.replace("{number}", String(number));
+    if (action.name === "get_build_status") {
+        suffix = suffix.replace("{sn}", encodeSegment(String(parameters.sn)));
+        delete parameters.sn;
+    }
+    if (action.name === "update_issue" && parameters.state !== undefined) {
+        const valid = parameters.state === "open"
+            ? parameters.state_reason === "reopened"
+            : parameters.state_reason === "completed" || parameters.state_reason === "not_planned";
+        if (!valid) {
+            throw new ProviderRequestError(400, "CNB issue state and state_reason do not match", undefined, "invalid_input");
+        }
+    }
+    const pathname = repo === undefined ? suffix : `/${encodeRepository(String(repo))}${suffix}`;
+    const payload = await request({
+        pathname: pathname,
+        method: route.method,
+        parameters: parameters,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+    if (route.list) {
+        if (!Array.isArray(payload)) {
+            throw new ProviderRequestError(502, "CNB returned an invalid list response", undefined, "provider_error");
+        }
+        return { items: payload };
+    }
+    return requiredResponseRecord(payload, "CNB response");
+});
+export const executors = defineApiKeyProviderExecutors("cnb", handlers, { skipDnsValidation: true });
+export const credentialValidators = {
+    async apiKey(input) {
+        requiredInputString(input.apiKey, "API Key");
+        return {
+            profile: { displayName: "CNB Access Token" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl, validationMode: "local_non_empty_key" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "cnb",
+    baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({ accept: "application/vnd.cnb.api+json" }))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "Provider request failed"), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+});

package/src/providers/coupontools/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const coupontoolsApiBaseUrl = "https://api.coupontools.com";
 export async function validateCoupontoolsCredential(input, fetcher, signal) {
     await requestCoupontoolsJson({
@@ -49,7 +49,7 @@ export async function executeCoupontoolsAction(input, fetcher) {
         }
         case "create_single_use_url": {
             if (input.input.customvalcode != null && input.input.autovalcode != null) {
-                throw providerError("invalid_input", "customvalcode and autovalcode cannot be used together", 400);
+                throw providerInputError("customvalcode and autovalcode cannot be used together");
             }
             const raw = await requestCoupontoolsJson({
                 path: "/v3/singleuse/create",
@@ -64,7 +64,7 @@ export async function executeCoupontoolsAction(input, fetcher) {
             const singleUseUrl = optionalString(raw.single_use_url)?.trim();
             const singleUseCode = optionalString(raw.single_use_code)?.trim();
             if (!singleUseUrl || !singleUseCode) {
-                throw providerError("provider_error", "Coupontools response did not include single_use_url and single_use_code", 502);
+                throw providerResponseError("Coupontools response did not include single_use_url and single_use_code");
             }
             return {
                 single_use_url: singleUseUrl,
@@ -76,7 +76,7 @@ export async function executeCoupontoolsAction(input, fetcher) {
 }
 function requireCouponArray(value) {
     if (!Array.isArray(value)) {
-        throw providerError("provider_error", "Coupontools coupon_info must be an array", 502);
+        throw providerResponseError("Coupontools coupon_info must be an array");
     }
     return value;
 }
@@ -104,13 +104,13 @@ async function requestCoupontoolsJson(input) {
 async function readCoupontoolsPayload(response) {
     const text = await response.text();
     if (!text.trim()) {
-        throw providerError("provider_error", "Coupontools returned an empty response", 502);
+        throw providerResponseError("Coupontools returned an empty response");
     }
     try {
         return JSON.parse(text);
     }
     catch {
-        throw providerError("provider_error", "Coupontools returned invalid JSON", 502);
+        throw providerResponseError("Coupontools returned invalid JSON");
     }
 }
 function hasCoupontoolsError(payload) {
@@ -125,22 +125,19 @@ function createCoupontoolsError(statusCode, payload, phase) {
         optionalString(payloadRecord?.message)?.trim() ??
         `Coupontools request failed with status ${statusCode}`;
     if (statusCode == 429) {
-        return providerError("rate_limited", message, 429);
+        return new ProviderRequestError(429, message);
     }
     if (phase == "validate" && 400 <= statusCode && statusCode < 500) {
-        return providerError("invalid_input", message, 400);
+        return providerInputError(message);
     }
     if (statusCode == 401 || statusCode == 403) {
-        return providerError("provider_error", message, statusCode);
+        return new ProviderRequestError(statusCode, message);
     }
     if (400 <= statusCode && statusCode < 500) {
-        return providerError("invalid_input", message, statusCode);
+        return new ProviderRequestError(statusCode, message);
     }
-    return providerError("provider_error", message, statusCode >= 400 ? statusCode : 502);
+    return new ProviderRequestError(statusCode >= 400 ? statusCode : 502, message);
 }
 function requireStoredClientSecret(values) {
     return requiredInputString(values?.clientSecret, "clientSecret");
 }
-function providerError(_code, message, status) {
-    return new ProviderRequestError(status, message);
-}

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

@@ -0,0 +1,3 @@
+import type { ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/crtsh/executors.js

@@ -0,0 +1,19 @@
+import { defineProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { readCrtshError } from "./runtime.js";
+import { crtshActionHandlers, crtshApiBaseUrl } from "./runtime.js";
+const service = "crtsh";
+export const executors = defineProviderExecutors({
+    service,
+    handlers: crtshActionHandlers,
+    skipDnsValidation: true,
+    createContext(context, fetcher) {
+        return { fetcher, signal: context.signal };
+    },
+});
+export const proxy = defineProviderProxy({
+    readError: readCrtshError,
+    service,
+    baseUrl: crtshApiBaseUrl,
+    auth: { type: "none" },
+    skipDnsValidation: true,
+});

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

@@ -0,0 +1,17 @@
+import type { ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+import { ProviderRequestError } from "../provider-runtime.ts";
+export declare const crtshApiBaseUrl = "https://crt.sh";
+export interface CrtshRuntimeContext {
+    fetcher: ProviderFetch;
+    signal?: AbortSignal;
+}
+type CrtshActionHandler = (input: Record<string, unknown>, context: CrtshRuntimeContext) => Promise<unknown>;
+export declare const crtshActionHandlers: ProviderActionHandlers<"crtsh", CrtshActionHandler>;
+/**
+ * Map a crt.sh error onto the runtime's status conventions. crt.sh serves HTML
+ * error pages when overloaded, so surface a short excerpt instead of the page.
+ * The search endpoint needs no credentials, so an authorization failure is not
+ * something reconnecting can fix.
+ */
+export declare function readCrtshError(response: Response): Promise<ProviderRequestError>;
+export {};