runline 0.1.0

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

@@ -0,0 +1,327 @@
+const BASE_URL = "https://coda.io/apis/v1";
+async function apiRequest(token, method, endpoint, body, qs) {
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    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", Authorization: `Bearer ${token}` },
+    };
+    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)
+        throw new Error(`Coda API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+async function paginateAll(token, endpoint, qs, limit) {
+    const results = [];
+    let pageToken;
+    while (true) {
+        const q = { ...qs };
+        if (pageToken)
+            q.pageToken = pageToken;
+        const data = (await apiRequest(token, "GET", endpoint, undefined, q));
+        const items = data.items ?? [];
+        results.push(...items);
+        if (limit && results.length >= limit)
+            return results.slice(0, limit);
+        if (!data.nextPageToken)
+            break;
+        pageToken = data.nextPageToken;
+    }
+    return results;
+}
+function getToken(ctx) {
+    return ctx.connection.config.accessToken;
+}
+export default function coda(rl) {
+    rl.setName("coda");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: {
+            type: "string",
+            required: true,
+            description: "Coda API token",
+            env: "CODA_ACCESS_TOKEN",
+        },
+    });
+    // ── Table Row ───────────────────────────────────────
+    rl.registerAction("table.createRow", {
+        description: "Create/upsert a row in a table",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            tableId: { type: "string", required: true, description: "Table ID" },
+            cells: { type: "object", required: true, description: "Column-value pairs" },
+            keyColumns: { type: "array", required: false, description: "Key columns for upsert" },
+            disableParsing: { type: "boolean", required: false, description: "Disable value parsing" },
+        },
+        async execute(input, ctx) {
+            const { docId, tableId, cells, keyColumns, disableParsing } = input;
+            const qs = {};
+            if (disableParsing)
+                qs.disableParsing = true;
+            const row = Object.entries(cells).map(([column, value]) => ({ column, value }));
+            const body = { rows: [{ cells: row }] };
+            if (keyColumns)
+                body.keyColumns = keyColumns;
+            return apiRequest(getToken(ctx), "POST", `/docs/${docId}/tables/${tableId}/rows`, body, qs);
+        },
+    });
+    rl.registerAction("table.getRow", {
+        description: "Get a row by ID",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            tableId: { type: "string", required: true, description: "Table ID" },
+            rowId: { type: "string", required: true, description: "Row ID or name" },
+            useColumnNames: { type: "boolean", required: false, description: "Use column names (default: true)" },
+            valueFormat: { type: "string", required: false, description: "Value format: simple, simpleWithArrays, rich" },
+        },
+        async execute(input, ctx) {
+            const { docId, tableId, rowId, useColumnNames = true, valueFormat } = input;
+            const qs = { useColumnNames };
+            if (valueFormat)
+                qs.valueFormat = valueFormat;
+            const data = (await apiRequest(getToken(ctx), "GET", `/docs/${docId}/tables/${tableId}/rows/${rowId}`, undefined, qs));
+            return { id: data.id, ...data.values };
+        },
+    });
+    rl.registerAction("table.listRows", {
+        description: "List rows in a table",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            tableId: { type: "string", required: true, description: "Table ID" },
+            query: { type: "string", required: false, description: "Search query" },
+            sortBy: { type: "string", required: false, description: "Sort column" },
+            useColumnNames: { type: "boolean", required: false, description: "Use column names (default: true)" },
+            valueFormat: { type: "string", required: false, description: "Value format" },
+            visibleOnly: { type: "boolean", required: false, description: "Only visible rows" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { docId, tableId, query, sortBy, useColumnNames = true, valueFormat, visibleOnly, limit } = (input ?? {});
+            const qs = { useColumnNames };
+            if (query)
+                qs.query = query;
+            if (sortBy)
+                qs.sortBy = sortBy;
+            if (valueFormat)
+                qs.valueFormat = valueFormat;
+            if (visibleOnly)
+                qs.visibleOnly = visibleOnly;
+            const rows = await paginateAll(getToken(ctx), `/docs/${docId}/tables/${tableId}/rows`, qs, limit);
+            return rows.map((r) => {
+                const row = r;
+                return { id: row.id, ...row.values };
+            });
+        },
+    });
+    rl.registerAction("table.deleteRow", {
+        description: "Delete a row",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            tableId: { type: "string", required: true, description: "Table ID" },
+            rowId: { type: "string", required: true, description: "Row ID" },
+        },
+        async execute(input, ctx) {
+            const { docId, tableId, rowId } = input;
+            return apiRequest(getToken(ctx), "DELETE", `/docs/${docId}/tables/${tableId}/rows`, { rowIds: [rowId] });
+        },
+    });
+    rl.registerAction("table.pushButton", {
+        description: "Push a button on a row",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            tableId: { type: "string", required: true, description: "Table ID" },
+            rowId: { type: "string", required: true, description: "Row ID" },
+            columnId: { type: "string", required: true, description: "Button column ID" },
+        },
+        async execute(input, ctx) {
+            const { docId, tableId, rowId, columnId } = input;
+            return apiRequest(getToken(ctx), "POST", `/docs/${docId}/tables/${tableId}/rows/${rowId}/buttons/${columnId}`);
+        },
+    });
+    // ── Table Column ────────────────────────────────────
+    rl.registerAction("table.getColumn", {
+        description: "Get a column",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            tableId: { type: "string", required: true, description: "Table ID" },
+            columnId: { type: "string", required: true, description: "Column ID" },
+        },
+        async execute(input, ctx) {
+            const { docId, tableId, columnId } = input;
+            return apiRequest(getToken(ctx), "GET", `/docs/${docId}/tables/${tableId}/columns/${columnId}`);
+        },
+    });
+    rl.registerAction("table.listColumns", {
+        description: "List columns in a table",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            tableId: { type: "string", required: true, description: "Table ID" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { docId, tableId, limit } = (input ?? {});
+            return paginateAll(getToken(ctx), `/docs/${docId}/tables/${tableId}/columns`, undefined, limit);
+        },
+    });
+    // ── Formula ─────────────────────────────────────────
+    rl.registerAction("formula.get", {
+        description: "Get a formula",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            formulaId: { type: "string", required: true, description: "Formula ID" },
+        },
+        async execute(input, ctx) {
+            const { docId, formulaId } = input;
+            return apiRequest(getToken(ctx), "GET", `/docs/${docId}/formulas/${formulaId}`);
+        },
+    });
+    rl.registerAction("formula.list", {
+        description: "List formulas in a doc",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { docId, limit } = (input ?? {});
+            return paginateAll(getToken(ctx), `/docs/${docId}/formulas`, undefined, limit);
+        },
+    });
+    // ── Control ─────────────────────────────────────────
+    rl.registerAction("control.get", {
+        description: "Get a control",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            controlId: { type: "string", required: true, description: "Control ID" },
+        },
+        async execute(input, ctx) {
+            const { docId, controlId } = input;
+            return apiRequest(getToken(ctx), "GET", `/docs/${docId}/controls/${controlId}`);
+        },
+    });
+    rl.registerAction("control.list", {
+        description: "List controls in a doc",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { docId, limit } = (input ?? {});
+            return paginateAll(getToken(ctx), `/docs/${docId}/controls`, undefined, limit);
+        },
+    });
+    // ── View ────────────────────────────────────────────
+    rl.registerAction("view.get", {
+        description: "Get a view",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            viewId: { type: "string", required: true, description: "View ID" },
+        },
+        async execute(input, ctx) {
+            const { docId, viewId } = input;
+            return apiRequest(getToken(ctx), "GET", `/docs/${docId}/tables/${viewId}`);
+        },
+    });
+    rl.registerAction("view.list", {
+        description: "List views in a doc",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { docId, limit } = (input ?? {});
+            return paginateAll(getToken(ctx), `/docs/${docId}/tables`, { tableTypes: "view" }, limit);
+        },
+    });
+    rl.registerAction("view.listRows", {
+        description: "List rows in a view",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            viewId: { type: "string", required: true, description: "View ID" },
+            query: { type: "string", required: false, description: "Search query" },
+            sortBy: { type: "string", required: false, description: "Sort column" },
+            useColumnNames: { type: "boolean", required: false, description: "Use column names (default: true)" },
+            valueFormat: { type: "string", required: false, description: "Value format" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { docId, viewId, query, sortBy, useColumnNames = true, valueFormat, limit } = (input ?? {});
+            const qs = { useColumnNames };
+            if (query)
+                qs.query = query;
+            if (sortBy)
+                qs.sortBy = sortBy;
+            if (valueFormat)
+                qs.valueFormat = valueFormat;
+            const rows = await paginateAll(getToken(ctx), `/docs/${docId}/tables/${viewId}/rows`, qs, limit);
+            return rows.map((r) => {
+                const row = r;
+                return { id: row.id, ...row.values };
+            });
+        },
+    });
+    rl.registerAction("view.deleteRow", {
+        description: "Delete a row from a view",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            viewId: { type: "string", required: true, description: "View ID" },
+            rowId: { type: "string", required: true, description: "Row ID" },
+        },
+        async execute(input, ctx) {
+            const { docId, viewId, rowId } = input;
+            return apiRequest(getToken(ctx), "DELETE", `/docs/${docId}/tables/${viewId}/rows/${rowId}`);
+        },
+    });
+    rl.registerAction("view.updateRow", {
+        description: "Update a row in a view",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            viewId: { type: "string", required: true, description: "View ID" },
+            rowId: { type: "string", required: true, description: "Row ID" },
+            cells: { type: "object", required: true, description: "Column-value pairs to update" },
+            disableParsing: { type: "boolean", required: false, description: "Disable value parsing" },
+        },
+        async execute(input, ctx) {
+            const { docId, viewId, rowId, cells, disableParsing } = input;
+            const qs = {};
+            if (disableParsing)
+                qs.disableParsing = true;
+            const row = Object.entries(cells).map(([column, value]) => ({ column, value }));
+            return apiRequest(getToken(ctx), "PUT", `/docs/${docId}/tables/${viewId}/rows/${rowId}`, { row: { cells: row } }, qs);
+        },
+    });
+    rl.registerAction("view.pushButton", {
+        description: "Push a button on a view row",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            viewId: { type: "string", required: true, description: "View ID" },
+            rowId: { type: "string", required: true, description: "Row ID" },
+            columnId: { type: "string", required: true, description: "Button column ID" },
+        },
+        async execute(input, ctx) {
+            const { docId, viewId, rowId, columnId } = input;
+            return apiRequest(getToken(ctx), "POST", `/docs/${docId}/tables/${viewId}/rows/${rowId}/buttons/${columnId}`);
+        },
+    });
+    rl.registerAction("view.listColumns", {
+        description: "List columns in a view",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Doc ID" },
+            viewId: { type: "string", required: true, description: "View ID" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { docId, viewId, limit } = (input ?? {});
+            return paginateAll(getToken(ctx), `/docs/${docId}/tables/${viewId}/columns`, undefined, limit);
+        },
+    });
+}

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

@@ -0,0 +1,244 @@
+const BASE_URL = "https://api.coingecko.com/api/v3";
+async function apiRequest(endpoint, qs, apiKey) {
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const headers = { Accept: "application/json" };
+    if (apiKey)
+        headers["x-cg-demo-api-key"] = apiKey;
+    const res = await fetch(url.toString(), { headers });
+    if (!res.ok)
+        throw new Error(`CoinGecko API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function coingecko(rl) {
+    rl.setName("coingecko");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: false,
+            description: "CoinGecko API key (optional for free tier)",
+            env: "COINGECKO_API_KEY",
+        },
+    });
+    function getKey(ctx) {
+        return ctx.connection.config.apiKey;
+    }
+    // ── Coin ────────────────────────────────────────────
+    rl.registerAction("coin.get", {
+        description: "Get detailed coin data by ID or contract address",
+        inputSchema: {
+            coinId: { type: "string", required: false, description: "Coin ID (e.g. bitcoin)" },
+            platformId: { type: "string", required: false, description: "Platform ID for contract lookup" },
+            contractAddress: { type: "string", required: false, description: "Contract address" },
+            communityData: { type: "boolean", required: false, description: "Include community data" },
+            developerData: { type: "boolean", required: false, description: "Include developer data" },
+            marketData: { type: "boolean", required: false, description: "Include market data" },
+            tickers: { type: "boolean", required: false, description: "Include tickers" },
+        },
+        async execute(input, ctx) {
+            const { coinId, platformId, contractAddress, communityData, developerData, marketData, tickers } = (input ?? {});
+            const qs = {
+                community_data: communityData ?? false,
+                developer_data: developerData ?? false,
+                localization: false,
+                market_data: marketData ?? false,
+                sparkline: false,
+                tickers: tickers ?? false,
+            };
+            if (contractAddress && platformId) {
+                return apiRequest(`/coins/${platformId}/contract/${contractAddress}`, qs, getKey(ctx));
+            }
+            return apiRequest(`/coins/${coinId}`, qs, getKey(ctx));
+        },
+    });
+    rl.registerAction("coin.list", {
+        description: "List all supported coins",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const data = (await apiRequest("/coins/list", undefined, getKey(ctx)));
+            if (limit)
+                return data.slice(0, limit);
+            return data;
+        },
+    });
+    rl.registerAction("coin.market", {
+        description: "Get coin market data (price, mcap, volume) for multiple coins",
+        inputSchema: {
+            vsCurrency: { type: "string", required: true, description: "Quote currency (e.g. usd)" },
+            ids: { type: "string", required: false, description: "Comma-separated coin IDs" },
+            category: { type: "string", required: false, description: "Category filter" },
+            order: { type: "string", required: false, description: "Sort order" },
+            priceChangePercentage: { type: "string", required: false, description: "Comma-separated periods (1h,24h,7d,14d,30d,200d,1y)" },
+            limit: { type: "number", required: false, description: "Max results (default: 100)" },
+        },
+        async execute(input, ctx) {
+            const { vsCurrency, ids, category, order, priceChangePercentage, limit } = (input ?? {});
+            const qs = { vs_currency: vsCurrency };
+            if (ids)
+                qs.ids = ids;
+            if (category)
+                qs.category = category;
+            if (order)
+                qs.order = order;
+            if (priceChangePercentage)
+                qs.price_change_percentage = priceChangePercentage;
+            if (limit)
+                qs.per_page = limit;
+            return apiRequest("/coins/markets", qs, getKey(ctx));
+        },
+    });
+    rl.registerAction("coin.price", {
+        description: "Get simple price for coins",
+        inputSchema: {
+            ids: { type: "string", required: true, description: "Comma-separated coin IDs" },
+            vsCurrencies: { type: "string", required: true, description: "Comma-separated quote currencies" },
+            includeMarketCap: { type: "boolean", required: false, description: "Include market cap" },
+            include24hrVol: { type: "boolean", required: false, description: "Include 24h volume" },
+            include24hrChange: { type: "boolean", required: false, description: "Include 24h change" },
+        },
+        async execute(input, ctx) {
+            const { ids, vsCurrencies, includeMarketCap, include24hrVol, include24hrChange } = (input ?? {});
+            const qs = {
+                ids,
+                vs_currencies: vsCurrencies,
+            };
+            if (includeMarketCap)
+                qs.include_market_cap = true;
+            if (include24hrVol)
+                qs.include_24hr_vol = true;
+            if (include24hrChange)
+                qs.include_24hr_change = true;
+            return apiRequest("/simple/price", qs, getKey(ctx));
+        },
+    });
+    rl.registerAction("coin.tokenPrice", {
+        description: "Get token price by contract address",
+        inputSchema: {
+            platformId: { type: "string", required: true, description: "Platform ID (e.g. ethereum)" },
+            contractAddresses: { type: "string", required: true, description: "Comma-separated contract addresses" },
+            vsCurrencies: { type: "string", required: true, description: "Comma-separated quote currencies" },
+        },
+        async execute(input, ctx) {
+            const { platformId, contractAddresses, vsCurrencies } = input;
+            return apiRequest(`/simple/token_price/${platformId}`, {
+                contract_addresses: contractAddresses,
+                vs_currencies: vsCurrencies,
+            }, getKey(ctx));
+        },
+    });
+    rl.registerAction("coin.ticker", {
+        description: "Get tickers for a coin",
+        inputSchema: {
+            coinId: { type: "string", required: true, description: "Coin ID" },
+            exchangeIds: { type: "string", required: false, description: "Comma-separated exchange IDs" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { coinId, exchangeIds, limit } = (input ?? {});
+            const qs = {};
+            if (exchangeIds)
+                qs.exchange_ids = exchangeIds;
+            const data = (await apiRequest(`/coins/${coinId}/tickers`, qs, getKey(ctx)));
+            const tickers = data.tickers ?? [];
+            if (limit)
+                return tickers.slice(0, limit);
+            return tickers;
+        },
+    });
+    rl.registerAction("coin.history", {
+        description: "Get historical data for a coin on a specific date",
+        inputSchema: {
+            coinId: { type: "string", required: true, description: "Coin ID" },
+            date: { type: "string", required: true, description: "Date (DD-MM-YYYY format)" },
+            localization: { type: "boolean", required: false, description: "Include localized languages" },
+        },
+        async execute(input, ctx) {
+            const { coinId, date, localization } = input;
+            const qs = { date };
+            if (localization !== undefined)
+                qs.localization = localization;
+            return apiRequest(`/coins/${coinId}/history`, qs, getKey(ctx));
+        },
+    });
+    rl.registerAction("coin.marketChart", {
+        description: "Get price, market cap, and volume chart data",
+        inputSchema: {
+            coinId: { type: "string", required: false, description: "Coin ID" },
+            platformId: { type: "string", required: false, description: "Platform ID (for contract)" },
+            contractAddress: { type: "string", required: false, description: "Contract address" },
+            vsCurrency: { type: "string", required: true, description: "Quote currency" },
+            days: { type: "string", required: true, description: "Number of days (1, 7, 14, 30, 90, 180, 365, max)" },
+        },
+        async execute(input, ctx) {
+            const { coinId, platformId, contractAddress, vsCurrency, days } = input;
+            const qs = { vs_currency: vsCurrency, days };
+            let endpoint;
+            if (contractAddress && platformId) {
+                endpoint = `/coins/${platformId}/contract/${contractAddress}/market_chart`;
+            }
+            else {
+                endpoint = `/coins/${coinId}/market_chart`;
+            }
+            const data = (await apiRequest(endpoint, qs, getKey(ctx)));
+            const prices = data.prices ?? [];
+            return prices.map((p, idx) => ({
+                time: new Date(p[0]).toISOString(),
+                price: p[1],
+                marketCap: (data.market_caps?.[idx] ?? [])[1],
+                totalVolume: (data.total_volumes?.[idx] ?? [])[1],
+            }));
+        },
+    });
+    rl.registerAction("coin.candlestick", {
+        description: "Get OHLC candlestick data",
+        inputSchema: {
+            coinId: { type: "string", required: true, description: "Coin ID" },
+            vsCurrency: { type: "string", required: true, description: "Quote currency" },
+            days: { type: "string", required: true, description: "Number of days (1, 7, 14, 30, 90, 180, 365, max)" },
+        },
+        async execute(input, ctx) {
+            const { coinId, vsCurrency, days } = input;
+            const data = (await apiRequest(`/coins/${coinId}/ohlc`, {
+                vs_currency: vsCurrency,
+                days,
+            }, getKey(ctx)));
+            return data.map(([time, open, high, low, close]) => ({
+                time: new Date(time).toISOString(),
+                open,
+                high,
+                low,
+                close,
+            }));
+        },
+    });
+    // ── Event ───────────────────────────────────────────
+    rl.registerAction("event.list", {
+        description: "List crypto events",
+        inputSchema: {
+            countryCode: { type: "string", required: false, description: "Country code filter" },
+            type: { type: "string", required: false, description: "Event type filter" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { countryCode, type, limit } = (input ?? {});
+            const qs = {};
+            if (countryCode)
+                qs.country_code = countryCode;
+            if (type)
+                qs.type = type;
+            if (limit)
+                qs.per_page = limit;
+            const data = (await apiRequest("/events", qs, getKey(ctx)));
+            return data.data;
+        },
+    });
+}