runline 0.1.0

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

@@ -0,0 +1,123 @@
+const BASE = "https://api.twitter.com/2";
+async function api(token, method, endpoint, body, qs, fullOutput = false) {
+    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}`, "Content-Type": "application/json" } };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`Twitter error ${res.status}: ${await res.text()}`);
+    const json = await res.json();
+    return fullOutput ? json : json.data;
+}
+async function paginate(token, endpoint, qs = {}, limit) {
+    const results = [];
+    let nextToken;
+    qs.max_results = limit && limit < 100 ? limit : 10;
+    do {
+        if (nextToken)
+            qs.next_token = nextToken;
+        const res = await api(token, "GET", endpoint, undefined, { ...qs }, true);
+        const data = res.data;
+        if (data)
+            results.push(...data);
+        nextToken = res.meta?.next_token;
+        if (limit && results.length >= limit) {
+            return results.slice(0, limit);
+        }
+    } while (nextToken);
+    return results;
+}
+export default function twitter(rl) {
+    rl.setName("twitter");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ bearerToken: { type: "string", required: true, description: "OAuth2 Bearer token for Twitter/X API v2", env: "TWITTER_BEARER_TOKEN" } });
+    const t = (ctx) => ctx.connection.config.bearerToken;
+    // ── Tweet ───────────────────────────────────────────
+    rl.registerAction("tweet.create", { description: "Create a tweet (post, quote, or reply)",
+        inputSchema: { text: { type: "string", required: true }, quoteTweetId: { type: "string", required: false, description: "Tweet ID to quote" }, replyToTweetId: { type: "string", required: false, description: "Tweet ID to reply to" }, mediaId: { type: "string", required: false }, placeId: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { text: p.text };
+            if (p.quoteTweetId)
+                body.quote_tweet_id = p.quoteTweetId;
+            if (p.replyToTweetId)
+                body.reply = { in_reply_to_tweet_id: p.replyToTweetId };
+            if (p.mediaId)
+                body.media = { media_ids: [p.mediaId] };
+            if (p.placeId)
+                body.geo = { place_id: p.placeId };
+            return api(t(ctx), "POST", "/tweets", body);
+        } });
+    rl.registerAction("tweet.delete", { description: "Delete a tweet", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(t(ctx), "DELETE", `/tweets/${input.id}`); } });
+    rl.registerAction("tweet.like", { description: "Like a tweet (requires user context)",
+        inputSchema: { tweetId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const user = await api(t(ctx), "GET", "/users/me");
+            return api(t(ctx), "POST", `/users/${user.id}/likes`, { tweet_id: input.tweetId });
+        } });
+    rl.registerAction("tweet.retweet", { description: "Retweet a tweet (requires user context)",
+        inputSchema: { tweetId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const user = await api(t(ctx), "GET", "/users/me");
+            return api(t(ctx), "POST", `/users/${user.id}/retweets`, { tweet_id: input.tweetId });
+        } });
+    rl.registerAction("tweet.search", { description: "Search recent tweets (last 7 days)",
+        inputSchema: { query: { type: "string", required: true }, limit: { type: "number", required: false, description: "Max results (default all)" }, sortOrder: { type: "string", required: false, description: "recency or relevancy" }, startTime: { type: "string", required: false, description: "ISO datetime" }, endTime: { type: "string", required: false, description: "ISO datetime" }, tweetFields: { type: "string", required: false, description: "Comma-separated fields like author_id,created_at,public_metrics" } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = { query: p.query };
+            if (p.sortOrder)
+                qs.sort_order = p.sortOrder;
+            if (p.startTime)
+                qs.start_time = p.startTime;
+            if (p.endTime)
+                qs.end_time = p.endTime;
+            if (p.tweetFields)
+                qs["tweet.fields"] = p.tweetFields;
+            const limit = p.limit;
+            if (limit) {
+                return paginate(t(ctx), "/tweets/search/recent", qs, limit);
+            }
+            return paginate(t(ctx), "/tweets/search/recent", qs);
+        } });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.get", { description: "Get a user by username or ID",
+        inputSchema: { username: { type: "string", required: false, description: "Username (without @)" }, id: { type: "string", required: false, description: "User ID" }, me: { type: "boolean", required: false, description: "Get the authenticated user" } },
+        async execute(input, ctx) {
+            const p = input;
+            if (p.me)
+                return api(t(ctx), "GET", "/users/me");
+            if (p.username) {
+                const name = p.username.replace(/^@/, "");
+                return api(t(ctx), "GET", `/users/by/username/${name}`);
+            }
+            if (p.id)
+                return api(t(ctx), "GET", `/users/${p.id}`);
+            throw new Error("Provide username, id, or set me=true");
+        } });
+    // ── List ────────────────────────────────────────────
+    rl.registerAction("list.addMember", { description: "Add a user to a list",
+        inputSchema: { listId: { type: "string", required: true }, userId: { type: "string", required: true, description: "User ID to add" } },
+        async execute(input, ctx) {
+            const p = input;
+            return api(t(ctx), "POST", `/lists/${p.listId}/members`, { user_id: p.userId });
+        } });
+    // ── Direct Message ──────────────────────────────────
+    rl.registerAction("dm.create", { description: "Send a direct message to a user",
+        inputSchema: { userId: { type: "string", required: true, description: "Recipient user ID" }, text: { type: "string", required: true }, mediaId: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { text: p.text };
+            if (p.mediaId)
+                body.attachments = [{ media_id: p.mediaId }];
+            return api(t(ctx), "POST", `/dm_conversations/with/${p.userId}/messages`, body);
+        } });
+}

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

@@ -0,0 +1,84 @@
+import { createHmac } from "node:crypto";
+const BASE = "https://api.unleashedsoftware.com";
+function getConn(ctx) {
+    return { apiId: ctx.connection.config.apiId, apiKey: ctx.connection.config.apiKey };
+}
+function buildQs(params) {
+    const parts = [];
+    for (const [k, v] of Object.entries(params)) {
+        if (v !== undefined && v !== null)
+            parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+    }
+    return parts.join("&");
+}
+async function apiRequest(conn, method, endpoint, qs, page) {
+    const path = page ? `${endpoint}/${page}` : endpoint;
+    const qsString = qs ? buildQs(qs) : "";
+    const signature = createHmac("sha256", conn.apiKey).update(qsString).digest("base64");
+    const url = qsString ? `${BASE}${path}?${qsString}` : `${BASE}${path}`;
+    const res = await fetch(url, {
+        method,
+        headers: { Accept: "application/json", "Content-Type": "application/json", "api-auth-id": conn.apiId, "api-auth-signature": signature },
+    });
+    if (!res.ok)
+        throw new Error(`Unleashed error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function unleashedSoftware(rl) {
+    rl.setName("unleashedSoftware");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiId: { type: "string", required: true, description: "Unleashed API ID", env: "UNLEASHED_API_ID" },
+        apiKey: { type: "string", required: true, description: "Unleashed API Key", env: "UNLEASHED_API_KEY" },
+    });
+    rl.registerAction("salesOrder.list", {
+        description: "List sales orders",
+        inputSchema: {
+            limit: { type: "number", required: false },
+            startDate: { type: "string", required: false, description: "YYYY-MM-DD" },
+            endDate: { type: "string", required: false, description: "YYYY-MM-DD" },
+            orderStatus: { type: "string", required: false, description: "Comma-separated statuses" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.startDate)
+                qs.startDate = p.startDate;
+            if (p.endDate)
+                qs.endDate = p.endDate;
+            if (p.orderStatus)
+                qs.orderStatus = p.orderStatus;
+            if (p.limit)
+                qs.pageSize = p.limit;
+            const data = (await apiRequest(getConn(ctx), "GET", "/SalesOrders", qs, 1));
+            return data.Items;
+        },
+    });
+    rl.registerAction("stockOnHand.list", {
+        description: "List stock on hand",
+        inputSchema: {
+            limit: { type: "number", required: false },
+            asAtDate: { type: "string", required: false, description: "YYYY-MM-DD" },
+            productCode: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.asAtDate)
+                qs.asAtDate = p.asAtDate;
+            if (p.productCode)
+                qs.productCode = p.productCode;
+            if (p.limit)
+                qs.pageSize = p.limit;
+            const data = (await apiRequest(getConn(ctx), "GET", "/StockOnHand", qs, 1));
+            return data.Items;
+        },
+    });
+    rl.registerAction("stockOnHand.get", {
+        description: "Get stock on hand for a product",
+        inputSchema: { productId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return apiRequest(getConn(ctx), "GET", `/StockOnHand/${input.productId}`);
+        },
+    });
+}

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

