@oomol-lab/open-connector 1.9.0 → 1.9.2

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

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly IntegrationDefinition[];

package/src/providers/vercel/executors.js

@@ -1,5 +1,6 @@
 import { defineProviderExecutors, defineProviderProxy, requireApiKeyCredential } from "../provider-runtime.js";
 import { readVercelTeamScope, validateVercelCredential, vercelActionHandlers, vercelApiBaseUrl } from "./runtime.js";
+import { vercelDeploymentEvent } from "./trigger-on-deployment-event.js";
 const service = "vercel";
 const vercelProxyUserAgent = "oomol-connector/1.0 (+https://oomol.com)";
 export const executors = defineProviderExecutors({
@@ -29,3 +30,4 @@ export const credentialValidators = {
         return validateVercelCredential(input, fetcher);
     },
 };
+export const triggers = [vercelDeploymentEvent];

package/src/providers/vercel/trigger-on-deployment-event.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+export declare const vercelDeploymentEvent: IntegrationDefinition;

package/src/providers/vercel/trigger-on-deployment-event.definition.d.ts

@@ -0,0 +1,5 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const events: readonly ["deployment.ready", "deployment.error"];
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "integration";
+};

package/src/providers/vercel/trigger-on-deployment-event.definition.js

@@ -0,0 +1,41 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const events = ["deployment.ready", "deployment.error"];
+export const snapshot = {
+    key: "vercel.on_deployment_event",
+    provider: "vercel",
+    name: "on_deployment_event",
+    displayName: "Deployment Ready or Failed",
+    description: "Receives successful and failed deployments for a Vercel project.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "teamId",
+            jsonSchema: { type: "string", minLength: 1, maxLength: 256, title: "Team ID" },
+            nullable: false,
+        },
+        {
+            handle: "projectId",
+            jsonSchema: { type: "string", minLength: 1, maxLength: 256, title: "Project ID" },
+            nullable: false,
+        },
+        {
+            handle: "environment",
+            jsonSchema: { type: "string", enum: ["all", "production", "preview"], title: "Environment" },
+            nullable: false,
+            value: "all",
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string", enum: events }, nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "deploymentId", jsonSchema: s.string(), nullable: false },
+        { handle: "projectId", jsonSchema: s.string(), nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/vercel/trigger-on-deployment-event.js

@@ -0,0 +1,102 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { reconcileManagedWebhook, webhookRequest } from "../../triggers/managed-webhook.js";
+import { verifyHexHmac } from "../../triggers/signature.js";
+import { snapshot, events } from "./trigger-on-deployment-event.definition.js";
+export const vercelDeploymentEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        const query = { teamId: String(context.config.teamId) };
+        const remove = async (id) => {
+            await webhookRequest(context, { endpoint: `/v1/webhooks/${encodeURIComponent(id)}`, method: "DELETE", query });
+        };
+        return reconcileManagedWebhook(context, {
+            async find() {
+                const result = await webhookRequest(context, { endpoint: "/v1/webhooks", method: "GET", query });
+                if (!Array.isArray(result.data) ||
+                    result.data.some((item) => !isJsonObject(item) || typeof item.url != "string" || typeof item.id != "string"))
+                    throw new TransientIntegrationError("Vercel returned an invalid webhook list.");
+                const matches = result.data.filter((item) => isJsonObject(item) && item.url == context.endpointUrl);
+                if (matches.length > 1)
+                    throw new PermanentIntegrationError("Multiple Vercel webhooks match this subscription. Remove duplicates before retrying.");
+                const found = [];
+                for (const item of matches) {
+                    const id = item.id;
+                    if (item.ownerId != context.config.teamId ||
+                        !Array.isArray(item.projectIds) ||
+                        item.projectIds.length != 1 ||
+                        item.projectIds[0] != context.config.projectId ||
+                        !Array.isArray(item.events) ||
+                        item.events.length != events.length ||
+                        !events.every((event) => item.events.includes(event)))
+                        throw new PermanentIntegrationError("The Vercel webhook scope differs from this subscription. Restore its project and event settings.");
+                    const state = context.state;
+                    if (state.subscription.hookId == id && typeof state.subscription.secret == "string") {
+                        found.push({ id, secret: state.subscription.secret });
+                    }
+                    else {
+                        // Vercel only returns the secret on creation. Remove the owned orphan before recreating it.
+                        await remove(id);
+                        await state.saveSubscription({}, context.now);
+                    }
+                }
+                return found;
+            },
+            async create() {
+                const result = await webhookRequest(context, {
+                    endpoint: "/v1/webhooks",
+                    method: "POST",
+                    query,
+                    body: { url: context.endpointUrl, events: [...events], projectIds: [context.config.projectId] },
+                });
+                const data = result.data;
+                if (!isJsonObject(data) ||
+                    typeof data.id != "string" ||
+                    !data.id ||
+                    typeof data.secret != "string" ||
+                    !data.secret)
+                    throw new TransientIntegrationError("Vercel webhook creation returned no identity or secret.");
+                return { id: data.id, secret: data.secret };
+            },
+            remove,
+        });
+    },
+    async receive(context) {
+        const secret = context.state?.subscription.secret;
+        if (typeof secret != "string")
+            return { outcome: "respond", status: 503, body: "", contentType: "text/plain" };
+        if (!(await verifyHexHmac(secret, [context.rawBody], context.header("x-vercel-signature"), "SHA-1")))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const body = context.payload;
+        if (!isJsonObject(body) || typeof body.type != "string" || !events.includes(body.type))
+            return { outcome: "ignored", reason: "Vercel event does not match." };
+        const payload = body.payload;
+        if (!isJsonObject(payload) ||
+            !isJsonObject(payload.team) ||
+            payload.team.id != context.config.teamId ||
+            !isJsonObject(payload.project) ||
+            payload.project.id != context.config.projectId)
+            return { outcome: "ignored", reason: "Vercel project or Team does not match." };
+        if ((context.config.environment == "production" && payload.target != "production") ||
+            (context.config.environment == "preview" && payload.target !== null))
+            return { outcome: "ignored", reason: "Vercel environment does not match." };
+        if (typeof body.id != "string" ||
+            !body.id ||
+            !isJsonObject(payload.deployment) ||
+            typeof payload.deployment.id != "string" ||
+            !payload.deployment.id)
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: body.id,
+            outputs: {
+                event: body.type,
+                deliveryId: body.id,
+                deploymentId: payload.deployment.id,
+                projectId: payload.project.id,
+                body: payload,
+            },
+        };
+    },
+};

