runline 0.1.0

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

@@ -0,0 +1,298 @@
+const BASE_URL = "https://www.beeminder.com/api/v1";
+async function apiRequest(token, method, endpoint, body, qs) {
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    url.searchParams.set("auth_token", token);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: { "Content-Type": "application/json" },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Beeminder API error ${res.status}: ${text}`);
+    }
+    const ct = res.headers.get("content-type") ?? "";
+    if (ct.includes("application/json"))
+        return res.json();
+    return { success: true };
+}
+async function paginateAll(token, endpoint, qs) {
+    const results = [];
+    let page = 1;
+    while (true) {
+        const data = (await apiRequest(token, "GET", endpoint, undefined, { ...qs, page }));
+        if (!Array.isArray(data) || data.length === 0)
+            break;
+        results.push(...data);
+        page++;
+    }
+    return results;
+}
+function getToken(ctx) {
+    return ctx.connection.config.apiToken;
+}
+export default function beeminder(rl) {
+    rl.setName("beeminder");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiToken: {
+            type: "string",
+            required: true,
+            description: "Beeminder API token",
+            env: "BEEMINDER_API_TOKEN",
+        },
+    });
+    // ── Datapoint ───────────────────────────────────────
+    rl.registerAction("datapoint.create", {
+        description: "Create a datapoint for a goal",
+        inputSchema: {
+            goalName: { type: "string", required: true, description: "Goal slug" },
+            value: { type: "number", required: true, description: "Datapoint value" },
+            timestamp: { type: "number", required: false, description: "Unix timestamp (default: now)" },
+            comment: { type: "string", required: false, description: "Comment" },
+            requestid: { type: "string", required: false, description: "Unique ID to prevent duplicates" },
+        },
+        async execute(input, ctx) {
+            const { goalName, ...body } = input;
+            return apiRequest(getToken(ctx), "POST", `/users/me/goals/${goalName}/datapoints.json`, body);
+        },
+    });
+    rl.registerAction("datapoint.createAll", {
+        description: "Create multiple datapoints at once",
+        inputSchema: {
+            goalName: { type: "string", required: true, description: "Goal slug" },
+            datapoints: { type: "array", required: true, description: "Array of {value, timestamp?, comment?, requestid?}" },
+        },
+        async execute(input, ctx) {
+            const { goalName, datapoints } = input;
+            return apiRequest(getToken(ctx), "POST", `/users/me/goals/${goalName}/datapoints/create_all.json`, { datapoints });
+        },
+    });
+    rl.registerAction("datapoint.get", {
+        description: "Get a single datapoint",
+        inputSchema: {
+            goalName: { type: "string", required: true, description: "Goal slug" },
+            datapointId: { type: "string", required: true, description: "Datapoint ID" },
+        },
+        async execute(input, ctx) {
+            const { goalName, datapointId } = input;
+            return apiRequest(getToken(ctx), "GET", `/users/me/goals/${goalName}/datapoints/${datapointId}.json`);
+        },
+    });
+    rl.registerAction("datapoint.list", {
+        description: "List datapoints for a goal",
+        inputSchema: {
+            goalName: { type: "string", required: true, description: "Goal slug" },
+            sort: { type: "string", required: false, description: "Sort attribute (default: id)" },
+            limit: { type: "number", required: false, description: "Max results (omit for all)" },
+            page: { type: "number", required: false, description: "Page number (1-indexed)" },
+            per: { type: "number", required: false, description: "Results per page" },
+        },
+        async execute(input, ctx) {
+            const { goalName, sort, limit, page, per } = (input ?? {});
+            const token = getToken(ctx);
+            const qs = {};
+            if (sort)
+                qs.sort = sort;
+            if (limit) {
+                qs.count = limit;
+                if (page)
+                    qs.page = page;
+                if (per)
+                    qs.per = per;
+                return apiRequest(token, "GET", `/users/me/goals/${goalName}/datapoints.json`, undefined, qs);
+            }
+            return paginateAll(token, `/users/me/goals/${goalName}/datapoints.json`, qs);
+        },
+    });
+    rl.registerAction("datapoint.update", {
+        description: "Update a datapoint",
+        inputSchema: {
+            goalName: { type: "string", required: true, description: "Goal slug" },
+            datapointId: { type: "string", required: true, description: "Datapoint ID" },
+            value: { type: "number", required: false, description: "New value" },
+            comment: { type: "string", required: false, description: "New comment" },
+            timestamp: { type: "number", required: false, description: "New unix timestamp" },
+        },
+        async execute(input, ctx) {
+            const { goalName, datapointId, ...body } = input;
+            return apiRequest(getToken(ctx), "PUT", `/users/me/goals/${goalName}/datapoints/${datapointId}.json`, body);
+        },
+    });
+    rl.registerAction("datapoint.delete", {
+        description: "Delete a datapoint",
+        inputSchema: {
+            goalName: { type: "string", required: true, description: "Goal slug" },
+            datapointId: { type: "string", required: true, description: "Datapoint ID" },
+        },
+        async execute(input, ctx) {
+            const { goalName, datapointId } = input;
+            return apiRequest(getToken(ctx), "DELETE", `/users/me/goals/${goalName}/datapoints/${datapointId}.json`);
+        },
+    });
+    // ── Charge ──────────────────────────────────────────
+    rl.registerAction("charge.create", {
+        description: "Create a charge (pay money to Beeminder)",
+        inputSchema: {
+            amount: { type: "number", required: true, description: "Amount in USD" },
+            note: { type: "string", required: false, description: "Charge explanation" },
+            dryrun: { type: "boolean", required: false, description: "Test without actually charging" },
+        },
+        async execute(input, ctx) {
+            const { amount, note, dryrun } = input;
+            const body = { user_id: "me", amount };
+            if (note)
+                body.note = note;
+            if (dryrun)
+                body.dryrun = dryrun;
+            return apiRequest(getToken(ctx), "POST", "/charges.json", body);
+        },
+    });
+    // ── Goal ────────────────────────────────────────────
+    rl.registerAction("goal.create", {
+        description: "Create a new goal",
+        inputSchema: {
+            slug: { type: "string", required: true, description: "Goal slug (unique identifier)" },
+            title: { type: "string", required: true, description: "Human-readable title" },
+            goal_type: { type: "string", required: true, description: "Goal type: hustler, biker, fatloser, gainer, inboxer, drinker, custom" },
+            gunits: { type: "string", required: true, description: "Units (e.g. hours, pages, pounds)" },
+            goaldate: { type: "number", required: false, description: "Target date (unix timestamp)" },
+            goalval: { type: "number", required: false, description: "Target value" },
+            rate: { type: "number", required: false, description: "Rate (units per day)" },
+            initval: { type: "number", required: false, description: "Initial value (default: 0)" },
+            secret: { type: "boolean", required: false, description: "Secret goal" },
+            datapublic: { type: "boolean", required: false, description: "Public data" },
+            datasource: { type: "string", required: false, description: "Data source: api, ifttt, zapier, manual" },
+            dryrun: { type: "boolean", required: false, description: "Test without creating" },
+            tags: { type: "array", required: false, description: "Array of tag strings" },
+        },
+        async execute(input, ctx) {
+            return apiRequest(getToken(ctx), "POST", "/users/me/goals.json", input);
+        },
+    });
+    rl.registerAction("goal.get", {
+        description: "Get a specific goal",
+        inputSchema: {
+            goalName: { type: "string", required: true, description: "Goal slug" },
+            datapoints: { type: "boolean", required: false, description: "Include datapoints" },
+            emaciated: { type: "boolean", required: false, description: "Strip road/roadall/fullroad attributes" },
+        },
+        async execute(input, ctx) {
+            const { goalName, ...qs } = input;
+            return apiRequest(getToken(ctx), "GET", `/users/me/goals/${goalName}.json`, undefined, qs);
+        },
+    });
+    rl.registerAction("goal.list", {
+        description: "List all goals",
+        inputSchema: {
+            emaciated: { type: "boolean", required: false, description: "Strip road attributes" },
+        },
+        async execute(input, ctx) {
+            const qs = (input ?? {});
+            return apiRequest(getToken(ctx), "GET", "/users/me/goals.json", undefined, qs);
+        },
+    });
+    rl.registerAction("goal.listArchived", {
+        description: "List archived goals",
+        inputSchema: {
+            emaciated: { type: "boolean", required: false, description: "Strip road attributes" },
+        },
+        async execute(input, ctx) {
+            const qs = (input ?? {});
+            return apiRequest(getToken(ctx), "GET", "/users/me/goals/archived.json", undefined, qs);
+        },
+    });
+    rl.registerAction("goal.update", {
+        description: "Update a goal",
+        inputSchema: {
+            goalName: { type: "string", required: true, description: "Goal slug" },
+            title: { type: "string", required: false, description: "New title" },
+            yaxis: { type: "string", required: false, description: "Y-axis label" },
+            tmin: { type: "string", required: false, description: "Min date (yyyy-mm-dd)" },
+            tmax: { type: "string", required: false, description: "Max date (yyyy-mm-dd)" },
+            secret: { type: "boolean", required: false, description: "Secret goal" },
+            datapublic: { type: "boolean", required: false, description: "Public data" },
+            roadall: { type: "array", required: false, description: "Road matrix [[date, value, rate], ...]" },
+            datasource: { type: "string", required: false, description: "Data source" },
+            tags: { type: "array", required: false, description: "Array of tag strings" },
+        },
+        async execute(input, ctx) {
+            const { goalName, ...body } = input;
+            return apiRequest(getToken(ctx), "PUT", `/users/me/goals/${goalName}.json`, body);
+        },
+    });
+    rl.registerAction("goal.refresh", {
+        description: "Refresh a goal's graph",
+        inputSchema: {
+            goalName: { type: "string", required: true, description: "Goal slug" },
+        },
+        async execute(input, ctx) {
+            const { goalName } = input;
+            return apiRequest(getToken(ctx), "GET", `/users/me/goals/${goalName}/refresh_graph.json`);
+        },
+    });
+    rl.registerAction("goal.shortCircuit", {
+        description: "Short-circuit a goal's pledge",
+        inputSchema: {
+            goalName: { type: "string", required: true, description: "Goal slug" },
+        },
+        async execute(input, ctx) {
+            const { goalName } = input;
+            return apiRequest(getToken(ctx), "POST", `/users/me/goals/${goalName}/shortcircuit.json`);
+        },
+    });
+    rl.registerAction("goal.stepDown", {
+        description: "Step down a goal's pledge",
+        inputSchema: {
+            goalName: { type: "string", required: true, description: "Goal slug" },
+        },
+        async execute(input, ctx) {
+            const { goalName } = input;
+            return apiRequest(getToken(ctx), "POST", `/users/me/goals/${goalName}/stepdown.json`);
+        },
+    });
+    rl.registerAction("goal.cancelStepDown", {
+        description: "Cancel a step-down on a goal's pledge",
+        inputSchema: {
+            goalName: { type: "string", required: true, description: "Goal slug" },
+        },
+        async execute(input, ctx) {
+            const { goalName } = input;
+            return apiRequest(getToken(ctx), "POST", `/users/me/goals/${goalName}/cancel_stepdown.json`);
+        },
+    });
+    rl.registerAction("goal.uncle", {
+        description: "Derail a goal and charge the pledge amount",
+        inputSchema: {
+            goalName: { type: "string", required: true, description: "Goal slug" },
+        },
+        async execute(input, ctx) {
+            const { goalName } = input;
+            return apiRequest(getToken(ctx), "POST", `/users/me/goals/${goalName}/uncleme.json`);
+        },
+    });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.get", {
+        description: "Get current user information",
+        inputSchema: {
+            associations: { type: "boolean", required: false, description: "Include associations" },
+            diff_since: { type: "number", required: false, description: "Unix timestamp — only return goals/datapoints changed since" },
+            skinny: { type: "boolean", required: false, description: "Minimal user data" },
+            emaciated: { type: "boolean", required: false, description: "Strip road attributes from goals" },
+            datapoints_count: { type: "number", required: false, description: "Number of datapoints to include" },
+        },
+        async execute(input, ctx) {
+            const qs = (input ?? {});
+            return apiRequest(getToken(ctx), "GET", "/users/me.json", undefined, qs);
+        },
+    });
+}

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

@@ -0,0 +1,107 @@
+const BASE_URL = "https://api-ssl.bitly.com/v4";
+async function apiRequest(token, method, endpoint, body) {
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(`${BASE_URL}${endpoint}`, opts);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Bitly API error ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+function getToken(ctx) {
+    return ctx.connection.config.accessToken;
+}
+export default function bitly(rl) {
+    rl.setName("bitly");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: {
+            type: "string",
+            required: true,
+            description: "Bitly access token",
+            env: "BITLY_ACCESS_TOKEN",
+        },
+    });
+    rl.registerAction("link.create", {
+        description: "Create a shortened link (bitlink)",
+        inputSchema: {
+            longUrl: { type: "string", required: true, description: "Long URL to shorten" },
+            title: { type: "string", required: false, description: "Title for the link" },
+            domain: { type: "string", required: false, description: "Custom domain (default: bit.ly)" },
+            group: { type: "string", required: false, description: "Group GUID" },
+            tags: { type: "array", required: false, description: "Array of tag strings" },
+            deeplinks: {
+                type: "array",
+                required: false,
+                description: "Array of {app_uri_path, install_type, install_url, app_id}",
+            },
+        },
+        async execute(input, ctx) {
+            const { longUrl, title, domain, group, tags, deeplinks } = (input ?? {});
+            const body = { long_url: longUrl };
+            if (title)
+                body.title = title;
+            if (domain)
+                body.domain = domain;
+            if (group)
+                body.group = group;
+            if (tags)
+                body.tags = tags;
+            if (deeplinks)
+                body.deeplinks = deeplinks;
+            return apiRequest(getToken(ctx), "POST", "/bitlinks", body);
+        },
+    });
+    rl.registerAction("link.get", {
+        description: "Get a bitlink by ID",
+        inputSchema: {
+            bitlink: { type: "string", required: true, description: "Bitlink (e.g. bit.ly/22u3ypK)" },
+        },
+        async execute(input, ctx) {
+            const { bitlink } = input;
+            return apiRequest(getToken(ctx), "GET", `/bitlinks/${bitlink}`);
+        },
+    });
+    rl.registerAction("link.update", {
+        description: "Update a bitlink",
+        inputSchema: {
+            bitlink: { type: "string", required: true, description: "Bitlink (e.g. bit.ly/22u3ypK)" },
+            longUrl: { type: "string", required: false, description: "New long URL" },
+            title: { type: "string", required: false, description: "New title" },
+            archived: { type: "boolean", required: false, description: "Archive the link" },
+            group: { type: "string", required: false, description: "Group GUID" },
+            tags: { type: "array", required: false, description: "Array of tag strings" },
+            deeplinks: {
+                type: "array",
+                required: false,
+                description: "Array of {app_uri_path, install_type, install_url, app_id}",
+            },
+        },
+        async execute(input, ctx) {
+            const { bitlink, longUrl, title, archived, group, tags, deeplinks } = (input ?? {});
+            const body = {};
+            if (longUrl)
+                body.long_url = longUrl;
+            if (title)
+                body.title = title;
+            if (archived !== undefined)
+                body.archived = archived;
+            if (group)
+                body.group = group;
+            if (tags)
+                body.tags = tags;
+            if (deeplinks)
+                body.deeplinks = deeplinks;
+            return apiRequest(getToken(ctx), "PATCH", `/bitlinks/${bitlink}`, body);
+        },
+    });
+}