runline 0.1.0

package/dist/plugins/onfleet/src/index.js

@@ -0,0 +1,254 @@
+const BASE = "https://onfleet.com/api/v2";
+async function apiRequest(apiKey, method, endpoint, body, qs) {
+    const url = new URL(`${BASE}/${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const init = {
+        method,
+        headers: {
+            Authorization: `Basic ${btoa(`${apiKey}:`)}`,
+            "Content-Type": "application/json",
+            "User-Agent": "runline-onfleet",
+        },
+    };
+    if (body !== undefined && method !== "GET")
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`Onfleet error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+function registerCrud(rl, resource, plural, key, createSchema) {
+    rl.registerAction(`${resource}.create`, {
+        description: `Create a ${resource}`,
+        inputSchema: createSchema,
+        async execute(input, ctx) { return apiRequest(key(ctx), "POST", plural, input); },
+    });
+    rl.registerAction(`${resource}.get`, {
+        description: `Get a ${resource} by ID`,
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "GET", `${plural}/${input.id}`); },
+    });
+    rl.registerAction(`${resource}.list`, {
+        description: `List ${plural}`,
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(key(ctx), "GET", plural));
+            const p = (input ?? {});
+            return p.limit ? data.slice(0, p.limit) : data;
+        },
+    });
+    rl.registerAction(`${resource}.update`, {
+        description: `Update a ${resource}`,
+        inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "PUT", `${plural}/${p.id}`, p.data);
+        },
+    });
+    rl.registerAction(`${resource}.delete`, {
+        description: `Delete a ${resource}`,
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            await apiRequest(key(ctx), "DELETE", `${plural}/${input.id}`);
+            return { success: true };
+        },
+    });
+}
+export default function onfleet(rl) {
+    rl.setName("onfleet");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ apiKey: { type: "string", required: true, description: "Onfleet API key", env: "ONFLEET_API_KEY" } });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    // ── Organization ────────────────────────────────────
+    rl.registerAction("organization.get", {
+        description: "Get organization details",
+        inputSchema: {},
+        async execute(_input, ctx) { return apiRequest(key(ctx), "GET", "organization"); },
+    });
+    // ── Task ────────────────────────────────────────────
+    rl.registerAction("task.create", {
+        description: "Create a task",
+        inputSchema: {
+            destination: { type: "object", required: true, description: "{ address: { unparsed: string } } or { address: { number, street, city, country } }" },
+            recipients: { type: "object", required: false, description: "Array of { name, phone }" },
+            completeAfter: { type: "number", required: false, description: "Unix ms timestamp" },
+            completeBefore: { type: "number", required: false, description: "Unix ms timestamp" },
+            notes: { type: "string", required: false },
+        },
+        async execute(input, ctx) { return apiRequest(key(ctx), "POST", "tasks", input); },
+    });
+    rl.registerAction("task.get", {
+        description: "Get a task by ID",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const id = input.id;
+            const path = id.length <= 8 ? `tasks/shortId/${id}` : `tasks/${id}`;
+            return apiRequest(key(ctx), "GET", path);
+        },
+    });
+    rl.registerAction("task.list", {
+        description: "List tasks",
+        inputSchema: { from: { type: "number", required: false, description: "Unix ms start" }, to: { type: "number", required: false }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.from)
+                qs.from = p.from;
+            else
+                qs.from = Date.now() - 604800000;
+            if (p.to)
+                qs.to = p.to;
+            const data = (await apiRequest(key(ctx), "GET", "tasks/all", undefined, qs));
+            const tasks = data.tasks;
+            return p.limit ? tasks.slice(0, p.limit) : tasks;
+        },
+    });
+    rl.registerAction("task.update", {
+        description: "Update a task",
+        inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "PUT", `tasks/${p.id}`, p.data);
+        },
+    });
+    rl.registerAction("task.delete", {
+        description: "Delete a task",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            await apiRequest(key(ctx), "DELETE", `tasks/${input.id}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("task.complete", {
+        description: "Force-complete a task",
+        inputSchema: { id: { type: "string", required: true }, success: { type: "boolean", required: true }, notes: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { completionDetails: { success: p.success } };
+            if (p.notes)
+                body.completionDetails.notes = p.notes;
+            await apiRequest(key(ctx), "POST", `tasks/${p.id}/complete`, body);
+            return { success: true };
+        },
+    });
+    // ── Worker ──────────────────────────────────────────
+    registerCrud(rl, "worker", "workers", key, {
+        name: { type: "string", required: true },
+        phone: { type: "string", required: true },
+        teams: { type: "object", required: true, description: "Array of team IDs" },
+    });
+    // ── Admin ───────────────────────────────────────────
+    registerCrud(rl, "admin", "admins", key, {
+        name: { type: "string", required: true },
+        email: { type: "string", required: true },
+    });
+    // ── Hub ─────────────────────────────────────────────
+    rl.registerAction("hub.create", {
+        description: "Create a hub",
+        inputSchema: { name: { type: "string", required: true }, address: { type: "object", required: true } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "POST", "hubs", input); },
+    });
+    rl.registerAction("hub.list", {
+        description: "List hubs",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(key(ctx), "GET", "hubs"));
+            const p = (input ?? {});
+            return p.limit ? data.slice(0, p.limit) : data;
+        },
+    });
+    rl.registerAction("hub.update", {
+        description: "Update a hub",
+        inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "PUT", `hubs/${p.id}`, p.data);
+        },
+    });
+    // ── Team ────────────────────────────────────────────
+    registerCrud(rl, "team", "teams", key, {
+        name: { type: "string", required: true },
+        workers: { type: "object", required: true, description: "Array of worker IDs" },
+        managers: { type: "object", required: true, description: "Array of admin IDs" },
+    });
+    // ── Recipient ───────────────────────────────────────
+    rl.registerAction("recipient.create", {
+        description: "Create a recipient",
+        inputSchema: { name: { type: "string", required: true }, phone: { type: "string", required: true }, notes: { type: "string", required: false } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "POST", "recipients", input); },
+    });
+    rl.registerAction("recipient.get", {
+        description: "Get a recipient by ID",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "GET", `recipients/${input.id}`); },
+    });
+    rl.registerAction("recipient.update", {
+        description: "Update a recipient",
+        inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "PUT", `recipients/${p.id}`, p.data);
+        },
+    });
+    // ── Container ────────────────────────────────────────
+    rl.registerAction("container.get", {
+        description: "Get a container by type and ID",
+        inputSchema: {
+            containerType: { type: "string", required: true, description: "workers, teams, or organizations" },
+            containerId: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "GET", `containers/${p.containerType}/${p.containerId}`);
+        },
+    });
+    rl.registerAction("container.updateTasks", {
+        description: "Update tasks in a container",
+        inputSchema: {
+            containerType: { type: "string", required: true, description: "workers, teams, or organizations" },
+            containerId: { type: "string", required: true },
+            tasks: { type: "object", required: true, description: "Array of task IDs" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "PUT", `containers/${p.containerType}/${p.containerId}`, { tasks: p.tasks });
+        },
+    });
+    rl.registerAction("team.getTimeEstimates", {
+        description: "Get driver time estimates for a team",
+        inputSchema: {
+            id: { type: "string", required: true },
+            dropoffLocation: { type: "string", required: false, description: "lng,lat" },
+            pickupLocation: { type: "string", required: false, description: "lng,lat" },
+        },
+        async execute(input, ctx) {
+            const { id, ...qs } = input;
+            return apiRequest(key(ctx), "GET", `teams/${id}/estimate`, undefined, qs);
+        },
+    });
+    rl.registerAction("team.autoDispatch", {
+        description: "Auto-dispatch tasks for a team",
+        inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "POST", `teams/${p.id}/dispatch`, p.data ?? {});
+        },
+    });
+    // ── Destination ─────────────────────────────────────
+    rl.registerAction("destination.create", {
+        description: "Create a destination",
+        inputSchema: { address: { type: "object", required: true, description: "{ unparsed: string } or { number, street, city, country }" } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "POST", "destinations", input); },
+    });
+    rl.registerAction("destination.get", {
+        description: "Get a destination by ID",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "GET", `destinations/${input.id}`); },
+    });
+}

package/dist/plugins/openThesaurus/src/index.js

@@ -0,0 +1,32 @@
+export default function openThesaurus(rl) {
+    rl.setName("openThesaurus");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({});
+    rl.registerAction("synonyms.get", {
+        description: "Get synonyms for a German word (OpenThesaurus API, no auth required)",
+        inputSchema: {
+            text: { type: "string", required: true, description: "German word to look up" },
+            baseform: { type: "boolean", required: false, description: "Return base form of search term" },
+            similar: { type: "boolean", required: false, description: "Return similarly written words" },
+            startswith: { type: "boolean", required: false, description: "Only match words starting with term" },
+            substring: { type: "boolean", required: false, description: "Match partial words" },
+            subsynsets: { type: "boolean", required: false, description: "Include sub-terms" },
+            supersynsets: { type: "boolean", required: false, description: "Include generic terms" },
+        },
+        async execute(input) {
+            const p = (input ?? {});
+            const url = new URL("https://www.openthesaurus.de/synonyme/search");
+            url.searchParams.set("q", p.text);
+            url.searchParams.set("format", "application/json");
+            for (const key of ["baseform", "similar", "startswith", "substring", "subsynsets", "supersynsets"]) {
+                if (p[key])
+                    url.searchParams.set(key, "true");
+            }
+            const res = await fetch(url.toString(), { headers: { "User-Agent": "runline" } });
+            if (!res.ok)
+                throw new Error(`OpenThesaurus error ${res.status}: ${await res.text()}`);
+            const data = (await res.json());
+            return data.synsets;
+        },
+    });
+}

package/dist/plugins/openweathermap/src/index.js

@@ -0,0 +1,60 @@
+const BASE = "https://api.openweathermap.org/data/2.5";
+const locationSchema = {
+    cityName: { type: "string", required: false, description: "City name (e.g. berlin,de)" },
+    cityId: { type: "number", required: false, description: "City ID from OpenWeatherMap" },
+    lat: { type: "string", required: false, description: "Latitude" },
+    lon: { type: "string", required: false, description: "Longitude" },
+    zip: { type: "string", required: false, description: "Zip code (e.g. 10115,de)" },
+    units: { type: "string", required: false, description: "Units: metric (default), imperial, standard" },
+    lang: { type: "string", required: false, description: "Language code (e.g. en, de)" },
+};
+function buildQs(apiKey, input) {
+    const qs = new URLSearchParams();
+    qs.set("APPID", apiKey);
+    qs.set("units", input.units ?? "metric");
+    if (input.cityName)
+        qs.set("q", input.cityName);
+    else if (input.cityId)
+        qs.set("id", String(input.cityId));
+    else if (input.lat && input.lon) {
+        qs.set("lat", input.lat);
+        qs.set("lon", input.lon);
+    }
+    else if (input.zip)
+        qs.set("zip", input.zip);
+    if (input.lang)
+        qs.set("lang", input.lang);
+    return qs;
+}
+export default function openWeatherMap(rl) {
+    rl.setName("openweathermap");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "OpenWeatherMap API key", env: "OPENWEATHERMAP_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    rl.registerAction("weather.current", {
+        description: "Get current weather data for a location",
+        inputSchema: locationSchema,
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = buildQs(key(ctx), p);
+            const res = await fetch(`${BASE}/weather?${qs.toString()}`);
+            if (!res.ok)
+                throw new Error(`OpenWeatherMap error ${res.status}: ${await res.text()}`);
+            return res.json();
+        },
+    });
+    rl.registerAction("weather.forecast5day", {
+        description: "Get 5-day / 3-hour weather forecast for a location",
+        inputSchema: locationSchema,
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = buildQs(key(ctx), p);
+            const res = await fetch(`${BASE}/forecast?${qs.toString()}`);
+            if (!res.ok)
+                throw new Error(`OpenWeatherMap error ${res.status}: ${await res.text()}`);
+            return res.json();
+        },
+    });
+}

package/dist/plugins/oura/src/index.js

@@ -0,0 +1,62 @@
+const BASE = "https://api.ouraring.com/v2";
+async function apiRequest(token, endpoint, qs = {}) {
+    const url = new URL(`${BASE}${endpoint}`);
+    for (const [k, v] of Object.entries(qs)) {
+        if (v !== undefined && v !== null)
+            url.searchParams.set(k, String(v));
+    }
+    const res = await fetch(url.toString(), {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok)
+        throw new Error(`Oura API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+function formatDate(d) {
+    if (!d)
+        return undefined;
+    return String(d).split("T")[0];
+}
+export default function oura(rl) {
+    rl.setName("oura");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "Oura personal access token", env: "OURA_ACCESS_TOKEN" },
+    });
+    const key = (ctx) => ctx.connection.config.accessToken;
+    rl.registerAction("profile.get", {
+        description: "Get the user's personal information",
+        inputSchema: {},
+        async execute(_input, ctx) {
+            return apiRequest(key(ctx), "/usercollection/personal_info");
+        },
+    });
+    const summaryEndpoints = [
+        { name: "summary.activity", path: "/usercollection/daily_activity", description: "Get daily activity summary" },
+        { name: "summary.readiness", path: "/usercollection/daily_readiness", description: "Get daily readiness summary" },
+        { name: "summary.sleep", path: "/usercollection/daily_sleep", description: "Get daily sleep summary" },
+    ];
+    for (const ep of summaryEndpoints) {
+        rl.registerAction(ep.name, {
+            description: ep.description,
+            inputSchema: {
+                startDate: { type: "string", required: false, description: "Start date (YYYY-MM-DD), defaults to a week ago" },
+                endDate: { type: "string", required: false, description: "End date (YYYY-MM-DD), defaults to today" },
+                limit: { type: "number", required: false, description: "Max results (default all)" },
+            },
+            async execute(input, ctx) {
+                const p = (input ?? {});
+                const qs = {};
+                if (p.startDate)
+                    qs.start_date = formatDate(p.startDate);
+                if (p.endDate)
+                    qs.end_date = formatDate(p.endDate);
+                const data = (await apiRequest(key(ctx), ep.path, qs));
+                let items = (data.data ?? []);
+                if (p.limit)
+                    items = items.slice(0, p.limit);
+                return items;
+            },
+        });
+    }
+}