package/src/providers/wangdian/runtime.js

@@ -1,7 +1,7 @@
 import { Buffer } from "node:buffer";
 import { createHash } from "node:crypto";
 import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, mapProviderActionSources, ProviderRequestError, providerUserAgent, toProviderExecutionError, } from "../provider-runtime.js";
+import { createProviderTimeout, mapProviderActionSources, ProviderRequestError, providerUserAgent, toProviderExecutionError, providerInputError, } from "../provider-runtime.js";
 export const wangdianApiBaseUrl = "https://api.wangdian.cn/openapi2";
 const maximumWindowMs = 30 * 24 * 60 * 60 * 1_000;
 const maximumOrderWindowMs = 60 * 60 * 1_000;
@@ -93,7 +93,7 @@ export function readWangdianProxyParameters(body) {
         return Object.fromEntries(new URLSearchParams(body));
     const value = optionalRecord(body);
     if (!value) {
-        throw new ProviderRequestError(400, "Wangdian proxy body must be an object or form-encoded string");
+        throw providerInputError("Wangdian proxy body must be an object or form-encoded string");
     }
     return value;
 }
@@ -103,7 +103,7 @@ export function toWangdianExecutionError(error) {
 async function executeWangdianAction(actionName, input, context) {
     const config = actionConfigByName[actionName];
     if (!config)
-        throw new ProviderRequestError(400, `Unsupported Wangdian action: ${actionName}`);
+        throw providerInputError(`Unsupported Wangdian action: ${actionName}`);
     validateActionInput(actionName, input);
     const payload = await requestWangdian({
         endpoint: config.endpoint,
@@ -114,7 +114,7 @@ async function executeWangdianAction(actionName, input, context) {
     const responseRecords = payload[config.responseField];
     const records = responseRecords === undefined && config.optionalResponseList ? [] : responseRecords;
     if (!Array.isArray(records)) {
-        throw wangdianError("provider_error", `Wangdian returned an invalid ${config.responseField} response`, 502);
+        throw new ProviderRequestError(502, `Wangdian returned an invalid ${config.responseField} response`, undefined, "provider_error");
     }
     return {
         [config.outputField]: records,
@@ -175,7 +175,7 @@ function validateOptionalDateTimes(input) {
     }
 }
 function invalidInput(message) {
-    throw wangdianError("invalid_input", message, 400);
+    throw new ProviderRequestError(400, message, undefined, "invalid_input");
 }
 function hasValue(value, fields) {
     return fields.some((field) => Boolean(optionalString(value[field])));
@@ -197,7 +197,7 @@ function parseChinaDateTime(value) {
 function requireCredentialValue(value, label) {
     const normalized = optionalString(value);
     if (!normalized)
-        throw new ProviderRequestError(400, `${label} is required`);
+        throw providerInputError(`${label} is required`);
     return normalized;
 }
 function buildActionParameters(actionName, input) {
@@ -291,7 +291,7 @@ function buildActionParameters(actionName, input) {
                 ...page,
             });
         default:
-            throw new ProviderRequestError(400, `Unsupported Wangdian action: ${actionName}`);
+            throw providerInputError(`Unsupported Wangdian action: ${actionName}`);
     }
 }
 function booleanFlag(value) {
@@ -338,7 +338,7 @@ async function requestWangdian(input) {
         const root = optionalRecord(payload);
         const code = parseOptionalInteger(root?.code);
         if (!root || code === undefined) {
-            throw wangdianError("provider_error", "Wangdian returned an invalid response", 502);
+            throw new ProviderRequestError(502, "Wangdian returned an invalid response", undefined, "provider_error");
         }
         if (code !== 0)
             throw createWangdianError(200, root, input.phase);
@@ -348,9 +348,9 @@ async function requestWangdian(input) {
         if (error instanceof ProviderRequestError)
             throw error;
         if (timeout.didTimeout() || (error instanceof Error && error.name === "AbortError")) {
-            throw wangdianError("provider_error", "Wangdian request timed out", 504);
+            throw new ProviderRequestError(504, "Wangdian request timed out", undefined, "provider_error");
         }
-        throw wangdianError("provider_error", error instanceof Error ? `Wangdian request failed: ${error.message}` : "Wangdian request failed", 502);
+        throw new ProviderRequestError(502, error instanceof Error ? `Wangdian request failed: ${error.message}` : "Wangdian request failed", undefined, "provider_error");
     }
     finally {
         timeout.cleanup();
@@ -364,7 +364,7 @@ async function readWangdianPayload(response) {
         return JSON.parse(text);
     }
     catch {
-        throw wangdianError("provider_error", "Wangdian returned invalid JSON", 502);
+        throw new ProviderRequestError(502, "Wangdian returned invalid JSON", undefined, "provider_error");
     }
 }
 function createWangdianError(status, payload, phase) {
@@ -373,9 +373,9 @@ function createWangdianError(status, payload, phase) {
     const message = optionalString(root?.message) ?? `Wangdian request failed with status ${status}`;
     const lowerMessage = message.toLowerCase();
     if (status === 429)
-        return wangdianError("rate_limited", message, 429, payload);
+        return new ProviderRequestError(429, message, payload, "rate_limited");
     if (message.includes("权限不足") || message.includes("无仓库访问权限")) {
-        return wangdianError("authorization_failed", message, 403, payload);
+        return new ProviderRequestError(403, message, payload, "authorization_failed");
     }
     if (status === 401 ||
         status === 403 ||
@@ -390,15 +390,12 @@ function createWangdianError(status, payload, phase) {
         lowerMessage.includes("sign error") ||
         lowerMessage.includes("invalid sign") ||
         lowerMessage.includes("sign is")) {
-        return wangdianError(phase === "validate" ? "invalid_input" : "authorization_failed", message, phase === "validate" ? 400 : 401, payload);
+        return new ProviderRequestError(phase === "validate" ? 400 : 401, message, payload, phase === "validate" ? "invalid_input" : "authorization_failed");
     }
     if (status === 400 || status === 422 || code === 1 || code === 100 || code === 2104) {
-        return wangdianError("invalid_input", message, 400, payload);
+        return new ProviderRequestError(400, message, payload, "invalid_input");
     }
-    return wangdianError("provider_error", message, 502, payload);
-}
-function wangdianError(code, message, status, details) {
-    return new ProviderRequestError(status, message, details, code);
+    return new ProviderRequestError(502, message, payload, "provider_error");
 }
 function parseOptionalInteger(value) {
     if (value === undefined || value === null || value === "")

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

@@ -17,5 +17,4 @@ export interface WeixinRequestOptions {
 type WeixinBotActionHandler = (input: Record<string, unknown>, context: WeixinBotContext) => Promise<Record<string, unknown>>;
 export declare const weixinBotActionHandlers: ProviderActionHandlers<"weixin_bot", WeixinBotActionHandler>;
 export declare function requestWeixin(options: WeixinRequestOptions): Promise<Record<string, unknown>>;
-export declare function parseWeixinJson(text: string): unknown;
 export {};

package/src/providers/weixin_bot/runtime.js

@@ -137,7 +137,7 @@ function readTypingStatus(value) {
         return status;
     throw new ProviderRequestError(400, "status must be typing or cancel");
 }
-export function parseWeixinJson(text) {
+function parseWeixinJson(text) {
     const losslessIds = new Set(["message_id", "msg_id", "svr_id"]);
     let output = "";
     let position = 0;

package/src/providers/weixin_store/access-token.d.ts

@@ -44,9 +44,9 @@ export declare function readWechatErrcode(record: Record<string, unknown> | unde
 export declare function isWechatTokenError(errcode: number | null): boolean;
 /**
  * Map a failed WeChat API call to the shared provider error. Rate limits
- * (45009/45011) become 429, the missing-permission 48001 becomes 403, the
- * 4xxxx client errcodes and the documented invalid-input store errcodes become
- * 400, and everything else becomes a 502.
+ * and invitation quotas become 429; missing permissions and policy bans become
+ * 403; duplicate/cooperation-capacity conflicts become 409; absent promotion
+ * products become 404. Documented input errors become 400; other failures 502.
  */
 export declare function normalizeWechatApiError(result: WechatApiResult): ProviderRequestError;
 export {};

package/src/providers/weixin_store/access-token.js

@@ -12,7 +12,9 @@ const accessTokenRefreshSkewMs = 120_000;
  * input, so they map to 400 instead of an upstream failure.
  */
 const wechatInvalidInputErrcodes = new Set([
-    9401020, 9700234, 10020017, 10020059, 10020060, 10020062, 10020063, 10020087, 10020094, 10020127, 10020504,
+    9401020, 9700234, 10020017, 10020059, 10020060, 10020062, 10020063, 10020087, 10020094, 10020127, 10020504, 10021069,
+    10023000, 10023001, 10024003, 10023100, 10023102, 10023104, 10023105, 10023106, 10023107, 10023108, 10023109,
+    10023110, 10023111, 10023112, 10023113, 10023116, 10023117, 10023121,
 ]);
 const accessTokenCache = new Map();
 const accessTokenInFlight = new Map();
@@ -133,9 +135,9 @@ export function isWechatTokenError(errcode) {
 }
 /**
  * Map a failed WeChat API call to the shared provider error. Rate limits
- * (45009/45011) become 429, the missing-permission 48001 becomes 403, the
- * 4xxxx client errcodes and the documented invalid-input store errcodes become
- * 400, and everything else becomes a 502.
+ * and invitation quotas become 429; missing permissions and policy bans become
+ * 403; duplicate/cooperation-capacity conflicts become 409; absent promotion
+ * products become 404. Documented input errors become 400; other failures 502.
  */
 export function normalizeWechatApiError(result) {
     const errcode = readWechatErrcode(result.record);
@@ -147,11 +149,17 @@ export function normalizeWechatApiError(result) {
         // A bare HTTP 403 with no errcode envelope is the store's optional IP whitelist rejecting the caller.
         message = `${message}. If the store has an IP whitelist configured (微信小店后台 → 服务市场 → 经营工具 → 自研 → IP 白名单), add this runtime's public egress IP to it and try again.`;
     }
-    if (result.status === 429 || errcode === 45009 || errcode === 45011) {
+    if (result.status === 429 || errcode === 45009 || errcode === 45011 || errcode === 10020510 || errcode === 10023002) {
         return new ProviderRequestError(429, message, result.record);
     }
-    if (errcode === 48001) {
-        return new ProviderRequestError(403, message, result.record);
+    if (errcode === 48001 || errcode === 10023007 || errcode === 10023114 || errcode === 10023115) {
+        return new ProviderRequestError(403, message, result.record, "provider_error");
+    }
+    if (errcode === 10023003 || errcode === 10023004 || errcode === 10023006) {
+        return new ProviderRequestError(409, message, result.record);
+    }
+    if (errcode === 10023103) {
+        return new ProviderRequestError(404, message, result.record);
     }
     if (errcode !== null && ((errcode >= 40000 && errcode < 50000) || wechatInvalidInputErrcodes.has(errcode))) {
         return new ProviderRequestError(400, message, result.record);

package/src/providers/weixin_store/executors.js

@@ -1,4 +1,4 @@
-import { compactObject, objectArray, optionalBoolean, optionalInteger, optionalRecord, optionalString, positiveInteger, } from "../../core/cast.js";
+import { compactObject, objectArray, optionalBoolean, optionalInteger, optionalNumber, optionalRecord, optionalString, positiveInteger, } from "../../core/cast.js";
 import { createProviderFetch, defineProviderExecutors, providerInputError, providerUserAgent, readTransitFileInput, requireCustomCredential, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
 import { getWechatAccessToken, isWechatTokenError, normalizeWechatApiError, parseWechatJson, readWechatErrcode, readWeixinStoreCredential, } from "./access-token.js";
 const service = "weixin_store";
@@ -35,6 +35,219 @@ const deliveryProductFieldMap = {
     productCnt: "product_cnt",
 };
 const weixinStoreActionHandlers = {
+    async list_league_promoter_products(input, context) {
+        const talentAppid = requiredInputString(input.talentAppid, "talentAppid");
+        const dataType = positiveInteger(input.dataType, "dataType", providerInputError);
+        const pageIndex = positiveInteger(input.pageIndex ?? 1, "pageIndex", providerInputError);
+        const pageSize = positiveInteger(input.pageSize ?? 20, "pageSize", providerInputError);
+        if (![1, 2].includes(dataType) || !Number.isSafeInteger(pageIndex) || pageSize > 20) {
+            throw providerInputError("dataType must be 1 or 2, pageIndex a safe positive integer, and pageSize at most 20");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/talent/getproductdatalist",
+            body: { talent_appid: talentAppid, get_data_type: dataType, page_index: pageIndex, page_size: pageSize },
+        });
+    },
+    async list_product_promotion_talents(input, context) {
+        const productId = positiveInteger(input.productId, "productId", providerInputError);
+        const promotionPlanId = positiveInteger(input.promotionPlanId, "promotionPlanId", providerInputError);
+        const pageIndex = positiveInteger(input.pageIndex ?? 1, "pageIndex", providerInputError);
+        const pageSize = positiveInteger(input.pageSize ?? 10, "pageSize", providerInputError);
+        if (![productId, promotionPlanId, pageIndex].every(Number.isSafeInteger) || pageSize > 10) {
+            throw providerInputError("Ids and pageIndex must be safe positive integers; pageSize must be at most 10");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/promotion/talent/list",
+            body: compactObject({
+                product_id: productId,
+                promotion_plan_id: promotionPlanId,
+                page_index: pageIndex,
+                page_size: pageSize,
+                talent_appid: input.talentAppid === undefined ? undefined : requiredInputString(input.talentAppid, "talentAppid"),
+            }),
+        });
+    },
+    get_product_audit_strategy(_input, context) {
+        return callWechatApi(context, { method: "POST", path: "/channels/ec/product/auditstrategy/get", body: {} });
+    },
+    async list_product_promotion_plans(input, context) {
+        const productId = positiveInteger(input.productId, "productId", providerInputError);
+        const pageIndex = positiveInteger(input.pageIndex ?? 1, "pageIndex", providerInputError);
+        const pageSize = positiveInteger(input.pageSize ?? 20, "pageSize", providerInputError);
+        const type = input.promotionPlanType === undefined
+            ? undefined
+            : positiveInteger(input.promotionPlanType, "promotionPlanType", providerInputError);
+        if (![productId, pageIndex].every(Number.isSafeInteger) ||
+            pageSize > 20 ||
+            (type !== undefined && ![100, 200, 300].includes(type))) {
+            throw providerInputError("Ids and pageIndex must be safe positive integers, pageSize at most 20, and promotionPlanType 100, 200 or 300");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/promotion/plan/list",
+            body: compactObject({
+                product_id: productId,
+                page_index: pageIndex,
+                page_size: pageSize,
+                promotion_plan_type: type,
+            }),
+        });
+    },
+    async list_league_products(input, context) {
+        const pageIndex = positiveInteger(input.pageIndex ?? 1, "pageIndex", providerInputError);
+        const pageSize = positiveInteger(input.pageSize ?? 20, "pageSize", providerInputError);
+        const productId = input.productId === undefined ? undefined : positiveInteger(input.productId, "productId", providerInputError);
+        if (!Number.isSafeInteger(pageIndex) ||
+            pageSize > 100 ||
+            pageSize * pageIndex > 5000 ||
+            (productId !== undefined && !Number.isSafeInteger(productId))) {
+            throw providerInputError("Product id must be safe, pageSize at most 100, and pageSize multiplied by pageIndex at most 5000");
+        }
+        if (input.needTotalNum !== undefined && typeof input.needTotalNum !== "boolean") {
+            throw providerInputError("needTotalNum must be a boolean");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/item/list/get",
+            body: compactObject({
+                page_index: pageIndex,
+                page_size: pageSize,
+                product_id: productId,
+                need_total_num: input.needTotalNum,
+            }),
+        });
+    },
+    async get_league_plan(input, context) {
+        const type = positiveInteger(input.type, "type", providerInputError);
+        const productId = positiveInteger(input.productId, "productId", providerInputError);
+        const promotionPlanId = input.promotionPlanId === undefined
+            ? undefined
+            : positiveInteger(input.promotionPlanId, "promotionPlanId", providerInputError);
+        if (![100, 300].includes(type) ||
+            !Number.isSafeInteger(productId) ||
+            (promotionPlanId !== undefined && !Number.isSafeInteger(promotionPlanId))) {
+            throw providerInputError("type must be 100 or 300 and ids must be safe positive integers");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/item/get",
+            body: compactObject({ type, product_id: productId, promotion_plan_id: promotionPlanId }),
+        });
+    },
+    async invite_league_promoter(input, context) {
+        if ((input.promoterId !== undefined) === (input.finderId !== undefined)) {
+            throw providerInputError("Supply exactly one of promoterId or finderId");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/promoter/add",
+            body: input.promoterId !== undefined
+                ? { promoter_id: requiredInputString(input.promoterId, "promoterId") }
+                : { finder_id: requiredInputString(input.finderId, "finderId") },
+        });
+    },
+    async update_league_plan(input, context) {
+        const type = positiveInteger(input.type, "type", providerInputError);
+        const productId = positiveInteger(input.productId, "productId", providerInputError);
+        const promotionPlanId = positiveInteger(input.promotionPlanId, "promotionPlanId", providerInputError);
+        const operateType = positiveInteger(input.operateType, "operateType", providerInputError);
+        if (![100, 300].includes(type) ||
+            ![productId, promotionPlanId].every(Number.isSafeInteger) ||
+            ![1, 2, 4].includes(operateType)) {
+            throw providerInputError("type must be 100 or 300, ids safe positive integers, and operateType 1, 2 or 4");
+        }
+        const ratio = optionalNumber(input.ratio);
+        if (operateType === 1
+            ? ratio === undefined || !Number.isFinite(ratio) || ratio < 0 || ratio > 90
+            : input.ratio !== undefined) {
+            throw providerInputError("ratio must be between 0 and 90 for operateType 1 and omitted for operateType 2 or 4");
+        }
+        if (input.exclusiveInfo !== undefined || input.exclusive_info !== undefined) {
+            throw providerInputError("Audience and timing edits are not supported by this action");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/item/upd",
+            body: compactObject({
+                type,
+                product_id: productId,
+                promotion_plan_id: promotionPlanId,
+                operate_type: operateType,
+                ratio,
+            }),
+        });
+    },
+    async list_league_promoters(input, context) {
+        const pageIndex = positiveInteger(input.pageIndex ?? 1, "pageIndex", providerInputError);
+        const pageSize = positiveInteger(input.pageSize ?? 20, "pageSize", providerInputError);
+        if (!Number.isSafeInteger(pageIndex) || pageSize > 20) {
+            throw providerInputError("pageIndex must be a safe positive integer and pageSize must be at most 20");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/promoter/list/get",
+            body: { page_index: pageIndex, page_size: pageSize },
+        });
+    },
+    async get_league_promoter(input, context) {
+        if ((input.talentAppid !== undefined) === (input.talentSearchKey !== undefined)) {
+            throw providerInputError("Supply exactly one of talentAppid or talentSearchKey");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/league/promoter/get",
+            body: input.talentAppid !== undefined
+                ? { talent_appid: requiredInputString(input.talentAppid, "talentAppid") }
+                : { talent_search_key: requiredInputString(input.talentSearchKey, "talentSearchKey") },
+        });
+    },
+    async get_compass_product_data(input, context) {
+        const date = requiredInputString(input.date, "date");
+        const parsed = /^\d{8}$/.test(date)
+            ? new Date(`${date.slice(0, 4)}-${date.slice(4, 6)}-${date.slice(6, 8)}T00:00:00Z`)
+            : new Date(Number.NaN);
+        const today = new Intl.DateTimeFormat("en-CA", {
+            timeZone: "Asia/Shanghai",
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+        })
+            .format(new Date())
+            .replaceAll("-", "");
+        if (!Number.isFinite(parsed.getTime()) ||
+            parsed.toISOString().slice(0, 10).replaceAll("-", "") !== date ||
+            date >= today) {
+            throw providerInputError("date must be a valid YYYYMMDD date, yesterday or earlier in Asia/Shanghai");
+        }
+        const productId = positiveInteger(input.productId, "productId", providerInputError);
+        if (!Number.isSafeInteger(productId)) {
+            throw providerInputError("productId must be a safe positive integer");
+        }
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/compass/shop/product/data/get",
+            body: { ds: date, product_id: productId },
+        });
+    },
+    async get_product_restricted_info(input, context) {
+        if (!Array.isArray(input.productIds) || input.productIds.length < 1 || input.productIds.length > 50) {
+            throw providerInputError("productIds must contain 1 to 50 product ids");
+        }
+        const productIds = input.productIds.map((value) => {
+            const id = positiveInteger(value, "productIds", providerInputError);
+            if (!Number.isSafeInteger(id)) {
+                throw providerInputError("productIds must contain only safe positive integers");
+            }
+            return id;
+        });
+        return callWechatApi(context, {
+            method: "POST",
+            path: "/channels/ec/product/getproductrestrictedinfo",
+            body: { product_ids: productIds },
+        });
+    },
     async upload_qualification_image(input, context) {
         const file = await readTransitFileInput(input.file, context);
         if (file.sizeBytes > 2 * 1024 * 1024) {

package/src/providers/weread/actions.d.ts

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