@oomol-lab/open-connector 1.6.2 → 1.6.3

package/src/providers/bing_webmaster/actions.js

@@ -0,0 +1,113 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { managementActions } from "./management-actions.js";
+import { reportingActions } from "./reporting-actions.js";
+import { siteInput, siteUrl, siteSchema, trafficSchema, querySchema, crawlSchema, issueSchema, feedSchema, quotaSchema, submittedSchema, } from "./schemas.js";
+const service = "bing_webmaster";
+export const bingWebmasterActions = [
+    ...reportingActions,
+    ...managementActions,
+    defineProviderAction(service, {
+        name: "list_sites",
+        description: "List the sites registered in the Bing Webmaster account, including unverified sites.",
+        operationType: "read",
+        inputSchema: s.object("No input is required.", {}),
+        outputSchema: s.object("The Bing Webmaster API result.", {
+            sites: s.array("The records returned by Bing.", siteSchema),
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "get_rank_and_traffic_stats",
+        description: "Get daily site impressions and clicks across Bing search verticals.",
+        operationType: "read",
+        inputSchema: siteInput,
+        outputSchema: s.object("The Bing Webmaster API result.", {
+            stats: s.array("The records returned by Bing.", trafficSchema),
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "get_query_stats",
+        description: "Get traffic and position statistics for top search queries. Bing updates this report weekly.",
+        operationType: "read",
+        inputSchema: siteInput,
+        outputSchema: s.object("The Bing Webmaster API result.", {
+            stats: s.array("The records returned by Bing.", querySchema),
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "get_page_stats",
+        description: "Get traffic and position statistics for top pages. The Query field contains the page URL.",
+        operationType: "read",
+        inputSchema: siteInput,
+        outputSchema: s.object("The Bing Webmaster API result.", {
+            stats: s.array("The records returned by Bing.", querySchema),
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "get_crawl_stats",
+        description: "Get daily crawl statistics for the last six months.",
+        operationType: "read",
+        inputSchema: siteInput,
+        outputSchema: s.object("The Bing Webmaster API result.", {
+            stats: s.array("The records returned by Bing.", crawlSchema),
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "get_crawl_issues",
+        description: "List URLs with crawl issues. Resolved issues may take several days to disappear.",
+        operationType: "read",
+        inputSchema: siteInput,
+        outputSchema: s.object("The Bing Webmaster API result.", {
+            issues: s.array("The records returned by Bing.", issueSchema),
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "list_sitemaps",
+        description: "List top-level sitemaps and feeds registered for a site.",
+        operationType: "read",
+        inputSchema: siteInput,
+        outputSchema: s.object("The Bing Webmaster API result.", {
+            sitemaps: s.array("The records returned by Bing.", feedSchema),
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "get_url_submission_quota",
+        description: "Get the remaining URL submission quota before submitting URLs.",
+        operationType: "read",
+        inputSchema: siteInput,
+        outputSchema: s.object("The Bing Webmaster API result.", { quota: quotaSchema }),
+    }),
+    defineProviderAction(service, {
+        name: "submit_sitemap",
+        description: "Submit a sitemap, RSS 2.0, Atom 0.3, Atom 1.0, or text feed URL to Bing.",
+        operationType: "write",
+        inputSchema: s.object("The site and URLs to submit.", {
+            siteUrl,
+            feedUrl: s.string("The sitemap or feed URL for Bing to fetch.", { format: "uri" }),
+        }),
+        outputSchema: submittedSchema,
+    }),
+    defineProviderAction(service, {
+        name: "submit_url",
+        description: "Submit one URL to Bing for crawling, subject to the available submission quota.",
+        operationType: "write",
+        inputSchema: s.object("The site and URLs to submit.", {
+            siteUrl,
+            url: s.string("The page URL to submit.", { format: "uri" }),
+        }),
+        outputSchema: submittedSchema,
+    }),
+    defineProviderAction(service, {
+        name: "submit_url_batch",
+        description: "Submit up to 500 URLs to Bing in one request, subject to the available submission quota.",
+        operationType: "write",
+        inputSchema: s.object("The site and URLs to submit.", {
+            siteUrl,
+            urlList: s.array("Between 1 and 500 page URLs to submit.", s.string("A page URL to submit.", { format: "uri" }), {
+                minItems: 1,
+                maxItems: 500,
+            }),
+        }),
+        outputSchema: submittedSchema,
+    }),
+];

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

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

package/src/providers/bing_webmaster/executors.js

@@ -0,0 +1,104 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { readProviderTextBody } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, providerResponseError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { bingWebmasterActions } from "./actions.js";
+const service = "bing_webmaster", baseUrl = "https://ssl.bing.com/webmaster/api.svc/json";
+const endpointOverrides = {
+    list_sites: "GetUserSites",
+    list_sitemaps: "GetFeeds",
+    submit_sitemap: "SubmitFeed",
+    remove_sitemap: "RemoveFeed",
+    list_child_url_info: "GetChildrenUrlInfo",
+    list_child_url_traffic_info: "GetChildrenUrlTrafficInfo",
+    list_connected_pages: "GetConnectedPages",
+    list_fetched_urls: "GetFetchedUrls",
+    list_link_counts: "GetLinkCounts",
+    list_url_links: "GetUrlLinks",
+    list_blocked_urls: "GetBlockedUrls",
+    list_page_preview_blocks: "GetActivePagePreviewBlocks",
+    list_deep_link_blocks: "GetDeepLinkBlocks",
+    list_query_parameters: "GetQueryParameters",
+    list_country_region_settings: "GetCountryRegionSettings",
+    list_site_moves: "GetSiteMoves",
+    list_site_roles: "GetSiteRoles",
+    get_sitemap_details: "GetFeedDetails",
+    set_query_parameter_enabled: "EnableDisableQueryParameter",
+};
+const jsonQueryFields = new Set(["page", "query", "url", "link", "feedUrl"]);
+const handlers = mapProviderActionHandlers(service, bingWebmasterActions, (action) => async (input, context) => {
+    const endpoint = endpointOverrides[action.name] ??
+        action.name
+            .split("_")
+            .map((part) => part[0].toUpperCase() + part.slice(1))
+            .join("");
+    const method = action.operationType === "read" && action.name !== "list_child_url_info" ? "GET" : "POST";
+    const data = await request(endpoint, method, input, context);
+    const properties = optionalRecord(action.outputSchema.properties) ?? {};
+    const output = Object.keys(properties)[0] ?? "result";
+    const schema = optionalRecord(properties[output]);
+    if (method === "POST" && (data === null || data === undefined))
+        return { [output]: true };
+    if (schema?.type === "array" && !Array.isArray(data))
+        throw providerResponseError(`Bing Webmaster ${output} must be a list`);
+    if (schema?.type === "object" && (!data || typeof data !== "object" || Array.isArray(data)))
+        throw providerResponseError(`Bing Webmaster ${output} must be an object`);
+    return { [output]: data };
+});
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl,
+    auth: { type: "api_key_query", name: "apikey" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json");
+    },
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await handlers.list_sites({}, { apiKey: input.apiKey, fetcher, signal });
+        return {
+            profile: { displayName: "Bing Webmaster API Key" },
+            grantedScopes: [],
+            metadata: { validationEndpoint: "GetUserSites" },
+        };
+    },
+};
+async function request(endpoint, method, input, context) {
+    const url = new URL(`${baseUrl}/${endpoint}`);
+    url.searchParams.set("apikey", context.apiKey);
+    if (method === "GET")
+        for (const [key, value] of Object.entries(input))
+            url.searchParams.set(key, jsonQueryFields.has(key) ? JSON.stringify(value) : String(value));
+    const response = await context.fetcher(url, {
+        method,
+        headers: {
+            accept: "application/json",
+            "content-type": "application/json; charset=utf-8",
+            "user-agent": providerUserAgent,
+        },
+        body: method === "POST" ? JSON.stringify(input) : undefined,
+        signal: context.signal,
+    });
+    const text = await readProviderTextBody(response, "Bing Webmaster response");
+    let payload;
+    try {
+        payload = text.trim() ? JSON.parse(text) : undefined;
+    }
+    catch {
+        throw new ProviderRequestError(response.ok ? 502 : response.status, `Bing Webmaster returned invalid JSON (HTTP ${response.status})`);
+    }
+    const envelope = optionalRecord(payload);
+    if (!response.ok || envelope?.ErrorCode !== undefined) {
+        const code = envelope?.ErrorCode;
+        throw new ProviderRequestError(response.status || 502, `Bing Webmaster${code === undefined ? "" : ` (${String(code)})`}: ${optionalString(envelope?.Message) ?? `request failed (HTTP ${response.status})`}`, payload, code === undefined ? undefined : String(code));
+    }
+    if (payload === undefined)
+        return null;
+    if (!envelope || !("d" in envelope))
+        throw providerResponseError("Bing Webmaster response is missing d");
+    return envelope.d;
+}

package/src/providers/bing_webmaster/management-actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const managementActions: readonly ActionDefinition[];

package/src/providers/bing_webmaster/management-actions.js

@@ -0,0 +1,241 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { blockedUrlInput, countrySettingsInput, crawlSettingsInput, siteMoveInput, siteRoleInput, siteUrl, } from "./schemas.js";
+export const managementActions = [
+    defineProviderAction("bing_webmaster", {
+        name: "add_site",
+        description: "Add a site to the account. Ownership must be verified separately.",
+        operationType: "write",
+        inputSchema: s.object("The input for AddSite.", {
+            siteUrl: siteUrl,
+        }),
+        outputSchema: s.object("The result of AddSite.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "remove_site",
+        description: "Remove a site from the account.",
+        operationType: "destructive",
+        inputSchema: s.object("The input for RemoveSite.", {
+            siteUrl: siteUrl,
+        }),
+        outputSchema: s.object("The result of RemoveSite.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "save_crawl_settings",
+        description: "Save crawl settings for a site, replacing supplied settings.",
+        operationType: "destructive",
+        inputSchema: s.object("The input for SaveCrawlSettings.", {
+            siteUrl: siteUrl,
+            crawlSettings: crawlSettingsInput,
+        }),
+        outputSchema: s.object("The result of SaveCrawlSettings.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "add_connected_page",
+        description: "Add a page connected to the site.",
+        operationType: "write",
+        inputSchema: s.object("The input for AddConnectedPage.", {
+            siteUrl: siteUrl,
+            masterUrl: s.string("The connected page URL supplied to Bing as masterUrl.", {
+                format: "uri",
+            }),
+        }),
+        outputSchema: s.object("The result of AddConnectedPage.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "remove_sitemap",
+        description: "Remove a registered sitemap or feed.",
+        operationType: "destructive",
+        inputSchema: s.object("The input for RemoveFeed.", {
+            siteUrl: siteUrl,
+            feedUrl: s.string("The sitemap or feed URL to remove.", { format: "uri" }),
+        }),
+        outputSchema: s.object("The result of RemoveFeed.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "add_blocked_url",
+        description: "Block a page or directory, including cache-only and full-removal modes.",
+        operationType: "destructive",
+        inputSchema: s.object("The input for AddBlockedUrl.", {
+            siteUrl: siteUrl,
+            blockedUrl: blockedUrlInput,
+        }),
+        outputSchema: s.object("The result of AddBlockedUrl.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "remove_blocked_url",
+        description: "Remove an existing page or directory block.",
+        operationType: "destructive",
+        inputSchema: s.object("The input for RemoveBlockedUrl.", {
+            siteUrl: siteUrl,
+            blockedUrl: blockedUrlInput,
+        }),
+        outputSchema: s.object("The result of RemoveBlockedUrl.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "remove_page_preview_block",
+        description: "Remove a page preview block.",
+        operationType: "destructive",
+        inputSchema: s.object("The input for RemovePagePreviewBlock.", {
+            siteUrl: siteUrl,
+            url: s.string("The page URL.", { format: "uri" }),
+        }),
+        outputSchema: s.object("The result of RemovePagePreviewBlock.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "add_deep_link_block",
+        description: "Block a deep link for a search URL and market.",
+        operationType: "destructive",
+        inputSchema: s.object("The input for AddDeepLinkBlock.", {
+            siteUrl: siteUrl,
+            market: s.nonEmptyString("The Bing market identifier, such as en-US."),
+            searchUrl: s.string("The search URL supplied to Bing."),
+            deepLinkUrl: s.string("The deep link URL to block."),
+        }),
+        outputSchema: s.object("The result of AddDeepLinkBlock.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "remove_deep_link_block",
+        description: "Remove a deep link blocking rule.",
+        operationType: "destructive",
+        inputSchema: s.object("The input for RemoveDeepLinkBlock.", {
+            siteUrl: siteUrl,
+            market: s.nonEmptyString("The Bing market identifier, such as en-US."),
+            searchUrl: s.string("The search URL supplied to Bing."),
+            deepLinkUrl: s.string("The deep link URL whose block is removed."),
+        }),
+        outputSchema: s.object("The result of RemoveDeepLinkBlock.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "add_query_parameter",
+        description: "Add a URL normalization parameter.",
+        operationType: "write",
+        inputSchema: s.object("The input for AddQueryParameter.", {
+            siteUrl: siteUrl,
+            queryParameter: s.nonEmptyString("The URL parameter name; Bing permits unreserved characters and colon."),
+        }),
+        outputSchema: s.object("The result of AddQueryParameter.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "set_query_parameter_enabled",
+        description: "Enable or disable a URL normalization parameter.",
+        operationType: "destructive",
+        inputSchema: s.object("The input for EnableDisableQueryParameter.", {
+            siteUrl: siteUrl,
+            queryParameter: s.nonEmptyString("The URL parameter name."),
+            isEnabled: s.boolean("Whether to enable this parameter rule."),
+        }),
+        outputSchema: s.object("The result of EnableDisableQueryParameter.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "remove_query_parameter",
+        description: "Remove a URL normalization parameter.",
+        operationType: "destructive",
+        inputSchema: s.object("The input for RemoveQueryParameter.", {
+            siteUrl: siteUrl,
+            queryParameter: s.nonEmptyString("The URL parameter name."),
+        }),
+        outputSchema: s.object("The result of RemoveQueryParameter.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "add_country_region_settings",
+        description: "Set country or region targeting for a URL scope.",
+        operationType: "destructive",
+        inputSchema: s.object("The input for AddCountryRegionSettings.", {
+            siteUrl: siteUrl,
+            settings: countrySettingsInput,
+        }),
+        outputSchema: s.object("The result of AddCountryRegionSettings.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "remove_country_region_settings",
+        description: "Remove country or region targeting settings.",
+        operationType: "destructive",
+        inputSchema: s.object("The input for RemoveCountryRegionSettings.", {
+            siteUrl: siteUrl,
+            settings: countrySettingsInput,
+        }),
+        outputSchema: s.object("The result of RemoveCountryRegionSettings.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "submit_site_move",
+        description: "Submit a site move between source and destination URLs.",
+        operationType: "destructive",
+        inputSchema: s.object("The input for SubmitSiteMove.", {
+            siteUrl: siteUrl,
+            settings: siteMoveInput,
+        }),
+        outputSchema: s.object("The result of SubmitSiteMove.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "verify_site",
+        description: "Attempt to verify site ownership and return whether verification succeeded.",
+        operationType: "write",
+        inputSchema: s.object("The input for VerifySite.", {
+            siteUrl: siteUrl,
+        }),
+        outputSchema: s.object("The result of VerifySite.", {
+            verified: s.boolean("Whether Bing verified ownership of the site."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "add_site_roles",
+        description: "Delegate site access to a user with administrator, read-only or read-write permissions.",
+        operationType: "destructive",
+        inputSchema: s.object("The input for AddSiteRoles.", {
+            siteUrl: siteUrl,
+            delegatedUrl: s.string("The site URL whose access is delegated.", { format: "uri" }),
+            userEmail: s.string("The email of the delegated user.", { format: "email" }),
+            authenticationCode: s.nonEmptyString("The site authentication code used for delegation."),
+            isAdministrator: s.boolean("Whether to grant administrator access."),
+            isReadOnly: s.boolean("Whether to grant read-only access."),
+        }),
+        outputSchema: s.object("The result of AddSiteRoles.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+    defineProviderAction("bing_webmaster", {
+        name: "remove_site_role",
+        description: "Remove a delegated site role.",
+        operationType: "destructive",
+        inputSchema: s.object("The input for RemoveSiteRole.", {
+            siteUrl: siteUrl,
+            siteRole: siteRoleInput,
+        }),
+        outputSchema: s.object("The result of RemoveSiteRole.", {
+            success: s.boolean("Whether Bing accepted the operation."),
+        }),
+    }),
+];

package/src/providers/bing_webmaster/reporting-actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const reportingActions: readonly ActionDefinition[];