package/dist/plugins/paddle/src/index.js

@@ -0,0 +1,247 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    const sandbox = c.sandbox;
+    const base = sandbox ? "https://sandbox-vendors.paddle.com/api" : "https://vendors.paddle.com/api";
+    return { base, vendorId: c.vendorId, vendorAuthCode: c.vendorAuthCode };
+}
+async function apiRequest(conn, endpoint, body = {}) {
+    body.vendor_id = conn.vendorId;
+    body.vendor_auth_code = conn.vendorAuthCode;
+    const res = await fetch(`${conn.base}${endpoint}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`Paddle API error ${res.status}: ${await res.text()}`);
+    const json = (await res.json());
+    if (!json.success)
+        throw new Error(`Paddle API error: ${JSON.stringify(json.error ?? json)}`);
+    return json.response;
+}
+async function paginate(conn, endpoint, body = {}) {
+    const all = [];
+    body.results_per_page = 200;
+    body.page = 1;
+    let items;
+    do {
+        const resp = await apiRequest(conn, endpoint, { ...body });
+        items = Array.isArray(resp) ? resp : [];
+        all.push(...items);
+        body.page = body.page + 1;
+    } while (items.length === 200);
+    return all;
+}
+export default function paddle(rl) {
+    rl.setName("paddle");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        vendorId: { type: "string", required: true, description: "Paddle Vendor ID", env: "PADDLE_VENDOR_ID" },
+        vendorAuthCode: { type: "string", required: true, description: "Paddle Vendor Auth Code", env: "PADDLE_VENDOR_AUTH_CODE" },
+        sandbox: { type: "boolean", required: false, description: "Use sandbox environment (default false)" },
+    });
+    // ── Coupon ──────────────────────────────────────────
+    rl.registerAction("coupon.create", {
+        description: "Create a coupon",
+        inputSchema: {
+            couponType: { type: "string", required: true, description: "product or checkout" },
+            discountType: { type: "string", required: true, description: "flat or percentage" },
+            discountAmount: { type: "number", required: true },
+            productIds: { type: "string", required: false, description: "Comma-separated product IDs (for product coupon type)" },
+            currency: { type: "string", required: false, description: "Currency code (required for flat discount)" },
+            allowedUses: { type: "number", required: false },
+            couponCode: { type: "string", required: false },
+            couponPrefix: { type: "string", required: false },
+            expires: { type: "string", required: false, description: "Expiry date YYYY-MM-DD" },
+            group: { type: "string", required: false },
+            recurring: { type: "boolean", required: false },
+            numberOfCoupons: { type: "number", required: false },
+            description: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const body = {
+                coupon_type: p.couponType, discount_type: p.discountType, discount_amount: p.discountAmount,
+            };
+            if (p.productIds)
+                body.product_ids = p.productIds;
+            if (p.currency)
+                body.currency = p.currency;
+            if (p.allowedUses)
+                body.allowed_uses = p.allowedUses;
+            if (p.couponCode)
+                body.coupon_code = p.couponCode;
+            if (p.couponPrefix)
+                body.coupon_prefix = p.couponPrefix;
+            if (p.expires)
+                body.expires = p.expires;
+            if (p.group)
+                body.group = p.group;
+            if (p.recurring !== undefined)
+                body.recurring = p.recurring ? 1 : 0;
+            if (p.numberOfCoupons)
+                body.num_coupons = p.numberOfCoupons;
+            if (p.description)
+                body.description = p.description;
+            const resp = (await apiRequest(getConn(ctx), "/2.1/product/create_coupon", body));
+            return resp.coupon_codes;
+        },
+    });
+    rl.registerAction("coupon.list", {
+        description: "List coupons for a product",
+        inputSchema: {
+            productId: { type: "string", required: true, description: "Product ID" },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const resp = (await apiRequest(getConn(ctx), "/2.0/product/list_coupons", { product_id: p.productId }));
+            if (p.limit)
+                return resp.slice(0, p.limit);
+            return resp;
+        },
+    });
+    rl.registerAction("coupon.update", {
+        description: "Update a coupon by code or group",
+        inputSchema: {
+            couponCode: { type: "string", required: false, description: "Coupon code to update" },
+            group: { type: "string", required: false, description: "Group name to update" },
+            newCouponCode: { type: "string", required: false },
+            newGroup: { type: "string", required: false },
+            allowedUses: { type: "number", required: false },
+            currency: { type: "string", required: false },
+            discountAmount: { type: "number", required: false },
+            expires: { type: "string", required: false },
+            productIds: { type: "string", required: false },
+            recurring: { type: "boolean", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const body = {};
+            if (p.couponCode)
+                body.coupon_code = p.couponCode;
+            if (p.group)
+                body.group = p.group;
+            if (p.newCouponCode)
+                body.new_coupon_code = p.newCouponCode;
+            if (p.newGroup)
+                body.new_group = p.newGroup;
+            if (p.allowedUses)
+                body.allowed_uses = p.allowedUses;
+            if (p.currency)
+                body.currency = p.currency;
+            if (p.discountAmount)
+                body.discount_amount = p.discountAmount;
+            if (p.expires)
+                body.expires = p.expires;
+            if (p.productIds)
+                body.product_ids = p.productIds;
+            if (p.recurring !== undefined)
+                body.recurring = p.recurring ? 1 : 0;
+            return apiRequest(getConn(ctx), "/2.1/product/update_coupon", body);
+        },
+    });
+    // ── Payment ─────────────────────────────────────────
+    rl.registerAction("payment.list", {
+        description: "List subscription payments",
+        inputSchema: {
+            subscriptionId: { type: "number", required: false },
+            plan: { type: "string", required: false },
+            state: { type: "string", required: false },
+            isPaid: { type: "boolean", required: false },
+            from: { type: "string", required: false, description: "YYYY-MM-DD" },
+            to: { type: "string", required: false, description: "YYYY-MM-DD" },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const body = {};
+            if (p.subscriptionId)
+                body.subscription_id = p.subscriptionId;
+            if (p.plan)
+                body.plan = p.plan;
+            if (p.state)
+                body.state = p.state;
+            if (p.isPaid !== undefined)
+                body.is_paid = p.isPaid ? 1 : 0;
+            if (p.from)
+                body.from = p.from;
+            if (p.to)
+                body.to = p.to;
+            const resp = (await apiRequest(getConn(ctx), "/2.0/subscription/payments", body));
+            if (p.limit)
+                return resp.slice(0, p.limit);
+            return resp;
+        },
+    });
+    rl.registerAction("payment.reschedule", {
+        description: "Reschedule a payment",
+        inputSchema: {
+            paymentId: { type: "number", required: true },
+            date: { type: "string", required: true, description: "New payment date YYYY-MM-DD" },
+        },
+        async execute(input, ctx) {
+            const { paymentId, date } = input;
+            return apiRequest(getConn(ctx), "/2.0/subscription/payments_reschedule", { payment_id: paymentId, date });
+        },
+    });
+    // ── Plan ────────────────────────────────────────────
+    rl.registerAction("plan.get", {
+        description: "Get a subscription plan by ID",
+        inputSchema: { planId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const { planId } = input;
+            return apiRequest(getConn(ctx), "/2.0/subscription/plans", { plan: planId });
+        },
+    });
+    rl.registerAction("plan.list", {
+        description: "List all subscription plans",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const resp = (await apiRequest(getConn(ctx), "/2.0/subscription/plans"));
+            const limit = input?.limit;
+            if (limit)
+                return resp.slice(0, limit);
+            return resp;
+        },
+    });
+    // ── Product ─────────────────────────────────────────
+    rl.registerAction("product.list", {
+        description: "List all products",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const resp = (await apiRequest(getConn(ctx), "/2.0/product/get_products"));
+            const products = (resp.products ?? resp);
+            const limit = input?.limit;
+            if (limit)
+                return products.slice(0, limit);
+            return products;
+        },
+    });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.list", {
+        description: "List subscription users",
+        inputSchema: {
+            state: { type: "string", required: false, description: "active, past_due, trialing, paused, deleted" },
+            planId: { type: "string", required: false },
+            subscriptionId: { type: "string", required: false },
+            limit: { type: "number", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const conn = getConn(ctx);
+            const body = {};
+            if (p.state)
+                body.state = p.state;
+            if (p.planId)
+                body.plan_id = p.planId;
+            if (p.subscriptionId)
+                body.subscription_id = p.subscriptionId;
+            if (p.limit) {
+                body.results_per_page = p.limit;
+                return apiRequest(conn, "/2.0/subscription/users", body);
+            }
+            return paginate(conn, "/2.0/subscription/users", body);
+        },
+    });
+}