runline 0.1.0

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

@@ -0,0 +1,159 @@
+const API_URL = "https://api.dropboxapi.com/2";
+async function apiRequest(token, endpoint, body) {
+    const res = await fetch(`${API_URL}${endpoint}`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+        },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok)
+        throw new Error(`Dropbox API error ${res.status}: ${await res.text()}`);
+    const ct = res.headers.get("content-type") ?? "";
+    if (ct.includes("application/json"))
+        return res.json();
+    return { success: true };
+}
+async function paginateFolder(token, path, opts, limit) {
+    const results = [];
+    const body = { path, limit: 1000, ...opts };
+    let data = (await apiRequest(token, "/files/list_folder", body));
+    results.push(...data.entries);
+    while (data.has_more && (!limit || results.length < limit)) {
+        data = (await apiRequest(token, "/files/list_folder/continue", { cursor: data.cursor }));
+        results.push(...data.entries);
+    }
+    return limit ? results.slice(0, limit) : results;
+}
+async function paginateSearch(token, query, opts, limit) {
+    const results = [];
+    const body = { query, options: { filename_only: true, ...opts } };
+    if (limit)
+        body.options.max_results = Math.min(limit, 1000);
+    let data = (await apiRequest(token, "/files/search_v2", body));
+    results.push(...data.matches);
+    while (data.has_more && (!limit || results.length < limit)) {
+        data = (await apiRequest(token, "/files/search/continue_v2", { cursor: data.cursor }));
+        results.push(...data.matches);
+    }
+    return limit ? results.slice(0, limit) : results;
+}
+export default function dropbox(rl) {
+    rl.setName("dropbox");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "Dropbox access token", env: "DROPBOX_ACCESS_TOKEN" },
+    });
+    const tok = (ctx) => ctx.connection.config.accessToken;
+    // ── File ────────────────────────────────────────────
+    rl.registerAction("file.copy", {
+        description: "Copy a file",
+        inputSchema: {
+            fromPath: { type: "string", required: true, description: "Source file path" },
+            toPath: { type: "string", required: true, description: "Destination file path" },
+        },
+        async execute(input, ctx) {
+            const { fromPath, toPath } = input;
+            return apiRequest(tok(ctx), "/files/copy_v2", { from_path: fromPath, to_path: toPath });
+        },
+    });
+    rl.registerAction("file.move", {
+        description: "Move a file",
+        inputSchema: {
+            fromPath: { type: "string", required: true, description: "Source file path" },
+            toPath: { type: "string", required: true, description: "Destination file path" },
+        },
+        async execute(input, ctx) {
+            const { fromPath, toPath } = input;
+            return apiRequest(tok(ctx), "/files/move_v2", { from_path: fromPath, to_path: toPath });
+        },
+    });
+    rl.registerAction("file.delete", {
+        description: "Delete a file",
+        inputSchema: { path: { type: "string", required: true, description: "File path to delete" } },
+        async execute(input, ctx) {
+            return apiRequest(tok(ctx), "/files/delete_v2", { path: input.path });
+        },
+    });
+    // ── Folder ──────────────────────────────────────────
+    rl.registerAction("folder.create", {
+        description: "Create a folder",
+        inputSchema: { path: { type: "string", required: true, description: "Folder path to create" } },
+        async execute(input, ctx) {
+            return apiRequest(tok(ctx), "/files/create_folder_v2", { path: input.path });
+        },
+    });
+    rl.registerAction("folder.list", {
+        description: "List contents of a folder",
+        inputSchema: {
+            path: { type: "string", required: true, description: "Folder path (empty string for root)" },
+            limit: { type: "number", required: false, description: "Max results" },
+            recursive: { type: "boolean", required: false, description: "Include subfolders recursively" },
+            includeDeleted: { type: "boolean", required: false, description: "Include deleted entries" },
+        },
+        async execute(input, ctx) {
+            const { path, limit, recursive, includeDeleted } = (input ?? {});
+            const opts = {};
+            if (recursive)
+                opts.recursive = true;
+            if (includeDeleted)
+                opts.include_deleted = true;
+            return paginateFolder(tok(ctx), path, opts, limit);
+        },
+    });
+    rl.registerAction("folder.copy", {
+        description: "Copy a folder",
+        inputSchema: {
+            fromPath: { type: "string", required: true, description: "Source folder path" },
+            toPath: { type: "string", required: true, description: "Destination folder path" },
+        },
+        async execute(input, ctx) {
+            const { fromPath, toPath } = input;
+            return apiRequest(tok(ctx), "/files/copy_v2", { from_path: fromPath, to_path: toPath });
+        },
+    });
+    rl.registerAction("folder.move", {
+        description: "Move a folder",
+        inputSchema: {
+            fromPath: { type: "string", required: true, description: "Source folder path" },
+            toPath: { type: "string", required: true, description: "Destination folder path" },
+        },
+        async execute(input, ctx) {
+            const { fromPath, toPath } = input;
+            return apiRequest(tok(ctx), "/files/move_v2", { from_path: fromPath, to_path: toPath });
+        },
+    });
+    rl.registerAction("folder.delete", {
+        description: "Delete a folder",
+        inputSchema: { path: { type: "string", required: true, description: "Folder path to delete" } },
+        async execute(input, ctx) {
+            return apiRequest(tok(ctx), "/files/delete_v2", { path: input.path });
+        },
+    });
+    // ── Search ──────────────────────────────────────────
+    rl.registerAction("search.query", {
+        description: "Search for files and folders",
+        inputSchema: {
+            query: { type: "string", required: true, description: "Search query" },
+            limit: { type: "number", required: false, description: "Max results" },
+            path: { type: "string", required: false, description: "Limit search to this folder path" },
+            fileCategories: { type: "array", required: false, description: "Filter by categories: image, document, pdf, spreadsheet, presentation, audio, video, folder, paper, other" },
+            fileExtensions: { type: "array", required: false, description: "Filter by file extensions (e.g. ['jpg', 'pdf'])" },
+            fileStatus: { type: "string", required: false, description: "active (default) or deleted" },
+        },
+        async execute(input, ctx) {
+            const { query, limit, path, fileCategories, fileExtensions, fileStatus } = (input ?? {});
+            const opts = {};
+            if (path)
+                opts.path = path;
+            if (fileCategories)
+                opts.file_categories = fileCategories;
+            if (fileExtensions)
+                opts.file_extensions = fileExtensions;
+            if (fileStatus)
+                opts.file_status = { ".tag": fileStatus };
+            return paginateSearch(tok(ctx), query, opts, limit);
+        },
+    });
+}

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

