@wix/agent-skills 1.35.1 → 1.36.1

package/skills/wix-vibe-headless/references/pricing-plans/app/rest/wix-pricing-plans.js

@@ -1,157 +0,0 @@
-import { wixApiRequest } from "./wix-client.js";
-
-/**
- * Wix Pricing Plans V3 Plan — key fields for a Plans & Pricing page.
- * Full model: https://dev.wix.com/docs/api-reference/business-solutions/pricing-plans/plans-v3/plan-object.md
- *
- *   id {string}, name {string}, description {string}, slug {string},
- *   image {object} — { id, width, height, altText } (id is a WixMedia id),
- *   currency {string} — ISO-4217 e.g. "USD", termsAndConditions {string},
- *   visibility "PUBLIC"|"PRIVATE" — queryPlans returns PUBLIC only,
- *   buyable {boolean} — hide buy button when false, buyerCanCancel {boolean},
- *   perks {array} — [{ id, description }] feature bullets,
- *   pricingVariants {array} — 1 variant per plan:
- *     [{ id, name, freeTrialDays, pricingStrategies[0].flatRate.amount (decimal string, "0" = free),
- *        billingTerms: { billingCycle: { period "DAY"|"WEEK"|"MONTH"|"YEAR", count },
- *        startType "ON_PURCHASE"|"CUSTOM", endType "UNTIL_CANCELLED"|"CYCLES_COMPLETED" } }]
- * Display price: amount = v.pricingStrategies[0].flatRate.amount + plan.currency.
- * Never compute a final charge — Wix settles price, tax, and schedule at hosted checkout.
- *
- * Order (member's purchase) — key fields for "My plans" screen.
- * Full model: https://dev.wix.com/docs/api-reference/business-solutions/pricing-plans/orders/order-object.md
- *   id {string}, planId {string}, planName {string},
- *   status "DRAFT"|"PENDING"|"ACTIVE"|"PAUSED"|"ENDED"|"CANCELED",
- *   lastPaymentStatus "PAID"|"REFUNDED"|"FAILED"|"UNPAID"|"NOT_APPLICABLE",
- *   startDate {string}, endDate {string}, freeTrialDays {number},
- *   currentCycle { index, startedDate, endedDate }, autoRenewCanceled {boolean}
- */
-
-const REDIRECT_SESSION_URL = "/headless/v1/redirect-session";
-
-/**
- * Query public, listable pricing plans (one page).
- * Returns only PUBLIC plans (the ones meant for the Plans & Pricing page). Some plans may have
- * `buyable: false` (merchant-assigned only) — keep them for display but hide the buy button.
- *
- * Reference: https://dev.wix.com/docs/api-reference/business-solutions/pricing-plans/plans-v3/query-plans.md
- *
- * @param {{ limit?: number, cursor?: string }} [options]
- * @returns {Promise<{ plans: object[], nextCursor: string|null }>}
- */
-export async function queryPlans({ limit = 100, cursor } = {}) {
-  const res = await wixApiRequest("/pricing-plans/v3/plans/query", {
-    method: "POST",
-    body: {
-      query: {
-        ...(cursor ? {} : { filter: { visibility: "PUBLIC" } }),
-        cursorPaging: cursor ? { limit, cursor } : { limit },
-      },
-    },
-  });
-  return {
-    plans: res?.plans ?? [],
-    nextCursor: res?.pagingMetadata?.cursors?.next ?? null,
-  };
-}
-
-/**
- * Fetch a single plan by its GUID. Returns null if not found.
- * Reference: https://dev.wix.com/docs/api-reference/business-solutions/pricing-plans/plans-v3/get-plan.md
- *
- * @param {string} planId  Plan GUID (`plan.id`).
- * @returns {Promise<object|null>}
- */
-export async function getPlanById(planId) {
-  try {
-    const res = await wixApiRequest(`/pricing-plans/v3/plans/${encodeURIComponent(planId)}`, {
-      method: "GET",
-    });
-    return res?.plan ?? null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Fetch a single PUBLIC plan by its URL slug. Returns null if not found.
- * There is no get-by-slug endpoint, so this queries with a slug filter and returns the first match.
- * Reference: https://dev.wix.com/docs/api-reference/business-solutions/pricing-plans/plans-v3/query-plans.md
- *
- * @param {string} slug
- * @returns {Promise<object|null>}
- */
-export async function getPlanBySlug(slug) {
-  const res = await wixApiRequest("/pricing-plans/v3/plans/query", {
-    method: "POST",
-    body: {
-      query: {
-        filter: { visibility: "PUBLIC", slug },
-        cursorPaging: { limit: 1 },
-      },
-    },
-  });
-  return res?.plans?.[0] ?? null;
-}
-
-/**
- * Start a purchase for a plan and return the Wix-hosted checkout URL.
- *
- * Pricing Plans purchases are MEMBERS-ONLY: the hosted flow handles member login (or signup),
- * the order form, and payment, then returns the visitor to your site. Redirect the browser to the
- * returned URL — do NOT create the order yourself; Wix settles price, tax, and the subscription.
- *
- * On return:
- *   - postFlowUrl is hit when the flow completes, is abandoned, or is interrupted.
- *   - thankYouPageUrl (if given) is hit only on success, with a `?planOrderId=<GUID>` query param.
- *   - Both callbacks also carry `wixMemberLoggedIn` (true if a member logged in during the flow).
- * After a successful purchase the visitor is a logged-in member — call getMyPlanOrders() to confirm.
- *
- * Reference: https://dev.wix.com/docs/api-reference/business-management/headless/redirects/create-redirect-session.md
- *
- * @param {string} planId  Plan GUID (`plan.id`). Must be a buyable plan.
- * @param {{ thankYouPageUrl?: string, postFlowUrl?: string }} [options]
- * @returns {Promise<string>} The hosted checkout URL to redirect to.
- */
-export async function checkout(planId, { thankYouPageUrl, postFlowUrl } = {}) {
-  if (!planId) throw new Error("Cannot check out: a planId is required.");
-  const callbacks = { postFlowUrl: postFlowUrl ?? window.location.href };
-  if (thankYouPageUrl) callbacks.thankYouPageUrl = thankYouPageUrl;
-
-  const redirect = await wixApiRequest(REDIRECT_SESSION_URL, {
-    method: "POST",
-    body: { paidPlansCheckout: { planId }, callbacks },
-  });
-  const url = redirect?.redirectSession?.fullUrl;
-  if (!url) throw new Error("Failed to create the pricing-plan checkout redirect session.");
-  return url;
-}
-
-/**
- * List the currently logged-in member's own plan orders (their purchases / subscriptions).
- * Use for a "My plans" screen and to confirm a purchase after returning from checkout.
- *
- * Requires a MEMBER identity. For an anonymous visitor (not logged in) Wix returns no member
- * context — this resolves to `[]` rather than throwing, so the UI can show a "log in to see your
- * plans" state. Up to 50 orders are returned per call.
- *
- * Reference: https://dev.wix.com/docs/api-reference/business-solutions/pricing-plans/orders/member-orders-service-list-orders.md
- *
- * @param {{ orderStatuses?: string[], limit?: number, offset?: number }} [options]
- *        orderStatuses: filter, e.g. ["ACTIVE"] | ["ACTIVE","PENDING","PAUSED"].
- * @returns {Promise<object[]>} The member's orders (empty array if none / not a member).
- */
-export async function getMyPlanOrders({ orderStatuses, limit, offset } = {}) {
-  try {
-    const res = await wixApiRequest("/pricing-plans/v2/member/orders", {
-      method: "GET",
-      query: {
-        orderStatuses,
-        limit: limit !== undefined ? String(limit) : undefined,
-        offset: offset !== undefined ? String(offset) : undefined,
-      },
-    });
-    return res?.orders ?? [];
-  } catch {
-    return [];
-  }
-}

package/skills/wix-vibe-headless/references/pricing-plans/seed/SEED.md

@@ -1,82 +0,0 @@
-# Pricing Plans — seeding
-
-Seed Wix Pricing Plans (Plans V3) by **calling `seed-pricing-plans.cjs`** — don't hand-write the
-REST calls. It's a build-time module (run via `exec_tool`, not shipped in the app) that abstracts
-every Pricing Plans + Benefit Programs seed operation. `require` it and call the functions with
-plain data.
-
-> **NOT yet live-verified — transcribed from `setup-pricing-plans.md`.**
-
-```js
-// build-time exec_tool
-const { accessToken } = await base44.asServiceRole.connectors.getConnection("wix");
-const seed = require(require("path").resolve(".agents/skills/wix-vibe-headless/references/pricing-plans/seed/seed-pricing-plans.cjs"));
-const ctx = { token: accessToken, siteId: WIX_METASITE_ID };
-
-// setupPricingPlans installs the Wix Pricing Plans app first (idempotent) — base44 sites may not have it.
-
-// DEFAULT: one call. Creates the plan(s), keeps their ids in memory, and (per plan) wires bookings
-// coverage when provided — createPlans then attachBookingsCoverage (2a→2b→2c), in order.
-const { plans, coverageAttached, benefitsCreated } = await seed.setupPricingPlans(ctx, {
-  plans: [
-    { name: "Studio Membership", description: "Unlimited group classes.", price: "20.00",
-      type: "recurring", billingCycle: { period: "MONTH", count: 1 },
-      perks: ["Unlimited group classes", "10% off workshops"],
-      coveredServiceIds: bookingsServiceIds },  // optional — only when this plan covers bookings services
-    // …just the plan data. price = decimal STRING; currency is site-derived (don't send it).
-    // limited pack instead of unlimited: bookingsCoverage: { serviceIds, creditAmount: 8 }
-  ],
-});
-// A plans-only run (no bookings) just omits coveredServiceIds — STEP 2 is skipped automatically.
-```
-
-**Seeding is additive — never delete or overwrite existing content.** Don't clean up, don't remove
-"sample" data, don't reset. Just add.
-
-## Escape hatch — individual functions
-Reach for the functions below only when the one-call `setupPricingPlans` doesn't fit (custom coverage,
-step-by-step control). `setupPricingPlans` is built from them, in this order:
-
-```js
-const plans = await seed.createPlans(ctx, [
-  { name: "Studio Membership", price: "20.00", perks: ["Unlimited group classes"],
-    coveredServiceIds: bookingsServiceIds },
-]);
-// STEP 2 — only when bookings is in the run AND the plan covers services (skip otherwise):
-await seed.attachBookingsCoverage(ctx, plans[0].id, plans[0].coveredServiceIds);
-// limited pack instead of unlimited: attachBookingsCoverage(ctx, id, ids, { creditAmount: 8 })
-```
-
-## Functions
-| fn | does |
-|---|---|
-| `setupPricingPlans(ctx, {plans})` | **DEFAULT** one call: createPlans → per-plan attachBookingsCoverage → `{plans,coverageAttached,benefitsCreated}` |
-| `createPlans(ctx, plans)` | one create call per plan (V3 has no bulk) → `[{id,name,coveredServiceIds}]` |
-| `attachBookingsCoverage(ctx, planId, serviceIds, {creditAmount?})` | STEP 2: 2a→2b→2c in order → `{itemSetId,serviceIds}` |
-| `getProgramDefinition(ctx, planId)` | 2a: READ the auto-created program definition (retry-once on 404) → `programDefinitionId` |
-| `createPoolDefinition(ctx, programDefinitionId, {creditAmount?})` | 2b: one pool + one Bookings benefit → `itemSetId` |
-| `createBenefitItems(ctx, itemSetId, serviceIds)` | 2c: bulk-create one benefit item per covered service |
-
-Plan `type`: `"recurring"` (default; `billingCycle` defaults to `{MONTH,1}`), `"one-time"`
-(bills once then ends; pass `billingCycle: null` for the unlimited one-time), or `"free"`
-(amount forced to `"0"` + a per-member-lifetime purchase limit). Amounts are decimal **strings**;
-`perks` are display-only bullets; plans default to `visibility: "PUBLIC"` + `buyable: true`.
-
-## Bookings-first dependency
-STEP 2 attaches **bookings service ids** to a plan through the Benefit Programs API (the coverage
-is NOT a plan field or a perk). Those ids come from the **bookings seed**
-(`seeded.bookings.serviceIds[]`), so **seed bookings before pricing-plans** and pass the ids in as
-`coveredServiceIds`. A plans-only run (no bookings) stops after `createPlans` — skip STEP 2 entirely.
-
-## Reference
-If a call returns a shape you didn't expect, or you need an operation this module doesn't cover,
-use the documentation skill available in your environment to search + read the live Wix API reference — never guess. The
-authoritative source recipe is `wix-headless/references/inline-recipes/setup-pricing-plans.md`.
-
-Read a method's page before writing its call: it carries the exact body shape, the required
-permission scope, and the response envelope.
-- Install a Wix app onto the site: https://dev.wix.com/docs/api-reference/business-management/app-installation/app-installation/install-app.md
-- Create Plan: https://dev.wix.com/docs/api-reference/business-solutions/pricing-plans/plans-v3/create-plan.md
-- Create Pool Definition (benefits): https://dev.wix.com/docs/api-reference/business-solutions/benefit-programs/pool-definitions/create-pool-definition.md
-- Bulk Create Items (benefits): https://dev.wix.com/docs/api-reference/business-solutions/benefit-programs/items/bulk-create-items.md
-- Get Program Definition By External Id And Namespace: https://dev.wix.com/docs/api-reference/business-solutions/benefit-programs/program-definitions/get-program-definition-by-external-id-and-namespace.md

package/skills/wix-vibe-headless/references/pricing-plans/seed/seed-pricing-plans.cjs

@@ -1,251 +0,0 @@
-// Pricing-Plans seed helpers — run at BUILD TIME via exec_tool (NOT shipped in the app).
-// The agent requires this and calls the functions with plain data; all Wix Pricing Plans (V3)
-// + Benefit Programs request/response mechanics (the client-supplied GUID rule, the string-amount
-// rule, the three ordered coverage sub-steps, the @wix/pricing-plans namespace) live here, once.
-//
-// **NOT yet live-verified — transcribed from setup-pricing-plans.md.**
-//
-// Usage (build-time exec_tool):
-//   const { accessToken } = await base44.asServiceRole.connectors.getConnection("wix");  // Base44
-//   const seed = require("/app/.agents/skills/wix-vibe-headless/references/pricing-plans/seed/seed-pricing-plans.cjs");
-//   const ctx = { token: accessToken, siteId: WIX_METASITE_ID };
-//
-//   // Bookings is seeded FIRST — its service ids feed a plan's coverage (see SEED.md).
-//   const plans = await seed.createPlans(ctx, [
-//     { name: "Studio Membership", description: "Unlimited group classes.", price: "20.00",
-//       type: "recurring", billingCycle: { period: "MONTH", count: 1 },
-//       perks: ["Unlimited group classes", "10% off workshops"],
-//       coveredServiceIds: bookingsServiceIds },   // optional — only when this plan covers bookings
-//   ]);
-//   // Then, per plan that covers bookings services (STEP 2; skip entirely with no bookings):
-//   await seed.attachBookingsCoverage(ctx, plans[0].id, plans[0].coveredServiceIds);
-//
-// If any call fails with a shape the caller didn't expect, fall back to the documentation skill available in your environment
-// (search + read the live Wix API reference) — never guess. Source recipe (authoritative):
-// wix-headless/references/inline-recipes/setup-pricing-plans.md.
-
-const { randomUUID } = require("crypto");
-
-const API = "https://www.wixapis.com";
-const BOOKINGS_APP_ID = "13d21c63-b5ec-5912-8397-c3a5ddb27a97"; // per recipe: providerAppId for coverage
-const PRICING_PLANS_APP_ID = "1522827f-c56c-a5c9-2ac9-00f9e6ae12d3"; // installPricingPlansApp installs this before seeding
-const PP_NAMESPACE = "@wix/pricing-plans"; // per recipe: literal, with @ and slash, in every 2a–2c call
-
-async function req(ctx, path, { method = "POST", body } = {}) {
-  const res = await fetch(API + path, {
-    method,
-    headers: {
-      Authorization: `Bearer ${ctx.token}`,
-      "wix-site-id": ctx.siteId,
-      "Content-Type": "application/json",
-    },
-    body: body ? JSON.stringify(body) : undefined,
-  });
-  const json = await res.json().catch(() => ({}));
-  if (!res.ok) throw new Error(`${method} ${path} -> ${res.status}: ${JSON.stringify(json).slice(0, 400)}`);
-  return json;
-}
-
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-
-// [ "text" | { description } ] -> Wix perks[]; each gets a fresh client-supplied GUID (required).
-function buildPerks(perks = []) {
-  return perks.map((p) => ({
-    id: randomUUID(),
-    description: typeof p === "string" ? p : p.description,
-  }));
-}
-
-// billingTerms selects the plan type (recurring | one-time | free). Amounts are decimal STRINGS.
-// recurring: billingCycle {period,count} (default MONTH/1) + startType ON_PURCHASE + endType UNTIL_CANCELLED.
-// one-time:  endType CYCLES_COMPLETED + cyclesCompletedDetails {billingCycleCount:1} (bill once, then ends);
-//            an unlimited one-time instead sets billingCycle:null + endType UNTIL_CANCELLED.
-function buildBillingTerms(plan) {
-  const type = plan.type || "recurring";
-  if (type === "one-time") {
-    if (plan.billingCycle === null) {
-      return { billingCycle: null, startType: "ON_PURCHASE", endType: "UNTIL_CANCELLED" };
-    }
-    const cycle = plan.billingCycle || { period: "MONTH", count: 1 };
-    return {
-      billingCycle: cycle,
-      startType: "ON_PURCHASE",
-      endType: "CYCLES_COMPLETED",
-      cyclesCompletedDetails: { billingCycleCount: 1 },
-    };
-  }
-  // recurring (also the shape a free plan rides on)
-  const cycle = plan.billingCycle || { period: "MONTH", count: 1 };
-  return { billingCycle: cycle, startType: "ON_PURCHASE", endType: "UNTIL_CANCELLED" };
-}
-
-// one pricingVariant with one pricingStrategy (schema allows ≤20 but is "currently limited to 1").
-function buildPricingVariant(plan) {
-  const free = (plan.type || "recurring") === "free";
-  const amount = free ? "0" : String(plan.price);
-  return {
-    id: randomUUID(), // required, client-supplied GUID — never model-typed
-    name: plan.variantName || "Standard",
-    billingTerms: buildBillingTerms(plan),
-    pricingStrategies: [{ flatRate: { amount } }],
-  };
-}
-
-// ---- exported operations ----
-
-/**
- * Create the plan(s). Plans V3 has NO bulk-create — one create call per plan.
- * @param plans [{ name, description?, price,           // price = decimal string ("20.00"); ignored for free
- *   type?: "recurring"|"one-time"|"free",              // default "recurring"
- *   billingCycle?: { period: "DAY"|"WEEK"|"MONTH"|"YEAR", count } | null,  // default { MONTH, 1 }
- *   perks?: ["..."] | [{ description }],               // display-only bullets (no functional effect)
- *   visibility?, buyable?,                             // default "PUBLIC" / true (public + orderable)
- *   coveredServiceIds? }]                              // metadata for attachBookingsCoverage; not sent here
- * @returns [{ id, name, coveredServiceIds }]  (id = plan.id — orders by it AND is the coverage externalId)
- */
-async function createPlans(ctx, plans) {
-  const out = [];
-  for (const plan of plans) {
-    const free = (plan.type || "recurring") === "free";
-    const body = {
-      plan: {
-        name: plan.name,
-        description: plan.description,
-        status: "ACTIVE", // REQUIRED — omitting returns 400 "status value is required"
-        visibility: plan.visibility || "PUBLIC",
-        buyable: plan.buyable ?? true,
-        buyerCanCancel: plan.buyerCanCancel ?? true,
-        pricingVariants: [buildPricingVariant(plan)],
-        perks: buildPerks(plan.perks),
-        // free: cap lifetime reuse (older maxPurchasesPerBuyer is deprecated — prefer purchaseLimits)
-        ...(free ? { purchaseLimits: { type: "PER_MEMBER_LIFETIME", count: 1 } } : {}),
-      },
-    };
-    const r = await req(ctx, "/pricing-plans/v3/plans", { body });
-    out.push({ id: r.plan?.id, name: plan.name, coveredServiceIds: plan.coveredServiceIds });
-  }
-  return out;
-}
-
-// ---- STEP 2: bookings coverage via Benefit Programs API (SKIP when no bookings in the run) ----
-// Strictly ordered: plan.id -> programDefinition.id -> itemSetId -> items. Do NOT parallelize.
-
-// 2a: READ the auto-created program definition (the Plans app creates it; you never create it).
-// Provisioning is ~immediate but async — retry ONCE after a short backoff on 404/empty, don't loop.
-async function getProgramDefinition(ctx, planId) {
-  const path = `/benefit-programs/v1/program-definitions/by-namespace-and-external-id?externalId=${planId}&namespace=${encodeURIComponent(PP_NAMESPACE)}`;
-  try {
-    const r = await req(ctx, path, { method: "GET" });
-    if (r.programDefinition?.id) return r.programDefinition.id;
-  } catch {
-    // fall through to the single insurance retry
-  }
-  await sleep(1000);
-  const r = await req(ctx, path, { method: "GET" });
-  return r.programDefinition?.id;
-}
-
-// 2b: create ONE pool definition with EXACTLY ONE benefit naming Bookings as the provider.
-// price "0" = unlimited (default; no creditConfiguration). Limited pack: pass creditAmount ->
-// price "1" + details.creditConfiguration (SIBLING of benefits[], NOT inside a benefit).
-async function createPoolDefinition(ctx, programDefinitionId, { creditAmount } = {}) {
-  const limited = creditAmount != null;
-  const details = {
-    ...(limited ? { creditConfiguration: { amount: String(creditAmount) } } : {}),
-    benefits: [
-      {
-        benefitKey: randomUUID(), // freshly generated random UUID you supply
-        displayName: "Bookings sessions",
-        providerAppId: BOOKINGS_APP_ID,
-        price: limited ? "1" : "0",
-      },
-    ],
-  };
-  const r = await req(ctx, "/benefit-programs/v1/pool-definitions", {
-    body: {
-      poolDefinition: {
-        namespace: PP_NAMESPACE,
-        displayName: "Bookings benefit",
-        programDefinitionIds: [programDefinitionId],
-        details,
-      },
-      cascade: "IMMEDIATELY",
-    },
-  });
-  // itemSetId lives at poolDefinition.details.benefits[i].itemSetId — one benefit here, so [0].
-  return r.poolDefinition?.details?.benefits?.[0]?.itemSetId;
-}
-
-// 2c: bulk-create the benefit items — ONE item per covered service (externalId = bookings service id).
-// Up to 100 items per call; category is an empty string; namespace/providerAppId repeat 2b's values.
-async function createBenefitItems(ctx, itemSetId, serviceIds) {
-  return req(ctx, "/benefit-programs/v1/bulk/items/create", {
-    body: {
-      items: serviceIds.map((externalId) => ({
-        namespace: PP_NAMESPACE,
-        category: "",
-        providerAppId: BOOKINGS_APP_ID,
-        itemSetId,
-        externalId,
-      })),
-      returnEntity: true,
-    },
-  });
-}
-
-/**
- * Wire a plan to COVER bookings services (STEP 2, per plan). Runs 2a -> 2b -> 2c in order.
- * @param planId          plan.id from createPlans
- * @param serviceIds      bookings service ids (seeded.bookings.serviceIds[]) the plan should cover
- * @param creditAmount?   session-count for a limited pack; omit for the default unlimited ("0") case
- * @returns { itemSetId, serviceIds }  — keep as seed-time linkage (bookingsCoverage[planId])
- */
-async function attachBookingsCoverage(ctx, planId, serviceIds, { creditAmount } = {}) {
-  const programDefinitionId = await getProgramDefinition(ctx, planId);
-  const itemSetId = await createPoolDefinition(ctx, programDefinitionId, { creditAmount });
-  await createBenefitItems(ctx, itemSetId, serviceIds);
-  return { itemSetId, serviceIds };
-}
-
-/**
- * DEFAULT one-call path — create plan(s) and, per plan, wire bookings coverage when provided.
- * One call; created plan ids stay in memory so coverage never needs hand-threading of plan.id.
- * Order: createPlans (all plans) -> per covering plan attachBookingsCoverage (2a->2b->2c, in order).
- * The program definition is provisioned asynchronously ~1s after the plan; the retry-once-after-
- * backoff on its 404 lives in getProgramDefinition and is preserved via attachBookingsCoverage.
- * @param plan { plans: [{ ...createPlans fields (name, description?, price, type?, billingCycle?,
- *   perks?, visibility?, buyable?),
- *   coveredServiceIds?,                                    // bookings service ids this plan covers
- *   bookingsCoverage?: { serviceIds?, creditAmount? } }] } // richer coverage; creditAmount = limited pack
- * @returns { plans: [{id,name,coveredServiceIds}], coverageAttached: [{planId,itemSetId,serviceIds}], benefitsCreated }
- */
-// Install the Wix Pricing Plans app before seeding — base44 sites aren't guaranteed to have it (no
-// separate Setup step here, unlike the wix-headless recipe). Idempotent: re-installing returns 200.
-async function installPricingPlansApp(ctx) {
-  return req(ctx, "/apps-installer-service/v1/app-instance/install", { body: {
-    tenant: { tenantType: "SITE", id: ctx.siteId },
-    appInstance: { appDefId: PRICING_PLANS_APP_ID, enabled: true },
-  } });
-}
-
-async function setupPricingPlans(ctx, { plans = [] } = {}) {
-  await installPricingPlansApp(ctx);
-  const created = await createPlans(ctx, plans); // ids kept in memory
-  const coverageAttached = [];
-  for (let i = 0; i < created.length; i++) {
-    const cov = plans[i].bookingsCoverage || {};
-    const serviceIds = cov.serviceIds || created[i].coveredServiceIds;
-    if (!serviceIds?.length) continue; // plans-only plan — skip STEP 2
-    const r = await attachBookingsCoverage(ctx, created[i].id, serviceIds, { creditAmount: cov.creditAmount });
-    coverageAttached.push({ planId: created[i].id, ...r });
-  }
-  const benefitsCreated = coverageAttached.reduce((n, c) => n + c.serviceIds.length, 0);
-  return { plans: created, coverageAttached, benefitsCreated };
-}
-
-module.exports = {
-  setupPricingPlans, installPricingPlansApp,
-  createPlans,
-  attachBookingsCoverage,
-  getProgramDefinition, createPoolDefinition, createBenefitItems,
-};

package/skills/wix-vibe-headless/references/rentals/INSTRUCTIONS.md

@@ -1,13 +0,0 @@
----
-name: rentals
-description: Rentals — renting out an item for a length the customer picks. Runs on the Bookings vertical.
----
-
-# Rentals
-
-Rentals is **the Bookings vertical** — Wix Rentals runs on the Bookings APIs. There is nothing
-separate to build here.
-
-Read and follow `.agents/skills/wix-vibe-headless/references/bookings/INSTRUCTIONS.md` (its
-**Rentals** section), and use the bookings scaffolds under `references/bookings/app/`. The install
-already deploys those for you when `rentals` is selected.