runline 0.1.0

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

@@ -0,0 +1,137 @@
+const BASE = "https://www.strava.com/api/v3";
+async function apiRequest(token, 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: `Bearer ${token}` } };
+    if (body && Object.keys(body).length > 0) {
+        const form = new URLSearchParams();
+        for (const [k, v] of Object.entries(body)) {
+            if (v !== undefined && v !== null)
+                form.set(k, String(v));
+        }
+        init.body = form;
+        init.headers["Content-Type"] = "application/x-www-form-urlencoded";
+    }
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`Strava error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function strava(rl) {
+    rl.setName("strava");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "Strava OAuth2 access token", env: "STRAVA_ACCESS_TOKEN" },
+    });
+    const key = (ctx) => ctx.connection.config.accessToken;
+    rl.registerAction("activity.create", {
+        description: "Create an activity",
+        inputSchema: {
+            name: { type: "string", required: true },
+            sportType: { type: "string", required: true, description: "e.g. Run, Ride, Swim, Hike" },
+            startDateLocal: { type: "string", required: true, description: "ISO 8601 start time" },
+            elapsedTime: { type: "number", required: true, description: "Duration in seconds" },
+            description: { type: "string", required: false },
+            distance: { type: "number", required: false, description: "Distance in meters" },
+            trainer: { type: "boolean", required: false },
+            commute: { type: "boolean", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = {
+                name: p.name, sport_type: p.sportType,
+                start_date_local: new Date(p.startDateLocal).toISOString(),
+                elapsed_time: p.elapsedTime,
+            };
+            if (p.description)
+                body.description = p.description;
+            if (p.distance)
+                body.distance = p.distance;
+            if (p.trainer)
+                body.trainer = 1;
+            if (p.commute)
+                body.commute = 1;
+            return apiRequest(key(ctx), "POST", "/activities", body);
+        },
+    });
+    rl.registerAction("activity.get", {
+        description: "Get an activity by ID",
+        inputSchema: { activityId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return apiRequest(key(ctx), "GET", `/activities/${input.activityId}`);
+        },
+    });
+    rl.registerAction("activity.list", {
+        description: "List the authenticated athlete's activities",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const qs = {};
+            if (input?.limit)
+                qs.per_page = input.limit;
+            return apiRequest(key(ctx), "GET", "/activities", undefined, qs);
+        },
+    });
+    rl.registerAction("activity.update", {
+        description: "Update an activity",
+        inputSchema: {
+            activityId: { type: "string", required: true },
+            name: { type: "string", required: false },
+            sportType: { type: "string", required: false },
+            description: { type: "string", required: false },
+            trainer: { type: "boolean", required: false },
+            commute: { type: "boolean", required: false },
+            gearId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const { activityId, ...fields } = input;
+            const body = {};
+            if (fields.name)
+                body.name = fields.name;
+            if (fields.sportType)
+                body.sport_type = fields.sportType;
+            if (fields.description)
+                body.description = fields.description;
+            if (fields.trainer !== undefined)
+                body.trainer = fields.trainer;
+            if (fields.commute !== undefined)
+                body.commute = fields.commute;
+            if (fields.gearId)
+                body.gear_id = fields.gearId;
+            return apiRequest(key(ctx), "PUT", `/activities/${activityId}`, body);
+        },
+    });
+    for (const sub of [
+        { name: "getLaps", path: "laps", description: "Get laps for an activity" },
+        { name: "getZones", path: "zones", description: "Get zones for an activity" },
+        { name: "getKudos", path: "kudos", description: "Get kudos for an activity" },
+        { name: "getComments", path: "comments", description: "Get comments for an activity" },
+    ]) {
+        rl.registerAction(`activity.${sub.name}`, {
+            description: sub.description,
+            inputSchema: { activityId: { type: "string", required: true }, limit: { type: "number", required: false } },
+            async execute(input, ctx) {
+                const p = input;
+                const data = (await apiRequest(key(ctx), "GET", `/activities/${p.activityId}/${sub.path}`));
+                if (p.limit)
+                    return data.slice(0, p.limit);
+                return data;
+            },
+        });
+    }
+    rl.registerAction("activity.getStreams", {
+        description: "Get activity streams (time-series data)",
+        inputSchema: {
+            activityId: { type: "string", required: true },
+            keys: { type: "string", required: true, description: "Comma-separated stream types: time, distance, latlng, altitude, heartrate, cadence, watts, temp, moving, grade_smooth" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "GET", `/activities/${p.activityId}/streams`, undefined, { keys: p.keys, key_by_type: "true" });
+        },
+    });
+}

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

@@ -0,0 +1,222 @@
+const BASE = "https://api.stripe.com/v1";
+async function apiRequest(secretKey, 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: `Bearer ${secretKey}` } };
+    if (body && Object.keys(body).length > 0) {
+        const form = new URLSearchParams();
+        function flatten(obj, prefix = "") {
+            for (const [k, v] of Object.entries(obj)) {
+                const key = prefix ? `${prefix}[${k}]` : k;
+                if (v !== null && v !== undefined && typeof v === "object" && !Array.isArray(v)) {
+                    flatten(v, key);
+                }
+                else if (v !== null && v !== undefined) {
+                    form.set(key, String(v));
+                }
+            }
+        }
+        flatten(body);
+        init.body = form;
+        init.headers["Content-Type"] = "application/x-www-form-urlencoded";
+    }
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`Stripe error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function stripe(rl) {
+    rl.setName("stripe");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ secretKey: { type: "string", required: true, description: "Stripe secret API key", env: "STRIPE_SECRET_KEY" } });
+    const key = (ctx) => ctx.connection.config.secretKey;
+    // ── Balance ─────────────────────────────────────────
+    rl.registerAction("balance.get", {
+        description: "Get current balance",
+        inputSchema: {},
+        async execute(_input, ctx) { return apiRequest(key(ctx), "GET", "/balance"); },
+    });
+    // ── Customer ────────────────────────────────────────
+    rl.registerAction("customer.create", {
+        description: "Create a customer",
+        inputSchema: { name: { type: "string", required: true }, email: { type: "string", required: false }, phone: { type: "string", required: false }, description: { type: "string", required: false } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "POST", "/customers", input); },
+    });
+    rl.registerAction("customer.get", {
+        description: "Get a customer by ID",
+        inputSchema: { customerId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "GET", `/customers/${input.customerId}`); },
+    });
+    rl.registerAction("customer.list", {
+        description: "List customers",
+        inputSchema: { limit: { type: "number", required: false }, email: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.limit)
+                qs.limit = p.limit;
+            if (p.email)
+                qs.email = p.email;
+            const data = (await apiRequest(key(ctx), "GET", "/customers", undefined, qs));
+            return data.data;
+        },
+    });
+    rl.registerAction("customer.update", {
+        description: "Update a customer",
+        inputSchema: { customerId: { type: "string", required: true }, name: { type: "string", required: false }, email: { type: "string", required: false }, phone: { type: "string", required: false }, description: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { customerId, ...fields } = input;
+            return apiRequest(key(ctx), "POST", `/customers/${customerId}`, fields);
+        },
+    });
+    rl.registerAction("customer.delete", {
+        description: "Delete a customer",
+        inputSchema: { customerId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "DELETE", `/customers/${input.customerId}`); },
+    });
+    // ── Charge ──────────────────────────────────────────
+    rl.registerAction("charge.create", {
+        description: "Create a charge",
+        inputSchema: {
+            amount: { type: "number", required: true, description: "Amount in smallest currency unit (e.g. cents)" },
+            currency: { type: "string", required: true },
+            source: { type: "string", required: true, description: "Payment source token or ID" },
+            customer: { type: "string", required: false },
+            description: { type: "string", required: false },
+        },
+        async execute(input, ctx) { return apiRequest(key(ctx), "POST", "/charges", input); },
+    });
+    rl.registerAction("charge.get", {
+        description: "Get a charge by ID",
+        inputSchema: { chargeId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "GET", `/charges/${input.chargeId}`); },
+    });
+    rl.registerAction("charge.list", {
+        description: "List charges",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const qs = {};
+            if (input?.limit)
+                qs.limit = input.limit;
+            const data = (await apiRequest(key(ctx), "GET", "/charges", undefined, qs));
+            return data.data;
+        },
+    });
+    rl.registerAction("charge.update", {
+        description: "Update a charge",
+        inputSchema: { chargeId: { type: "string", required: true }, description: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { chargeId, ...fields } = input;
+            return apiRequest(key(ctx), "POST", `/charges/${chargeId}`, fields);
+        },
+    });
+    // ── Coupon ──────────────────────────────────────────
+    rl.registerAction("coupon.create", {
+        description: "Create a coupon",
+        inputSchema: {
+            duration: { type: "string", required: true, description: "forever, once, or repeating" },
+            percentOff: { type: "number", required: false },
+            amountOff: { type: "number", required: false, description: "In smallest currency unit" },
+            currency: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { duration: p.duration };
+            if (p.percentOff)
+                body.percent_off = p.percentOff;
+            if (p.amountOff)
+                body.amount_off = p.amountOff;
+            if (p.currency)
+                body.currency = p.currency;
+            return apiRequest(key(ctx), "POST", "/coupons", body);
+        },
+    });
+    rl.registerAction("coupon.list", {
+        description: "List coupons",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const qs = {};
+            if (input?.limit)
+                qs.limit = input.limit;
+            const data = (await apiRequest(key(ctx), "GET", "/coupons", undefined, qs));
+            return data.data;
+        },
+    });
+    // ── Customer Card ───────────────────────────────────
+    rl.registerAction("customerCard.add", {
+        description: "Add a card to a customer",
+        inputSchema: { customerId: { type: "string", required: true }, token: { type: "string", required: true, description: "Card token from Stripe.js/Elements" } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "POST", `/customers/${p.customerId}/sources`, { source: p.token });
+        },
+    });
+    rl.registerAction("customerCard.get", {
+        description: "Get a customer's card/source",
+        inputSchema: { customerId: { type: "string", required: true }, sourceId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "GET", `/customers/${p.customerId}/sources/${p.sourceId}`);
+        },
+    });
+    rl.registerAction("customerCard.remove", {
+        description: "Remove a card from a customer",
+        inputSchema: { customerId: { type: "string", required: true }, cardId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "DELETE", `/customers/${p.customerId}/sources/${p.cardId}`);
+        },
+    });
+    // ── Source ──────────────────────────────────────────
+    rl.registerAction("source.create", {
+        description: "Create a source and attach to customer",
+        inputSchema: { customerId: { type: "string", required: true }, type: { type: "string", required: true }, amount: { type: "number", required: true }, currency: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            const source = (await apiRequest(key(ctx), "POST", "/sources", { type: p.type, amount: p.amount, currency: p.currency }));
+            await apiRequest(key(ctx), "POST", `/customers/${p.customerId}/sources`, { source: source.id });
+            return source;
+        },
+    });
+    rl.registerAction("source.get", {
+        description: "Get a source by ID",
+        inputSchema: { sourceId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "GET", `/sources/${input.sourceId}`); },
+    });
+    rl.registerAction("source.delete", {
+        description: "Detach a source from a customer",
+        inputSchema: { customerId: { type: "string", required: true }, sourceId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "DELETE", `/customers/${p.customerId}/sources/${p.sourceId}`);
+        },
+    });
+    // ── Token ───────────────────────────────────────────
+    rl.registerAction("token.createCard", {
+        description: "Create a card token",
+        inputSchema: { number: { type: "string", required: true }, expMonth: { type: "number", required: true }, expYear: { type: "number", required: true }, cvc: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(key(ctx), "POST", "/tokens", { card: { number: p.number, exp_month: p.expMonth, exp_year: p.expYear, cvc: p.cvc } });
+        },
+    });
+    // ── Meter Event ─────────────────────────────────────
+    rl.registerAction("meterEvent.create", {
+        description: "Create a billing meter event",
+        inputSchema: { eventName: { type: "string", required: true }, customerId: { type: "string", required: true }, value: { type: "number", required: true }, identifier: { type: "string", required: false }, timestamp: { type: "string", required: false, description: "ISO datetime" } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { event_name: p.eventName, payload: { stripe_customer_id: p.customerId, value: p.value } };
+            if (p.identifier)
+                body.identifier = p.identifier;
+            if (p.timestamp)
+                body.timestamp = Math.floor(new Date(p.timestamp).getTime() / 1000);
+            return apiRequest(key(ctx), "POST", "/billing/meter_events", body);
+        },
+    });
+}

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

