runline 0.1.0

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

@@ -0,0 +1,91 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { url: c.url.replace(/\/$/, ""), token: c.token };
+}
+async function api(conn, method, endpoint, body, qs) {
+    const url = new URL(`${conn.url}/api/v1${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: `Token token=${conn.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(`Zammad error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+function registerCrud(rl, resource, plural, conn, createSchema) {
+    rl.registerAction(`${resource}.create`, { description: `Create a ${resource}`, inputSchema: createSchema,
+        async execute(input, ctx) { return api(conn(ctx), "POST", `/${plural}`, input); } });
+    rl.registerAction(`${resource}.get`, { description: `Get a ${resource} by ID`, inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { return api(conn(ctx), "GET", `/${plural}/${input.id}`); } });
+    rl.registerAction(`${resource}.list`, { description: `List ${plural}`, inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = { per_page: p.limit ?? 100 };
+            return api(conn(ctx), "GET", `/${plural}`, undefined, qs);
+        } });
+    rl.registerAction(`${resource}.update`, { description: `Update a ${resource}`, inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) { const p = input; return api(conn(ctx), "PUT", `/${plural}/${p.id}`, p.data); } });
+    rl.registerAction(`${resource}.delete`, { description: `Delete a ${resource}`, inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { await api(conn(ctx), "DELETE", `/${plural}/${input.id}`); return { success: true }; } });
+}
+export default function zammad(rl) {
+    rl.setName("zammad");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "Zammad instance URL", env: "ZAMMAD_URL" },
+        token: { type: "string", required: true, description: "Zammad access token", env: "ZAMMAD_TOKEN" },
+    });
+    registerCrud(rl, "user", "users", getConn, { firstname: { type: "string", required: true }, lastname: { type: "string", required: true }, email: { type: "string", required: false } });
+    registerCrud(rl, "organization", "organizations", getConn, { name: { type: "string", required: true } });
+    registerCrud(rl, "group", "groups", getConn, { name: { type: "string", required: true } });
+    // ── Ticket (special: includes article) ──────────────
+    rl.registerAction("ticket.create", { description: "Create a ticket", inputSchema: {
+            title: { type: "string", required: true }, group: { type: "string", required: true },
+            customer: { type: "string", required: true, description: "Customer email" },
+            articleBody: { type: "string", required: true }, articleSubject: { type: "string", required: false },
+            articleInternal: { type: "boolean", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { title: p.title, group: p.group, customer: p.customer, article: { body: p.articleBody, internal: p.articleInternal ?? false } };
+            if (p.articleSubject)
+                body.article.subject = p.articleSubject;
+            return api(getConn(ctx), "POST", "/tickets", body);
+        } });
+    rl.registerAction("ticket.get", { description: "Get a ticket with articles", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const c = getConn(ctx);
+            const id = input.id;
+            const ticket = (await api(c, "GET", `/tickets/${id}`));
+            ticket.articles = await api(c, "GET", `/ticket_articles/by_ticket/${id}`);
+            return ticket;
+        } });
+    rl.registerAction("ticket.list", { description: "List tickets", inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const qs = { per_page: (input ?? {}).limit ?? 100 };
+            return api(getConn(ctx), "GET", "/tickets", undefined, qs);
+        } });
+    rl.registerAction("ticket.update", { description: "Update a ticket", inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) { const p = input; return api(getConn(ctx), "PUT", `/tickets/${p.id}`, p.data); } });
+    rl.registerAction("ticket.delete", { description: "Delete a ticket", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { await api(getConn(ctx), "DELETE", `/tickets/${input.id}`); return { success: true }; } });
+    // ── User extras ─────────────────────────────────────
+    rl.registerAction("user.getSelf", { description: "Get the current user", inputSchema: {},
+        async execute(_input, ctx) { return api(getConn(ctx), "GET", "/users/me"); } });
+    rl.registerAction("user.search", { description: "Search users", inputSchema: { query: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = { query: p.query };
+            if (p.limit)
+                qs.per_page = p.limit;
+            return api(getConn(ctx), "GET", "/users/search", undefined, qs);
+        } });
+}

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

@@ -0,0 +1,137 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { subdomain: c.subdomain, email: c.email, apiToken: c.apiToken };
+}
+async function api(conn, method, endpoint, body, qs) {
+    const url = new URL(`https://${conn.subdomain}.zendesk.com/api/v2${endpoint}.json`);
+    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: `Basic ${btoa(`${conn.email}/token:${conn.apiToken}`)}`, "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(`Zendesk error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+export default function zendesk(rl) {
+    rl.setName("zendesk");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        subdomain: { type: "string", required: true, description: "Zendesk subdomain", env: "ZENDESK_SUBDOMAIN" },
+        email: { type: "string", required: true, description: "Agent email", env: "ZENDESK_EMAIL" },
+        apiToken: { type: "string", required: true, description: "Zendesk API token", env: "ZENDESK_API_TOKEN" },
+    });
+    // ── Ticket ──────────────────────────────────────────
+    rl.registerAction("ticket.create", { description: "Create a ticket", inputSchema: { description: { type: "string", required: true }, subject: { type: "string", required: false }, type: { type: "string", required: false }, status: { type: "string", required: false }, priority: { type: "string", required: false }, tags: { type: "object", required: false }, customFields: { type: "object", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const ticket = { comment: { body: p.description } };
+            if (p.subject)
+                ticket.subject = p.subject;
+            if (p.type)
+                ticket.type = p.type;
+            if (p.status)
+                ticket.status = p.status;
+            if (p.priority)
+                ticket.priority = p.priority;
+            if (p.tags)
+                ticket.tags = p.tags;
+            if (p.customFields)
+                ticket.custom_fields = p.customFields;
+            const data = (await api(getConn(ctx), "POST", "/tickets", { ticket }));
+            return data.ticket;
+        } });
+    rl.registerAction("ticket.get", { description: "Get a ticket", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const data = (await api(getConn(ctx), "GET", `/tickets/${input.id}`)); return data.ticket; } });
+    rl.registerAction("ticket.list", { description: "Search tickets", inputSchema: { query: { type: "string", required: false, description: "Zendesk search query" }, limit: { type: "number", required: false }, status: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            let q = "type:ticket";
+            if (p.query)
+                q += ` ${p.query}`;
+            if (p.status)
+                q += ` status:${p.status}`;
+            const qs = { query: q };
+            if (p.limit)
+                qs.per_page = p.limit;
+            const data = (await api(getConn(ctx), "GET", "/search", undefined, qs));
+            return data.results;
+        } });
+    rl.registerAction("ticket.update", { description: "Update a ticket", inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true, description: "Ticket fields to update" } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await api(getConn(ctx), "PUT", `/tickets/${p.id}`, { ticket: p.data }));
+            return data.ticket;
+        } });
+    rl.registerAction("ticket.delete", { description: "Delete a ticket", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { await api(getConn(ctx), "DELETE", `/tickets/${input.id}`); return { success: true }; } });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.create", { description: "Create a user", inputSchema: { name: { type: "string", required: true }, email: { type: "string", required: false }, role: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const data = (await api(getConn(ctx), "POST", "/users", { user: input }));
+            return data.user;
+        } });
+    rl.registerAction("user.get", { description: "Get a user", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const data = (await api(getConn(ctx), "GET", `/users/${input.id}`)); return data.user; } });
+    rl.registerAction("user.list", { description: "List users", inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const qs = {};
+            if (input?.limit)
+                qs.per_page = input.limit;
+            const data = (await api(getConn(ctx), "GET", "/users", undefined, qs));
+            return data.users;
+        } });
+    rl.registerAction("user.update", { description: "Update a user", inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await api(getConn(ctx), "PUT", `/users/${p.id}`, { user: p.data }));
+            return data.user;
+        } });
+    rl.registerAction("user.delete", { description: "Delete a user", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const data = (await api(getConn(ctx), "DELETE", `/users/${input.id}`)); return data.user; } });
+    rl.registerAction("user.search", { description: "Search users", inputSchema: { query: { type: "string", required: true }, limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = { query: p.query };
+            if (p.limit)
+                qs.per_page = p.limit;
+            const data = (await api(getConn(ctx), "GET", "/users/search", undefined, qs));
+            return data.users;
+        } });
+    // ── Organization ────────────────────────────────────
+    rl.registerAction("organization.create", { description: "Create an organization", inputSchema: { name: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await api(getConn(ctx), "POST", "/organizations", { organization: input }));
+            return data.organization;
+        } });
+    rl.registerAction("organization.get", { description: "Get an organization", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const data = (await api(getConn(ctx), "GET", `/organizations/${input.id}`)); return data.organization; } });
+    rl.registerAction("organization.list", { description: "List organizations", inputSchema: { limit: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const qs = {};
+            if (input?.limit)
+                qs.per_page = input.limit;
+            const data = (await api(getConn(ctx), "GET", "/organizations", undefined, qs));
+            return data.organizations;
+        } });
+    rl.registerAction("organization.update", { description: "Update an organization", inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            const data = (await api(getConn(ctx), "PUT", `/organizations/${p.id}`, { organization: p.data }));
+            return data.organization;
+        } });
+    rl.registerAction("organization.delete", { description: "Delete an organization", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { await api(getConn(ctx), "DELETE", `/organizations/${input.id}`); return { success: true }; } });
+    // ── Ticket Field ────────────────────────────────────
+    rl.registerAction("ticketField.get", { description: "Get a ticket field", inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) { const data = (await api(getConn(ctx), "GET", `/ticket_fields/${input.id}`)); return data.ticket_field; } });
+    rl.registerAction("ticketField.list", { description: "List ticket fields", inputSchema: {},
+        async execute(_input, ctx) { const data = (await api(getConn(ctx), "GET", "/ticket_fields")); return data.ticket_fields; } });
+}

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

