runline 0.1.0

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

@@ -0,0 +1,104 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    const registryUrl = (c.registryUrl ?? "https://registry.npmjs.org").replace(/\/$/, "");
+    const token = c.token;
+    return { registryUrl, token };
+}
+async function apiRequest(conn, method, path, body, contentType) {
+    const headers = {};
+    if (conn.token)
+        headers.Authorization = `Bearer ${conn.token}`;
+    if (contentType)
+        headers["Content-Type"] = contentType;
+    else
+        headers["Content-Type"] = "application/json";
+    const init = { method, headers };
+    if (body !== undefined)
+        init.body = body;
+    const res = await fetch(`${conn.registryUrl}${path}`, init);
+    if (!res.ok)
+        throw new Error(`npm registry error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+export default function npm(rl) {
+    rl.setName("npm");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        registryUrl: { type: "string", required: false, description: "NPM registry URL (default: https://registry.npmjs.org)", env: "NPM_REGISTRY_URL" },
+        token: { type: "string", required: false, description: "NPM auth token (optional, needed for private packages and dist-tag updates)", env: "NPM_TOKEN" },
+    });
+    rl.registerAction("package.getMetadata", {
+        description: "Get metadata for a package at a specific version",
+        inputSchema: {
+            packageName: { type: "string", required: true, description: "Package name (e.g. lodash)" },
+            version: { type: "string", required: false, description: "Version or tag (default: latest)" },
+        },
+        async execute(input, ctx) {
+            const { packageName, version } = input;
+            const v = version || "latest";
+            return apiRequest(getConn(ctx), "GET", `/${encodeURIComponent(packageName)}/${v}`);
+        },
+    });
+    rl.registerAction("package.getVersions", {
+        description: "Get all versions for a package with publish dates",
+        inputSchema: {
+            packageName: { type: "string", required: true, description: "Package name" },
+        },
+        async execute(input, ctx) {
+            const { packageName } = input;
+            const data = (await apiRequest(getConn(ctx), "GET", `/${encodeURIComponent(packageName)}`));
+            const time = (data.time ?? {});
+            const versions = Object.entries(time)
+                .filter(([v]) => /^\d+\.\d+\.\d+/.test(v))
+                .map(([version, published_at]) => ({ version, published_at }))
+                .sort((a, b) => new Date(b.published_at).getTime() - new Date(a.published_at).getTime());
+            return versions;
+        },
+    });
+    rl.registerAction("package.search", {
+        description: "Search for packages on the npm registry",
+        inputSchema: {
+            query: { type: "string", required: true, description: "Search query" },
+            limit: { type: "number", required: false, description: "Max results (default 10, max 100)" },
+            offset: { type: "number", required: false, description: "Offset for pagination (default 0)" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const params = new URLSearchParams();
+            params.set("text", p.query);
+            params.set("size", String(p.limit ?? 10));
+            params.set("from", String(p.offset ?? 0));
+            params.set("popularity", "0.99");
+            const data = (await apiRequest(getConn(ctx), "GET", `/-/v1/search?${params.toString()}`));
+            const objects = (data.objects ?? []);
+            return objects.map(({ package: pkg }) => ({
+                name: pkg.name,
+                version: pkg.version,
+                description: pkg.description,
+            }));
+        },
+    });
+    rl.registerAction("distTag.list", {
+        description: "Get all dist-tags for a package",
+        inputSchema: {
+            packageName: { type: "string", required: true, description: "Package name" },
+        },
+        async execute(input, ctx) {
+            const { packageName } = input;
+            return apiRequest(getConn(ctx), "GET", `/-/package/${encodeURIComponent(packageName)}/dist-tags`);
+        },
+    });
+    rl.registerAction("distTag.update", {
+        description: "Update a dist-tag for a package (requires auth)",
+        inputSchema: {
+            packageName: { type: "string", required: true, description: "Package name" },
+            tagName: { type: "string", required: true, description: "Dist-tag name (e.g. latest)" },
+            version: { type: "string", required: true, description: "Version to point the tag to" },
+        },
+        async execute(input, ctx) {
+            const { packageName, tagName, version } = input;
+            return apiRequest(getConn(ctx), "PUT", `/-/package/${encodeURIComponent(packageName)}/dist-tags/${encodeURIComponent(tagName)}`, version, "application/x-www-form-urlencoded");
+        },
+    });
+}

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

@@ -0,0 +1,157 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return {
+        url: c.url.replace(/\/$/, ""),
+        db: c.db,
+        username: c.username,
+        password: c.password,
+    };
+}
+function getDBName(db, url) {
+    if (db)
+        return db;
+    try {
+        return new URL(url).hostname.split(".")[0];
+    }
+    catch {
+        return "";
+    }
+}
+async function jsonRpc(url, params) {
+    const body = { jsonrpc: "2.0", method: "call", params, id: Math.floor(Math.random() * 1000) };
+    const res = await fetch(`${url}/jsonrpc`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`Odoo HTTP error ${res.status}: ${await res.text()}`);
+    const json = (await res.json());
+    if (json.error) {
+        const err = json.error;
+        const data = (err.data ?? err);
+        throw new Error(`Odoo RPC error: ${data.message ?? JSON.stringify(err)}`);
+    }
+    return json.result;
+}
+async function login(url, db, username, password) {
+    const uid = (await jsonRpc(url, { service: "common", method: "login", args: [db, username, password] }));
+    if (!uid)
+        throw new Error("Odoo login failed — check credentials");
+    return uid;
+}
+async function execute(url, db, uid, password, model, method, ...args) {
+    return jsonRpc(url, {
+        service: "object", method: "execute",
+        args: [db, uid, password, model, method, ...args],
+    });
+}
+const MODEL_MAP = {
+    contact: "res.partner",
+    opportunity: "crm.lead",
+    note: "note.note",
+};
+function resolveModel(resource) {
+    return MODEL_MAP[resource] ?? resource;
+}
+export default function odoo(rl) {
+    rl.setName("odoo");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "Odoo instance URL (e.g. https://mycompany.odoo.com)", env: "ODOO_URL" },
+        db: { type: "string", required: false, description: "Database name (auto-detected from URL if omitted)", env: "ODOO_DB" },
+        username: { type: "string", required: true, description: "Odoo username (email)", env: "ODOO_USERNAME" },
+        password: { type: "string", required: true, description: "Odoo password or API key", env: "ODOO_PASSWORD" },
+    });
+    // Helper to get authenticated session
+    async function getSession(ctx) {
+        const c = getConn(ctx);
+        const db = getDBName(c.db, c.url);
+        const uid = await login(c.url, db, c.username, c.password);
+        return { url: c.url, db, uid, password: c.password };
+    }
+    rl.registerAction("record.create", {
+        description: "Create a record in any Odoo model (contact, opportunity, note, or custom model name)",
+        inputSchema: {
+            model: { type: "string", required: true, description: "Model: contact, opportunity, note, or Odoo model name (e.g. res.partner)" },
+            fields: { type: "object", required: true, description: "Fields to set on the new record" },
+        },
+        async execute(input, ctx) {
+            const { model, fields } = input;
+            const s = await getSession(ctx);
+            const id = await execute(s.url, s.db, s.uid, s.password, resolveModel(model), "create", fields);
+            return { id };
+        },
+    });
+    rl.registerAction("record.get", {
+        description: "Read a record by ID",
+        inputSchema: {
+            model: { type: "string", required: true, description: "Model: contact, opportunity, note, or Odoo model name" },
+            id: { type: "number", required: true, description: "Record ID" },
+            fields: { type: "object", required: false, description: "Array of field names to return (default: all)" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const s = await getSession(ctx);
+            const fieldsToRead = p.fields ?? [];
+            return execute(s.url, s.db, s.uid, s.password, resolveModel(p.model), "read", [p.id], fieldsToRead);
+        },
+    });
+    rl.registerAction("record.list", {
+        description: "Search and read records from any Odoo model",
+        inputSchema: {
+            model: { type: "string", required: true, description: "Model: contact, opportunity, note, or Odoo model name" },
+            filters: { type: "object", required: false, description: "Array of filter tuples, e.g. [[\"name\", \"like\", \"test\"]]" },
+            fields: { type: "object", required: false, description: "Array of field names to return" },
+            limit: { type: "number", required: false, description: "Max records (0 = no limit)" },
+            offset: { type: "number", required: false, description: "Offset for pagination" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const s = await getSession(ctx);
+            const filters = p.filters ?? [];
+            const fields = p.fields ?? [];
+            const offset = p.offset ?? 0;
+            const limit = p.limit ?? 0;
+            return execute(s.url, s.db, s.uid, s.password, resolveModel(p.model), "search_read", filters, fields, offset, limit);
+        },
+    });
+    rl.registerAction("record.update", {
+        description: "Update a record by ID",
+        inputSchema: {
+            model: { type: "string", required: true, description: "Model: contact, opportunity, note, or Odoo model name" },
+            id: { type: "number", required: true, description: "Record ID" },
+            fields: { type: "object", required: true, description: "Fields to update" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const s = await getSession(ctx);
+            await execute(s.url, s.db, s.uid, s.password, resolveModel(p.model), "write", [p.id], p.fields);
+            return { id: p.id };
+        },
+    });
+    rl.registerAction("record.delete", {
+        description: "Delete a record by ID",
+        inputSchema: {
+            model: { type: "string", required: true, description: "Model: contact, opportunity, note, or Odoo model name" },
+            id: { type: "number", required: true, description: "Record ID" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const s = await getSession(ctx);
+            await execute(s.url, s.db, s.uid, s.password, resolveModel(p.model), "unlink", [p.id]);
+            return { success: true };
+        },
+    });
+    rl.registerAction("model.getFields", {
+        description: "Get field definitions for an Odoo model",
+        inputSchema: {
+            model: { type: "string", required: true, description: "Model: contact, opportunity, note, or Odoo model name" },
+        },
+        async execute(input, ctx) {
+            const { model } = input;
+            const s = await getSession(ctx);
+            return execute(s.url, s.db, s.uid, s.password, resolveModel(model), "fields_get", [], ["string", "type", "help", "required", "name"]);
+        },
+    });
+}

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

@@ -0,0 +1,141 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    const url = c.url.replace(/\/$/, "");
+    return { url, apiToken: c.apiToken };
+}
+async function apiRequest(conn, method, endpoint, body, qs) {
+    const u = new URL(`${conn.url}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                u.searchParams.set(k, String(v));
+        }
+    }
+    const init = {
+        method,
+        headers: {
+            Authorization: `SSWS ${conn.apiToken}`,
+            "Content-Type": "application/json",
+        },
+    };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify(body);
+    const res = await fetch(u.toString(), init);
+    if (!res.ok)
+        throw new Error(`Okta API error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    const data = text ? JSON.parse(text) : {};
+    return { data, linkHeader: res.headers.get("link") ?? undefined };
+}
+async function paginate(conn, endpoint, qs = {}) {
+    const all = [];
+    let after;
+    do {
+        if (after)
+            qs.after = after;
+        qs.limit = 200;
+        const { data, linkHeader } = await apiRequest(conn, "GET", endpoint, undefined, qs);
+        const items = Array.isArray(data) ? data : [];
+        all.push(...items);
+        after = undefined;
+        if (linkHeader) {
+            const match = linkHeader.match(/after=([^&>]+)/);
+            if (match)
+                after = match[1];
+        }
+    } while (after);
+    return all;
+}
+export default function okta(rl) {
+    rl.setName("okta");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "Okta org URL (e.g. https://yourorg.okta.com)", env: "OKTA_URL" },
+        apiToken: { type: "string", required: true, description: "Okta API token (SSWS)", env: "OKTA_API_TOKEN" },
+    });
+    rl.registerAction("user.create", {
+        description: "Create a new user in Okta",
+        inputSchema: {
+            firstName: { type: "string", required: true },
+            lastName: { type: "string", required: true },
+            login: { type: "string", required: true, description: "Username (must be email)" },
+            email: { type: "string", required: true },
+            activate: { type: "boolean", required: false, description: "Activate user immediately (default true)" },
+            password: { type: "string", required: false },
+            profile: { type: "object", required: false, description: "Additional profile fields (city, department, displayName, etc.)" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const conn = getConn(ctx);
+            const body = {
+                profile: {
+                    firstName: p.firstName,
+                    lastName: p.lastName,
+                    login: p.login,
+                    email: p.email,
+                    ...(p.profile ?? {}),
+                },
+            };
+            if (p.password) {
+                body.credentials = { password: { value: p.password } };
+            }
+            const qs = { activate: p.activate !== false ? "true" : "false" };
+            const { data } = await apiRequest(conn, "POST", "/api/v1/users/", body, qs);
+            return data;
+        },
+    });
+    rl.registerAction("user.get", {
+        description: "Get user details by ID or login",
+        inputSchema: {
+            userId: { type: "string", required: true, description: "User ID or login (email)" },
+        },
+        async execute(input, ctx) {
+            const { userId } = input;
+            const { data } = await apiRequest(getConn(ctx), "GET", `/api/v1/users/${userId}`);
+            return data;
+        },
+    });
+    rl.registerAction("user.list", {
+        description: "List users (with optional search query)",
+        inputSchema: {
+            search: { type: "string", required: false, description: "Search/filter query, e.g. profile.lastName sw \"Smi\"" },
+            limit: { type: "number", required: false, description: "Max results (default all)" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const conn = getConn(ctx);
+            const qs = {};
+            if (p.search)
+                qs.search = p.search;
+            if (p.limit) {
+                qs.limit = p.limit;
+                const { data } = await apiRequest(conn, "GET", "/api/v1/users/", undefined, qs);
+                return data;
+            }
+            return paginate(conn, "/api/v1/users/", qs);
+        },
+    });
+    rl.registerAction("user.update", {
+        description: "Update a user's profile",
+        inputSchema: {
+            userId: { type: "string", required: true, description: "User ID" },
+            profile: { type: "object", required: true, description: "Profile fields to update (firstName, lastName, email, login, city, department, etc.)" },
+        },
+        async execute(input, ctx) {
+            const { userId, profile } = input;
+            const { data } = await apiRequest(getConn(ctx), "POST", `/api/v1/users/${userId}`, { profile });
+            return data;
+        },
+    });
+    rl.registerAction("user.delete", {
+        description: "Delete (deactivate and then delete) a user",
+        inputSchema: {
+            userId: { type: "string", required: true, description: "User ID" },
+        },
+        async execute(input, ctx) {
+            const { userId } = input;
+            await apiRequest(getConn(ctx), "DELETE", `/api/v1/users/${userId}`);
+            return { success: true };
+        },
+    });
+}

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

@@ -0,0 +1,155 @@
+const BASE = "https://onesimpleapi.com/api";
+async function apiRequest(token, endpoint, qs = {}) {
+    const url = new URL(`${BASE}${endpoint}`);
+    url.searchParams.set("token", token);
+    url.searchParams.set("output", "json");
+    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());
+    if (!res.ok)
+        throw new Error(`OneSimpleAPI error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function oneSimpleApi(rl) {
+    rl.setName("oneSimpleApi");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiToken: { type: "string", required: true, description: "OneSimpleAPI token", env: "ONE_SIMPLE_API_TOKEN" },
+    });
+    const key = (ctx) => ctx.connection.config.apiToken;
+    // ── Website ─────────────────────────────────────────
+    rl.registerAction("website.pdf", {
+        description: "Generate a PDF from a webpage (returns URL to the PDF)",
+        inputSchema: {
+            url: { type: "string", required: true, description: "Webpage URL" },
+            page: { type: "string", required: false, description: "Page size: A0-A6, Letter, Legal, Tabloid, Ledger" },
+            force: { type: "boolean", required: false, description: "Force refresh (default false)" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = { url: p.url };
+            if (p.page)
+                qs.page = p.page;
+            qs.force = p.force ? "yes" : "no";
+            return apiRequest(key(ctx), "/pdf", qs);
+        },
+    });
+    rl.registerAction("website.screenshot", {
+        description: "Take a screenshot of a webpage (returns URL to the image)",
+        inputSchema: {
+            url: { type: "string", required: true, description: "Webpage URL" },
+            screen: { type: "string", required: false, description: "Screen size: phone, phone-landscape, tablet, tablet-landscape, retina" },
+            fullpage: { type: "boolean", required: false, description: "Capture full page (default false)" },
+            force: { type: "boolean", required: false, description: "Force refresh (default false)" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = { url: p.url };
+            if (p.screen)
+                qs.screen = p.screen;
+            qs.fullpage = p.fullpage ? "yes" : "no";
+            qs.force = p.force ? "yes" : "no";
+            return apiRequest(key(ctx), "/screenshot", qs);
+        },
+    });
+    rl.registerAction("website.seo", {
+        description: "Get SEO information from a webpage",
+        inputSchema: {
+            url: { type: "string", required: true, description: "Webpage URL" },
+            headers: { type: "boolean", required: false, description: "Include response headers (default false)" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = { url: p.url };
+            if (p.headers)
+                qs.headers = "yes";
+            return apiRequest(key(ctx), "/page_info", qs);
+        },
+    });
+    // ── Social Profile ──────────────────────────────────
+    rl.registerAction("socialProfile.instagram", {
+        description: "Get details about an Instagram profile",
+        inputSchema: {
+            profile: { type: "string", required: true, description: "Instagram profile name" },
+        },
+        async execute(input, ctx) {
+            const { profile } = input;
+            return apiRequest(key(ctx), "/instagram_profile", { profile });
+        },
+    });
+    rl.registerAction("socialProfile.spotify", {
+        description: "Get details about a Spotify artist",
+        inputSchema: {
+            profile: { type: "string", required: true, description: "Spotify artist name" },
+        },
+        async execute(input, ctx) {
+            const { profile } = input;
+            return apiRequest(key(ctx), "/spotify_profile", { profile });
+        },
+    });
+    // ── Information ─────────────────────────────────────
+    rl.registerAction("information.exchangeRate", {
+        description: "Convert a value between currencies",
+        inputSchema: {
+            value: { type: "string", required: true, description: "Value to convert" },
+            fromCurrency: { type: "string", required: true, description: "Source currency (e.g. USD)" },
+            toCurrency: { type: "string", required: true, description: "Target currency (e.g. EUR)" },
+        },
+        async execute(input, ctx) {
+            const { value, fromCurrency, toCurrency } = input;
+            return apiRequest(key(ctx), "/exchange_rate", {
+                from_value: value, from_currency: fromCurrency, to_currency: toCurrency,
+            });
+        },
+    });
+    rl.registerAction("information.imageMetadata", {
+        description: "Get metadata from an image URL",
+        inputSchema: {
+            url: { type: "string", required: true, description: "Image URL" },
+        },
+        async execute(input, ctx) {
+            const { url } = input;
+            return apiRequest(key(ctx), "/image_info", { url, raw: true });
+        },
+    });
+    // ── Utility ─────────────────────────────────────────
+    rl.registerAction("utility.validateEmail", {
+        description: "Validate an email address",
+        inputSchema: {
+            email: { type: "string", required: true, description: "Email address to validate" },
+        },
+        async execute(input, ctx) {
+            const { email } = input;
+            return apiRequest(key(ctx), "/email", { email });
+        },
+    });
+    rl.registerAction("utility.expandUrl", {
+        description: "Expand a shortened URL",
+        inputSchema: {
+            url: { type: "string", required: true, description: "Shortened URL" },
+        },
+        async execute(input, ctx) {
+            const { url } = input;
+            return apiRequest(key(ctx), "/unshorten", { url });
+        },
+    });
+    rl.registerAction("utility.qrCode", {
+        description: "Generate a QR code (returns URL to the image)",
+        inputSchema: {
+            message: { type: "string", required: true, description: "Content for the QR code (URL, text, etc.)" },
+            size: { type: "string", required: false, description: "Size: Small, Medium, Large" },
+            format: { type: "string", required: false, description: "Format: PNG or SVG" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = { message: p.message };
+            if (p.size)
+                qs.size = p.size;
+            if (p.format)
+                qs.format = p.format;
+            return apiRequest(key(ctx), "/qr_code", qs);
+        },
+    });
+}