@@ -0,0 +1,121 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { host: c.host.replace(/\/$/, ""), serviceRole: c.serviceRole };
+}
+async function apiRequest(conn, method, endpoint, body, qs, extraHeaders) {
+    const url = new URL(`${conn.host}/rest/v1${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const headers = {
+        apikey: conn.serviceRole,
+        Authorization: `Bearer ${conn.serviceRole}`,
+        Prefer: "return=representation",
+        "Content-Type": "application/json",
+        ...extraHeaders,
+    };
+    const init = { method, headers };
+    if (body !== undefined)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`Supabase error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+export default function supabase(rl) {
+    rl.setName("supabase");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        host: { type: "string", required: true, description: "Supabase project URL (e.g. https://xxx.supabase.co)", env: "SUPABASE_URL" },
+        serviceRole: { type: "string", required: true, description: "Supabase service_role key", env: "SUPABASE_SERVICE_ROLE_KEY" },
+    });
+    rl.registerAction("row.create", {
+        description: "Insert rows into a table",
+        inputSchema: {
+            table: { type: "string", required: true },
+            data: { type: "object", required: true, description: "Row data (or array of rows)" },
+            schema: { type: "string", required: false, description: "Database schema (default: public)" },
+        },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            const p = input;
+            const headers = {};
+            if (p.schema && p.schema !== "public")
+                headers["Content-Profile"] = p.schema;
+            return apiRequest(conn, "POST", `/${p.table}`, p.data, undefined, headers);
+        },
+    });
+    rl.registerAction("row.get", {
+        description: "Get rows by filter (PostgREST query params)",
+        inputSchema: {
+            table: { type: "string", required: true },
+            filters: { type: "object", required: true, description: "PostgREST filters, e.g. { id: 'eq.5' }" },
+            schema: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            const p = input;
+            const headers = {};
+            if (p.schema && p.schema !== "public")
+                headers["Accept-Profile"] = p.schema;
+            return apiRequest(conn, "GET", `/${p.table}`, undefined, p.filters, headers);
+        },
+    });
+    rl.registerAction("row.list", {
+        description: "List rows from a table",
+        inputSchema: {
+            table: { type: "string", required: true },
+            limit: { type: "number", required: false },
+            filters: { type: "object", required: false, description: "PostgREST filters" },
+            schema: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            const p = (input ?? {});
+            const qs = { ...(p.filters ?? {}) };
+            if (p.limit)
+                qs.limit = p.limit;
+            const headers = {};
+            if (p.schema && p.schema !== "public")
+                headers["Accept-Profile"] = p.schema;
+            return apiRequest(conn, "GET", `/${p.table}`, undefined, qs, headers);
+        },
+    });
+    rl.registerAction("row.update", {
+        description: "Update rows matching a filter",
+        inputSchema: {
+            table: { type: "string", required: true },
+            data: { type: "object", required: true, description: "Fields to update" },
+            filters: { type: "object", required: true, description: "PostgREST filters to match rows" },
+            schema: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            const p = input;
+            const headers = {};
+            if (p.schema && p.schema !== "public")
+                headers["Content-Profile"] = p.schema;
+            return apiRequest(conn, "PATCH", `/${p.table}`, p.data, p.filters, headers);
+        },
+    });
+    rl.registerAction("row.delete", {
+        description: "Delete rows matching a filter",
+        inputSchema: {
+            table: { type: "string", required: true },
+            filters: { type: "object", required: true, description: "PostgREST filters to match rows" },
+            schema: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const conn = getConn(ctx);
+            const p = input;
+            const headers = {};
+            if (p.schema && p.schema !== "public")
+                headers["Content-Profile"] = p.schema;
+            return apiRequest(conn, "DELETE", `/${p.table}`, undefined, p.filters, headers);
+        },
+    });
+}