@@ -0,0 +1,85 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { accessToken: c.accessToken, apiDomain: (c.apiDomain || "https://www.zohoapis.com").replace(/\/$/, "") };
+}
+async function api(conn, method, endpoint, body, qs) {
+    const url = new URL(`${conn.apiDomain}/crm/v2${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: `Zoho-oauthtoken ${conn.accessToken}`, "Content-Type": "application/json" } };
+    if (body && Object.keys(body).length > 0)
+        init.body = JSON.stringify({ data: [body] });
+    const res = await fetch(url.toString(), init);
+    if (!res.ok)
+        throw new Error(`Zoho CRM error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+const MODULES = {
+    account: "Accounts", contact: "Contacts", deal: "Deals", invoice: "Invoices",
+    lead: "Leads", product: "Products", purchaseOrder: "Purchase_Orders",
+    salesOrder: "Sales_Orders", vendor: "Vendors", quote: "Quotes",
+};
+function registerCrmResource(rl, resource, conn) {
+    const mod = MODULES[resource];
+    rl.registerAction(`${resource}.create`, { description: `Create a ${resource}`, inputSchema: { data: { type: "object", required: true, description: "Record fields" } },
+        async execute(input, ctx) {
+            const data = (await api(conn(ctx), "POST", `/${mod}`, input.data));
+            return data.data;
+        } });
+    rl.registerAction(`${resource}.get`, { description: `Get a ${resource} by ID`, inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await api(conn(ctx), "GET", `/${mod}/${input.id}`));
+            return data.data;
+        } });
+    rl.registerAction(`${resource}.list`, { description: `List ${mod}`, inputSchema: { limit: { type: "number", required: false }, fields: { type: "string", required: false, description: "Comma-separated field names" } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.limit)
+                qs.per_page = p.limit;
+            if (p.fields)
+                qs.fields = p.fields;
+            const data = (await api(conn(ctx), "GET", `/${mod}`, undefined, qs));
+            return data.data ?? [];
+        } });
+    rl.registerAction(`${resource}.update`, { description: `Update a ${resource}`, inputSchema: { id: { type: "string", required: true }, data: { type: "object", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { ...p.data, id: p.id };
+            const data = (await api(conn(ctx), "PUT", `/${mod}`, body));
+            return data.data;
+        } });
+    rl.registerAction(`${resource}.delete`, { description: `Delete a ${resource}`, inputSchema: { id: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const data = (await api(conn(ctx), "DELETE", `/${mod}`, undefined, { ids: input.id }));
+            return data.data;
+        } });
+    rl.registerAction(`${resource}.upsert`, { description: `Upsert a ${resource}`, inputSchema: { data: { type: "object", required: true }, duplicateCheckFields: { type: "string", required: false, description: "Comma-separated field names for duplicate check" } },
+        async execute(input, ctx) {
+            const p = input;
+            const body = p.data;
+            const qs = {};
+            if (p.duplicateCheckFields) {
+                body.duplicate_check_fields = p.duplicateCheckFields.split(",").map(f => f.trim());
+            }
+            const data = (await api(conn(ctx), "POST", `/${mod}/upsert`, body));
+            return data.data;
+        } });
+}
+export default function zoho(rl) {
+    rl.setName("zoho");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "Zoho OAuth2 access token", env: "ZOHO_ACCESS_TOKEN" },
+        apiDomain: { type: "string", required: false, description: "API domain (default: https://www.zohoapis.com)", env: "ZOHO_API_DOMAIN" },
+    });
+    for (const resource of Object.keys(MODULES)) {
+        registerCrmResource(rl, resource, getConn);
+    }
+}

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