@@ -0,0 +1,59 @@
+const BASE = "https://api.uplead.com/v2";
+async function apiRequest(apiKey, 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: apiKey } });
+    if (!res.ok)
+        throw new Error(`Uplead error ${res.status}: ${await res.text()}`);
+    const data = (await res.json());
+    return data.data;
+}
+export default function uplead(rl) {
+    rl.setName("uplead");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Uplead API key", env: "UPLEAD_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    rl.registerAction("person.enrich", {
+        description: "Enrich a person by email or name+domain",
+        inputSchema: {
+            email: { type: "string", required: false },
+            firstName: { type: "string", required: false },
+            lastName: { type: "string", required: false },
+            domain: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.email)
+                qs.email = p.email;
+            if (p.firstName)
+                qs.first_name = p.firstName;
+            if (p.lastName)
+                qs.last_name = p.lastName;
+            if (p.domain)
+                qs.domain = p.domain;
+            return apiRequest(key(ctx), "/person-search", qs);
+        },
+    });
+    rl.registerAction("company.enrich", {
+        description: "Enrich a company by domain or name",
+        inputSchema: {
+            domain: { type: "string", required: false },
+            company: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.domain)
+                qs.domain = p.domain;
+            if (p.company)
+                qs.company = p.company;
+            return apiRequest(key(ctx), "/company-search", qs);
+        },
+    });
+}

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