@@ -0,0 +1,59 @@
+const BASE_URL = "https://api.dropcontact.io";
+async function apiRequest(apiKey, method, endpoint, body) {
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            "X-Access-Token": apiKey,
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(`${BASE_URL}${endpoint}`, opts);
+    if (!res.ok)
+        throw new Error(`Dropcontact API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function dropcontact(rl) {
+    rl.setName("dropcontact");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Dropcontact API key", env: "DROPCONTACT_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    rl.registerAction("contact.enrich", {
+        description: "Enrich contacts — find B2B emails from name and website",
+        inputSchema: {
+            contacts: {
+                type: "array",
+                required: true,
+                description: "Array of contact objects with fields: email, first_name, last_name, full_name, company, website, phone, linkedin, country, num_siren, siret",
+            },
+            siren: { type: "boolean", required: false, description: "Include French company SIREN data" },
+            language: { type: "string", required: false, description: "Response language: en (default) or fr" },
+        },
+        async execute(input, ctx) {
+            const { contacts, siren, language } = input;
+            const body = { data: contacts };
+            if (siren)
+                body.siren = true;
+            if (language)
+                body.language = language;
+            return apiRequest(key(ctx), "POST", "/batch", body);
+        },
+    });
+    rl.registerAction("contact.fetchRequest", {
+        description: "Fetch results of a previous enrich request by ID",
+        inputSchema: {
+            requestId: { type: "string", required: true, description: "Request ID from a previous enrich call" },
+        },
+        async execute(input, ctx) {
+            const { requestId } = input;
+            const data = (await apiRequest(key(ctx), "GET", `/batch/${requestId}`));
+            if (!data.success)
+                throw new Error(`Request not ready or failed: ${data.reason ?? "unknown"}`);
+            return data.data;
+        },
+    });
+}

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

@@ -0,0 +1,151 @@
+const BASE_URL = "https://api.egoiapp.com";
+async function apiRequest(apiKey, 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: { Apikey: apiKey, "Content-Type": "application/json", Accept: "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)
+        throw new Error(`E-goi API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+async function paginate(apiKey, endpoint, qs = {}, limit) {
+    const results = [];
+    qs.offset = 0;
+    qs.count = 500;
+    let data;
+    do {
+        const res = (await apiRequest(apiKey, "GET", endpoint, undefined, qs));
+        data = res.items ?? [];
+        results.push(...data);
+        qs.offset += qs.count;
+        if (limit && results.length >= limit)
+            break;
+    } while (data.length > 0);
+    return limit ? results.slice(0, limit) : results;
+}
+export default function egoi(rl) {
+    rl.setName("egoi");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "E-goi API key", env: "EGOI_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    rl.registerAction("contact.create", {
+        description: "Create a contact in a list",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            email: { type: "string", required: true, description: "Email address" },
+            firstName: { type: "string", required: false, description: "First name" },
+            lastName: { type: "string", required: false, description: "Last name" },
+            cellphone: { type: "string", required: false, description: "Cellphone" },
+            birthDate: { type: "string", required: false, description: "Birth date (YYYY-MM-DD)" },
+            status: { type: "string", required: false, description: "Status: active, inactive, unconfirmed, removed" },
+            tagIds: { type: "array", required: false, description: "Tag IDs to attach" },
+            extraFields: { type: "array", required: false, description: "Extra fields as [{field_id, value}]" },
+        },
+        async execute(input, ctx) {
+            const { listId, email, firstName, lastName, cellphone, birthDate, status, tagIds, extraFields } = input;
+            const base = { email };
+            if (firstName)
+                base.first_name = firstName;
+            if (lastName)
+                base.last_name = lastName;
+            if (cellphone)
+                base.cellphone = cellphone;
+            if (birthDate)
+                base.birth_date = birthDate;
+            if (status)
+                base.status = status;
+            const body = { base, extra: extraFields ?? [] };
+            const data = (await apiRequest(key(ctx), "POST", `/lists/${listId}/contacts`, body));
+            const contactId = data.contact_id;
+            if (tagIds && Array.isArray(tagIds)) {
+                for (const tag of tagIds) {
+                    await apiRequest(key(ctx), "POST", `/lists/${listId}/contacts/actions/attach-tag`, {
+                        tag_id: tag, contacts: [contactId],
+                    });
+                }
+            }
+            return apiRequest(key(ctx), "GET", `/lists/${listId}/contacts/${contactId}`);
+        },
+    });
+    rl.registerAction("contact.get", {
+        description: "Get a contact by ID or email",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            contactId: { type: "string", required: false, description: "Contact ID" },
+            email: { type: "string", required: false, description: "Email (alternative to contactId)" },
+        },
+        async execute(input, ctx) {
+            const { listId, contactId, email } = (input ?? {});
+            if (contactId)
+                return apiRequest(key(ctx), "GET", `/lists/${listId}/contacts/${contactId}`);
+            if (email)
+                return apiRequest(key(ctx), "GET", `/lists/${listId}/contacts`, undefined, { email: email });
+            throw new Error("Provide either contactId or email");
+        },
+    });
+    rl.registerAction("contact.list", {
+        description: "List contacts in a list",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { listId, limit } = (input ?? {});
+            return paginate(key(ctx), `/lists/${listId}/contacts`, {}, limit);
+        },
+    });
+    rl.registerAction("contact.update", {
+        description: "Update a contact",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            contactId: { type: "string", required: true, description: "Contact ID" },
+            email: { type: "string", required: false, description: "New email" },
+            firstName: { type: "string", required: false, description: "First name" },
+            lastName: { type: "string", required: false, description: "Last name" },
+            cellphone: { type: "string", required: false, description: "Cellphone" },
+            birthDate: { type: "string", required: false, description: "Birth date (YYYY-MM-DD)" },
+            status: { type: "string", required: false, description: "Status" },
+            tagIds: { type: "array", required: false, description: "Tag IDs to attach" },
+            extraFields: { type: "array", required: false, description: "Extra fields as [{field_id, value}]" },
+        },
+        async execute(input, ctx) {
+            const { listId, contactId, email, firstName, lastName, cellphone, birthDate, status, tagIds, extraFields } = input;
+            const base = {};
+            if (email)
+                base.email = email;
+            if (firstName)
+                base.first_name = firstName;
+            if (lastName)
+                base.last_name = lastName;
+            if (cellphone)
+                base.cellphone = cellphone;
+            if (birthDate)
+                base.birth_date = birthDate;
+            if (status)
+                base.status = status;
+            const body = { base, extra: extraFields ?? [] };
+            await apiRequest(key(ctx), "PATCH", `/lists/${listId}/contacts/${contactId}`, body);
+            if (tagIds && Array.isArray(tagIds)) {
+                for (const tag of tagIds) {
+                    await apiRequest(key(ctx), "POST", `/lists/${listId}/contacts/actions/attach-tag`, {
+                        tag_id: tag, contacts: [contactId],
+                    });
+                }
+            }
+            return apiRequest(key(ctx), "GET", `/lists/${listId}/contacts/${contactId}`);
+        },
+    });
+}

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