@@ -0,0 +1,122 @@
+const BASE = "https://api.zoom.us/v2";
+async function apiRequest(token, 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: { 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.status === 204)
+        return { success: true };
+    if (!res.ok)
+        throw new Error(`Zoom error ${res.status}: ${await res.text()}`);
+    const text = await res.text();
+    return text ? JSON.parse(text) : { success: true };
+}
+export default function zoom(rl) {
+    rl.setName("zoom");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "Zoom access token (JWT or OAuth2)", env: "ZOOM_ACCESS_TOKEN" },
+    });
+    const key = (ctx) => ctx.connection.config.accessToken;
+    rl.registerAction("meeting.create", {
+        description: "Create a Zoom meeting",
+        inputSchema: {
+            topic: { type: "string", required: true },
+            type: { type: "number", required: false, description: "1=Instant, 2=Scheduled, 3=Recurring no fixed, 8=Recurring fixed" },
+            startTime: { type: "string", required: false, description: "ISO 8601 datetime" },
+            duration: { type: "number", required: false, description: "Duration in minutes" },
+            timezone: { type: "string", required: false },
+            password: { type: "string", required: false },
+            agenda: { type: "string", required: false },
+            settings: { type: "object", required: false, description: "Meeting settings object" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { topic: p.topic };
+            if (p.type)
+                body.type = p.type;
+            if (p.startTime)
+                body.start_time = p.startTime;
+            if (p.duration)
+                body.duration = p.duration;
+            if (p.timezone)
+                body.timezone = p.timezone;
+            if (p.password)
+                body.password = p.password;
+            if (p.agenda)
+                body.agenda = p.agenda;
+            if (p.settings)
+                body.settings = p.settings;
+            return apiRequest(key(ctx), "POST", "/users/me/meetings", body);
+        },
+    });
+    rl.registerAction("meeting.get", {
+        description: "Get a meeting by ID",
+        inputSchema: { meetingId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            return apiRequest(key(ctx), "GET", `/meetings/${input.meetingId}`);
+        },
+    });
+    rl.registerAction("meeting.list", {
+        description: "List meetings for the authenticated user",
+        inputSchema: { limit: { type: "number", required: false }, type: { type: "string", required: false, description: "scheduled, live, upcoming" } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.limit)
+                qs.page_size = p.limit;
+            if (p.type)
+                qs.type = p.type;
+            const data = (await apiRequest(key(ctx), "GET", "/users/me/meetings", undefined, qs));
+            return data.meetings;
+        },
+    });
+    rl.registerAction("meeting.update", {
+        description: "Update a meeting",
+        inputSchema: {
+            meetingId: { type: "string", required: true },
+            topic: { type: "string", required: false },
+            startTime: { type: "string", required: false },
+            duration: { type: "number", required: false },
+            timezone: { type: "string", required: false },
+            password: { type: "string", required: false },
+            agenda: { type: "string", required: false },
+            settings: { type: "object", required: false },
+        },
+        async execute(input, ctx) {
+            const { meetingId, ...fields } = input;
+            const body = {};
+            if (fields.topic)
+                body.topic = fields.topic;
+            if (fields.startTime)
+                body.start_time = fields.startTime;
+            if (fields.duration)
+                body.duration = fields.duration;
+            if (fields.timezone)
+                body.timezone = fields.timezone;
+            if (fields.password)
+                body.password = fields.password;
+            if (fields.agenda)
+                body.agenda = fields.agenda;
+            if (fields.settings)
+                body.settings = fields.settings;
+            await apiRequest(key(ctx), "PATCH", `/meetings/${meetingId}`, body);
+            return { success: true };
+        },
+    });
+    rl.registerAction("meeting.delete", {
+        description: "Delete a meeting",
+        inputSchema: { meetingId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            await apiRequest(key(ctx), "DELETE", `/meetings/${input.meetingId}`);
+            return { success: true };
+        },
+    });
+}

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