@@ -0,0 +1,34 @@
+export default function uproc(rl) {
+    rl.setName("uproc");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        email: { type: "string", required: true, description: "uProc account email", env: "UPROC_EMAIL" },
+        apiKey: { type: "string", required: true, description: "uProc API key", env: "UPROC_API_KEY" },
+    });
+    rl.registerAction("process.run", {
+        description: "Run a uProc data processor tool",
+        inputSchema: {
+            processor: { type: "string", required: true, description: "Processor key (e.g. get-email-from-name-and-domain)" },
+            params: { type: "object", required: true, description: "Processor parameters as key-value pairs" },
+            dataWebhook: { type: "string", required: false, description: "URL for async callback" },
+        },
+        async execute(input, ctx) {
+            const c = ctx.connection.config;
+            const p = input;
+            const body = { processor: p.processor, params: p.params };
+            if (p.dataWebhook)
+                body.callback = { data: p.dataWebhook };
+            const res = await fetch("https://api.uproc.io/api/v2/process", {
+                method: "POST",
+                headers: {
+                    Authorization: `Basic ${btoa(`${c.email}:${c.apiKey}`)}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok)
+                throw new Error(`uProc error ${res.status}: ${await res.text()}`);
+            return res.json();
+        },
+    });
+}

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

@@ -0,0 +1,264 @@
+const BASE = "https://api.uptimerobot.com/v2";
+async function apiRequest(apiKey, endpoint, body = {}) {
+    const form = new URLSearchParams();
+    form.set("api_key", apiKey);
+    for (const [k, v] of Object.entries(body)) {
+        if (v !== undefined && v !== null)
+            form.set(k, String(v));
+    }
+    const res = await fetch(`${BASE}${endpoint}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: form,
+    });
+    if (!res.ok)
+        throw new Error(`UptimeRobot error ${res.status}: ${await res.text()}`);
+    const data = (await res.json());
+    if (data.stat !== "ok")
+        throw new Error(`UptimeRobot error: ${JSON.stringify(data)}`);
+    return data;
+}
+export default function uptimerobot(rl) {
+    rl.setName("uptimerobot");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({ apiKey: { type: "string", required: true, description: "UptimeRobot API key", env: "UPTIMEROBOT_API_KEY" } });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    // ── Account ─────────────────────────────────────────
+    rl.registerAction("account.get", {
+        description: "Get account details",
+        inputSchema: {},
+        async execute(_input, ctx) {
+            const data = (await apiRequest(key(ctx), "/getAccountDetails"));
+            return data.account;
+        },
+    });
+    // ── Monitor ─────────────────────────────────────────
+    rl.registerAction("monitor.create", {
+        description: "Create a monitor",
+        inputSchema: {
+            friendlyName: { type: "string", required: true },
+            url: { type: "string", required: true },
+            type: { type: "number", required: true, description: "1=HTTP(s), 2=Keyword, 3=Ping, 4=Port, 5=Heartbeat" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await apiRequest(key(ctx), "/newMonitor", { friendly_name: p.friendlyName, url: p.url, type: p.type }));
+            return data.monitor;
+        },
+    });
+    rl.registerAction("monitor.get", {
+        description: "Get a monitor by ID",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(key(ctx), "/getMonitors", { monitors: input.id }));
+            return data.monitors;
+        },
+    });
+    rl.registerAction("monitor.list", {
+        description: "List monitors",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const body = {};
+            if (p.limit)
+                body.limit = p.limit;
+            const data = (await apiRequest(key(ctx), "/getMonitors", body));
+            return data.monitors;
+        },
+    });
+    rl.registerAction("monitor.update", {
+        description: "Update a monitor",
+        inputSchema: { id: { type: "string", required: true }, friendlyName: { type: "string", required: false }, url: { type: "string", required: false }, type: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const body = { id };
+            if (fields.friendlyName)
+                body.friendly_name = fields.friendlyName;
+            if (fields.url)
+                body.url = fields.url;
+            if (fields.type)
+                body.type = fields.type;
+            const data = (await apiRequest(key(ctx), "/editMonitor", body));
+            return data.monitor;
+        },
+    });
+    rl.registerAction("monitor.delete", {
+        description: "Delete a monitor",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(key(ctx), "/deleteMonitor", { id: input.id }));
+            return data.monitor;
+        },
+    });
+    rl.registerAction("monitor.reset", {
+        description: "Reset a monitor's stats",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(key(ctx), "/resetMonitor", { id: input.id }));
+            return data.monitor;
+        },
+    });
+    // ── Alert Contact ───────────────────────────────────
+    rl.registerAction("alertContact.create", {
+        description: "Create an alert contact",
+        inputSchema: { friendlyName: { type: "string", required: true }, value: { type: "string", required: true, description: "Email or phone" }, type: { type: "number", required: true, description: "1=SMS, 2=Email, 3=Twitter, 5=Pushbullet, 11=Slack" } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await apiRequest(key(ctx), "/newAlertContact", { friendly_name: p.friendlyName, value: p.value, type: p.type }));
+            return data.alertcontact;
+        },
+    });
+    rl.registerAction("alertContact.get", {
+        description: "Get an alert contact by ID",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(key(ctx), "/getAlertContacts", { alert_contacts: input.id }));
+            return data.alert_contacts;
+        },
+    });
+    rl.registerAction("alertContact.list", {
+        description: "List alert contacts",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const body = {};
+            if (input?.limit)
+                body.limit = input.limit;
+            const data = (await apiRequest(key(ctx), "/getAlertContacts", body));
+            return data.alert_contacts;
+        },
+    });
+    rl.registerAction("alertContact.update", {
+        description: "Update an alert contact",
+        inputSchema: { id: { type: "string", required: true }, friendlyName: { type: "string", required: false }, value: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const body = { id };
+            if (fields.friendlyName)
+                body.friendly_name = fields.friendlyName;
+            if (fields.value)
+                body.value = fields.value;
+            const data = (await apiRequest(key(ctx), "/editAlertContact", body));
+            return data.alert_contact;
+        },
+    });
+    rl.registerAction("alertContact.delete", {
+        description: "Delete an alert contact",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(key(ctx), "/deleteAlertContact", { id: input.id }));
+            return data.alert_contact;
+        },
+    });
+    // ── Maintenance Window ──────────────────────────────
+    rl.registerAction("maintenanceWindow.create", {
+        description: "Create a maintenance window",
+        inputSchema: {
+            friendlyName: { type: "string", required: true },
+            type: { type: "number", required: true, description: "1=Once, 2=Daily, 3=Weekly, 4=Monthly" },
+            startTime: { type: "string", required: true, description: "ISO datetime for once, HH:mm for recurring" },
+            duration: { type: "number", required: true, description: "Duration in minutes" },
+            value: { type: "number", required: false, description: "Day of week (1-7) or month (1-28) for weekly/monthly" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { friendly_name: p.friendlyName, type: p.type, start_time: p.startTime, duration: p.duration };
+            if (p.value)
+                body.value = p.value;
+            const data = (await apiRequest(key(ctx), "/newMWindow", body));
+            return data.mwindow;
+        },
+    });
+    rl.registerAction("maintenanceWindow.get", {
+        description: "Get a maintenance window",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(key(ctx), "/getMWindows", { mwindows: input.id }));
+            return data.mwindows;
+        },
+    });
+    rl.registerAction("maintenanceWindow.list", {
+        description: "List maintenance windows",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const body = {};
+            if (input?.limit)
+                body.limit = input.limit;
+            const data = (await apiRequest(key(ctx), "/getMWindows", body));
+            return data.mwindows;
+        },
+    });
+    rl.registerAction("maintenanceWindow.update", {
+        description: "Update a maintenance window",
+        inputSchema: { id: { type: "string", required: true }, friendlyName: { type: "string", required: false }, duration: { type: "number", required: false }, startTime: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const body = { id };
+            if (fields.friendlyName)
+                body.friendly_name = fields.friendlyName;
+            if (fields.duration)
+                body.duration = fields.duration;
+            if (fields.startTime)
+                body.start_time = fields.startTime;
+            const data = (await apiRequest(key(ctx), "/editMWindow", body));
+            return data.mwindow;
+        },
+    });
+    rl.registerAction("maintenanceWindow.delete", {
+        description: "Delete a maintenance window",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return apiRequest(key(ctx), "/deleteMWindow", { id: input.id });
+        },
+    });
+    // ── Public Status Page ──────────────────────────────
+    rl.registerAction("publicStatusPage.create", {
+        description: "Create a public status page",
+        inputSchema: { friendlyName: { type: "string", required: true }, monitors: { type: "string", required: true, description: "Monitor IDs (comma-separated or 0 for all)" } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await apiRequest(key(ctx), "/newPSP", { friendly_name: p.friendlyName, monitors: p.monitors }));
+            return data.psp;
+        },
+    });
+    rl.registerAction("publicStatusPage.get", {
+        description: "Get a public status page",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(key(ctx), "/getPSPs", { psps: input.id }));
+            return data.psps;
+        },
+    });
+    rl.registerAction("publicStatusPage.list", {
+        description: "List public status pages",
+        inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const body = {};
+            if (input?.limit)
+                body.limit = input.limit;
+            const data = (await apiRequest(key(ctx), "/getPSPs", body));
+            return data.psps;
+        },
+    });
+    rl.registerAction("publicStatusPage.update", {
+        description: "Update a public status page",
+        inputSchema: { id: { type: "string", required: true }, friendlyName: { type: "string", required: false }, monitors: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const body = { id };
+            if (fields.friendlyName)
+                body.friendly_name = fields.friendlyName;
+            if (fields.monitors)
+                body.monitors = fields.monitors;
+            const data = (await apiRequest(key(ctx), "/editPSP", body));
+            return data.psp;
+        },
+    });
+    rl.registerAction("publicStatusPage.delete", {
+        description: "Delete a public status page",
+        inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await apiRequest(key(ctx), "/deletePSP", { id: input.id }));
+            return data.psp;
+        },
+    });
+}

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