@@ -0,0 +1,157 @@
+async function apiRequest(baseUrl, username, password, method, endpoint, body, qs) {
+    const url = new URL(`${baseUrl}${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: {
+            Authorization: `Basic ${btoa(`${username}:${password}`)}`,
+            "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)
+        throw new Error(`Elasticsearch error ${res.status}: ${await res.text()}`);
+    const ct = res.headers.get("content-type") ?? "";
+    if (ct.includes("application/json"))
+        return res.json();
+    return { success: true };
+}
+function getConn(ctx) {
+    const cfg = ctx.connection.config;
+    return {
+        baseUrl: cfg.baseUrl.replace(/\/$/, ""),
+        username: cfg.username ?? "",
+        password: cfg.password ?? "",
+    };
+}
+function req(ctx, method, endpoint, body, qs) {
+    const { baseUrl, username, password } = getConn(ctx);
+    return apiRequest(baseUrl, username, password, method, endpoint, body, qs);
+}
+export default function elasticsearch(rl) {
+    rl.setName("elasticsearch");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        baseUrl: { type: "string", required: true, description: "Elasticsearch base URL (e.g. https://localhost:9200)", env: "ELASTICSEARCH_URL" },
+        username: { type: "string", required: false, description: "Username for basic auth", env: "ELASTICSEARCH_USERNAME" },
+        password: { type: "string", required: false, description: "Password for basic auth", env: "ELASTICSEARCH_PASSWORD" },
+    });
+    // ── Document ────────────────────────────────────────
+    rl.registerAction("document.create", {
+        description: "Index (create) a document",
+        inputSchema: {
+            index: { type: "string", required: true, description: "Index name" },
+            id: { type: "string", required: false, description: "Document ID (auto-generated if omitted)" },
+            body: { type: "object", required: true, description: "Document body" },
+        },
+        async execute(input, ctx) {
+            const { index, id, body } = input;
+            const endpoint = id ? `/${index}/_doc/${id}` : `/${index}/_doc`;
+            return req(ctx, id ? "PUT" : "POST", endpoint, body);
+        },
+    });
+    rl.registerAction("document.get", {
+        description: "Get a document by ID",
+        inputSchema: {
+            index: { type: "string", required: true, description: "Index name" },
+            id: { type: "string", required: true, description: "Document ID" },
+        },
+        async execute(input, ctx) {
+            const { index, id } = input;
+            return req(ctx, "GET", `/${index}/_doc/${id}`);
+        },
+    });
+    rl.registerAction("document.update", {
+        description: "Update a document",
+        inputSchema: {
+            index: { type: "string", required: true, description: "Index name" },
+            id: { type: "string", required: true, description: "Document ID" },
+            body: { type: "object", required: true, description: "Partial document to merge" },
+        },
+        async execute(input, ctx) {
+            const { index, id, body } = input;
+            return req(ctx, "POST", `/${index}/_update/${id}`, { doc: body });
+        },
+    });
+    rl.registerAction("document.delete", {
+        description: "Delete a document",
+        inputSchema: {
+            index: { type: "string", required: true, description: "Index name" },
+            id: { type: "string", required: true, description: "Document ID" },
+        },
+        async execute(input, ctx) {
+            const { index, id } = input;
+            return req(ctx, "DELETE", `/${index}/_doc/${id}`);
+        },
+    });
+    rl.registerAction("document.search", {
+        description: "Search documents in an index",
+        inputSchema: {
+            index: { type: "string", required: true, description: "Index name" },
+            query: { type: "object", required: false, description: "Elasticsearch query DSL" },
+            size: { type: "number", required: false, description: "Max results (default: 10)" },
+            from: { type: "number", required: false, description: "Offset" },
+            sort: { type: "array", required: false, description: "Sort criteria" },
+        },
+        async execute(input, ctx) {
+            const { index, query, size, from: offset, sort } = (input ?? {});
+            const body = {};
+            if (query)
+                body.query = query;
+            if (size !== undefined)
+                body.size = size;
+            if (offset !== undefined)
+                body.from = offset;
+            if (sort)
+                body.sort = sort;
+            const data = (await req(ctx, "POST", `/${index}/_search`, body));
+            return data.hits?.hits;
+        },
+    });
+    // ── Index ───────────────────────────────────────────
+    rl.registerAction("index.create", {
+        description: "Create an index",
+        inputSchema: {
+            index: { type: "string", required: true, description: "Index name" },
+            settings: { type: "object", required: false, description: "Index settings" },
+            mappings: { type: "object", required: false, description: "Index mappings" },
+        },
+        async execute(input, ctx) {
+            const { index, settings, mappings } = (input ?? {});
+            const body = {};
+            if (settings)
+                body.settings = settings;
+            if (mappings)
+                body.mappings = mappings;
+            return req(ctx, "PUT", `/${index}`, Object.keys(body).length > 0 ? body : undefined);
+        },
+    });
+    rl.registerAction("index.get", {
+        description: "Get index details",
+        inputSchema: { index: { type: "string", required: true, description: "Index name" } },
+        async execute(input, ctx) {
+            return req(ctx, "GET", `/${input.index}`);
+        },
+    });
+    rl.registerAction("index.list", {
+        description: "List all indices",
+        async execute(_input, ctx) {
+            return req(ctx, "GET", "/_cat/indices", undefined, { format: "json" });
+        },
+    });
+    rl.registerAction("index.delete", {
+        description: "Delete an index",
+        inputSchema: { index: { type: "string", required: true, description: "Index name" } },
+        async execute(input, ctx) {
+            return req(ctx, "DELETE", `/${input.index}`);
+        },
+    });
+}