@@ -0,0 +1,170 @@
+function getConn(ctx) {
+    const c = ctx.connection.config;
+    return { url: c.url.replace(/\/$/, ""), email: c.email, apiKey: c.apiKey };
+}
+async function apiRequest(conn, method, endpoint, body) {
+    const url = `${conn.url}/api/v1${endpoint}`;
+    const init = {
+        method,
+        headers: {
+            Authorization: `Basic ${btoa(`${conn.email}:${conn.apiKey}`)}`,
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+    };
+    if (body && Object.keys(body).length > 0) {
+        const form = new URLSearchParams();
+        for (const [k, v] of Object.entries(body)) {
+            if (v !== undefined && v !== null)
+                form.set(k, typeof v === "object" ? JSON.stringify(v) : String(v));
+        }
+        init.body = form;
+    }
+    const res = await fetch(url, init);
+    if (!res.ok)
+        throw new Error(`Zulip error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function zulip(rl) {
+    rl.setName("zulip");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        url: { type: "string", required: true, description: "Zulip server URL", env: "ZULIP_URL" },
+        email: { type: "string", required: true, description: "Bot email", env: "ZULIP_EMAIL" },
+        apiKey: { type: "string", required: true, description: "Bot API key", env: "ZULIP_API_KEY" },
+    });
+    // ── Message ─────────────────────────────────────────
+    rl.registerAction("message.sendPrivate", {
+        description: "Send a private/direct message",
+        inputSchema: { to: { type: "string", required: true, description: "Comma-separated emails" }, content: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", "/messages", { type: "private", to: p.to, content: p.content });
+        },
+    });
+    rl.registerAction("message.sendStream", {
+        description: "Send a message to a stream",
+        inputSchema: { stream: { type: "string", required: true, description: "Stream name or ID" }, topic: { type: "string", required: true }, content: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", "/messages", { type: "stream", to: p.stream, topic: p.topic, content: p.content });
+        },
+    });
+    rl.registerAction("message.get", {
+        description: "Get a message by ID",
+        inputSchema: { messageId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "GET", `/messages/${input.messageId}`); },
+    });
+    rl.registerAction("message.update", {
+        description: "Update a message",
+        inputSchema: { messageId: { type: "string", required: true }, content: { type: "string", required: false }, topic: { type: "string", required: false } },
+        async execute(input, ctx) {
+            const { messageId, ...fields } = input;
+            return apiRequest(getConn(ctx), "PATCH", `/messages/${messageId}`, fields);
+        },
+    });
+    rl.registerAction("message.delete", {
+        description: "Delete a message",
+        inputSchema: { messageId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "DELETE", `/messages/${input.messageId}`); },
+    });
+    // ── Stream ──────────────────────────────────────────
+    rl.registerAction("stream.list", {
+        description: "List all streams",
+        inputSchema: { includePublic: { type: "boolean", required: false }, includeSubscribed: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const body = {};
+            if (p.includePublic !== undefined)
+                body.include_public = p.includePublic;
+            if (p.includeSubscribed !== undefined)
+                body.include_subscribed = p.includeSubscribed;
+            const data = (await apiRequest(getConn(ctx), "GET", "/streams", body));
+            return data.streams;
+        },
+    });
+    rl.registerAction("stream.listSubscribed", {
+        description: "List subscribed streams",
+        inputSchema: {},
+        async execute(_input, ctx) {
+            const data = (await apiRequest(getConn(ctx), "GET", "/users/me/subscriptions"));
+            return data.subscriptions;
+        },
+    });
+    rl.registerAction("stream.create", {
+        description: "Subscribe to / create a stream",
+        inputSchema: {
+            name: { type: "string", required: true },
+            description: { type: "string", required: false },
+            inviteOnly: { type: "boolean", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = {
+                subscriptions: JSON.stringify([{ name: p.name, description: p.description || "" }]),
+            };
+            if (p.inviteOnly !== undefined)
+                body.invite_only = p.inviteOnly;
+            return apiRequest(getConn(ctx), "POST", "/users/me/subscriptions", body);
+        },
+    });
+    rl.registerAction("stream.update", {
+        description: "Update a stream",
+        inputSchema: { streamId: { type: "string", required: true }, description: { type: "string", required: false }, newName: { type: "string", required: false }, isPrivate: { type: "boolean", required: false } },
+        async execute(input, ctx) {
+            const { streamId, ...fields } = input;
+            const body = {};
+            if (fields.description)
+                body.description = JSON.stringify(fields.description);
+            if (fields.newName)
+                body.new_name = JSON.stringify(fields.newName);
+            if (fields.isPrivate !== undefined)
+                body.is_private = fields.isPrivate;
+            return apiRequest(getConn(ctx), "PATCH", `/streams/${streamId}`, body);
+        },
+    });
+    rl.registerAction("stream.delete", {
+        description: "Delete a stream",
+        inputSchema: { streamId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "DELETE", `/streams/${input.streamId}`); },
+    });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.get", {
+        description: "Get a user by ID",
+        inputSchema: { userId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "GET", `/users/${input.userId}`); },
+    });
+    rl.registerAction("user.list", {
+        description: "List all users",
+        inputSchema: {},
+        async execute(_input, ctx) {
+            const data = (await apiRequest(getConn(ctx), "GET", "/users"));
+            return data.members;
+        },
+    });
+    rl.registerAction("user.create", {
+        description: "Create a user",
+        inputSchema: { email: { type: "string", required: true }, password: { type: "string", required: true }, fullName: { type: "string", required: true }, shortName: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const p = input;
+            return apiRequest(getConn(ctx), "POST", "/users", { email: p.email, password: p.password, full_name: p.fullName, short_name: p.shortName });
+        },
+    });
+    rl.registerAction("user.update", {
+        description: "Update a user",
+        inputSchema: { userId: { type: "string", required: true }, fullName: { type: "string", required: false }, role: { type: "number", required: false } },
+        async execute(input, ctx) {
+            const { userId, ...fields } = input;
+            const body = {};
+            if (fields.fullName)
+                body.full_name = JSON.stringify(fields.fullName);
+            if (fields.role !== undefined)
+                body.role = fields.role;
+            return apiRequest(getConn(ctx), "PATCH", `/users/${userId}`, body);
+        },
+    });
+    rl.registerAction("user.deactivate", {
+        description: "Deactivate a user",
+        inputSchema: { userId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(getConn(ctx), "DELETE", `/users/${input.userId}`); },
+    });
+}

package/dist/sdk.d.ts

@@ -0,0 +1,38 @@
+import { type ExecuteResult } from "./core/engine.js";
+import type { PluginFunction } from "./plugin/api.js";
+import type { ConnectionConfig, InputSchema, PluginDef } from "./plugin/types.js";
+export interface RunlineOptions {
+    plugins?: Array<PluginDef | PluginFunction>;
+    connections?: ConnectionConfig[];
+    timeoutMs?: number;
+    memoryLimitBytes?: number;
+}
+export declare class Runline {
+    private _registry;
+    private _config;
+    private constructor();
+    static create(options?: RunlineOptions): Runline;
+    /** Execute JavaScript code in the sandbox. */
+    execute(code: string): Promise<ExecuteResult>;
+    /** Register an additional plugin after creation. */
+    addPlugin(pluginOrFn: PluginDef | PluginFunction, connections?: ConnectionConfig[]): void;
+    /** List all available actions across all plugins. */
+    actions(): Array<{
+        plugin: string;
+        action: string;
+        description?: string;
+        inputSchema?: InputSchema;
+    }>;
+    /** List registered plugins. */
+    plugins(): Array<{
+        name: string;
+        version: string;
+        actions: string[];
+    }>;
+    /**
+     * Load runline from a project directory.
+     * Discovers .runline/ config and installed plugins, just like the CLI.
+     * Fully self-contained — does not mutate global state.
+     */
+    static fromProject(cwd?: string): Promise<Runline | null>;
+}