@@ -0,0 +1,64 @@
+const BASE = "https://urlscan.io/api/v1";
+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: { "API-Key": apiKey, "Content-Type": "application/json" } };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`urlscan.io error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function urlscanio(rl) {
+    rl.setName("urlscanio");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "urlscan.io API key", env: "URLSCANIO_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    rl.registerAction("scan.perform", {
+        description: "Submit a URL for scanning",
+        inputSchema: {
+            url: { type: "string", required: true },
+            visibility: { type: "string", required: false, description: "public, private, or unlisted" },
+            tags: { type: "string", required: false, description: "Comma-separated tags (max 10)" },
+            customAgent: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { url: p.url };
+            if (p.visibility)
+                body.visibility = p.visibility;
+            if (p.tags)
+                body.tags = p.tags.split(",").map(t => t.trim());
+            if (p.customAgent)
+                body.customAgent = p.customAgent;
+            return apiRequest(key(ctx), "POST", "/scan", body);
+        },
+    });
+    rl.registerAction("scan.get", {
+        description: "Get scan results by ID",
+        inputSchema: { scanId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return apiRequest(key(ctx), "GET", `/result/${input.scanId}`);
+        },
+    });
+    rl.registerAction("scan.search", {
+        description: "Search scan results",
+        inputSchema: { query: { type: "string", required: false, description: "Search query" }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = { size: p.limit ?? 100 };
+            if (p.query)
+                qs.q = p.query;
+            const data = (await apiRequest(key(ctx), "GET", "/search", undefined, qs));
+            return data.results;
+        },
+    });
+}