runline 0.1.0

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

@@ -0,0 +1,106 @@
+async function apiRequest(baseUrl, apiKey, method, endpoint, body, qs) {
+    const url = new URL(`${baseUrl}/api${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: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+    };
+    if (body !== undefined && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok)
+        throw new Error(`Grist API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+function getConn(ctx) {
+    const cfg = ctx.connection.config;
+    const planType = cfg.planType ?? "free";
+    let baseUrl;
+    if (planType === "selfHosted")
+        baseUrl = cfg.selfHostedUrl.replace(/\/$/, "");
+    else if (planType === "paid")
+        baseUrl = `https://${cfg.subdomain}.getgrist.com`;
+    else
+        baseUrl = "https://docs.getgrist.com";
+    return { baseUrl, apiKey: cfg.apiKey };
+}
+export default function grist(rl) {
+    rl.setName("grist");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Grist API key", env: "GRIST_API_KEY" },
+        planType: { type: "string", required: false, description: "free (default), paid, or selfHosted", default: "free" },
+        subdomain: { type: "string", required: false, description: "Subdomain for paid plan" },
+        selfHostedUrl: { type: "string", required: false, description: "Full URL for self-hosted", env: "GRIST_URL" },
+    });
+    rl.registerAction("record.create", {
+        description: "Create records in a table",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Document ID" },
+            tableId: { type: "string", required: true, description: "Table ID" },
+            records: { type: "array", required: true, description: "Array of {fields: {col: value}} objects" },
+        },
+        async execute(input, ctx) {
+            const { docId, tableId, records } = input;
+            const { baseUrl, apiKey } = getConn(ctx);
+            return apiRequest(baseUrl, apiKey, "POST", `/docs/${docId}/tables/${tableId}/records`, { records });
+        },
+    });
+    rl.registerAction("record.list", {
+        description: "List records from a table",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Document ID" },
+            tableId: { type: "string", required: true, description: "Table ID" },
+            limit: { type: "number", required: false, description: "Max results" },
+            sort: { type: "string", required: false, description: "Sort columns (e.g. 'Name,-Age')" },
+            filter: { type: "object", required: false, description: "Filter as {column: [values]}" },
+        },
+        async execute(input, ctx) {
+            const { docId, tableId, limit, sort, filter } = (input ?? {});
+            const { baseUrl, apiKey } = getConn(ctx);
+            const qs = {};
+            if (limit)
+                qs.limit = limit;
+            if (sort)
+                qs.sort = sort;
+            if (filter)
+                qs.filter = JSON.stringify(filter);
+            const data = (await apiRequest(baseUrl, apiKey, "GET", `/docs/${docId}/tables/${tableId}/records`, undefined, qs));
+            return data.records;
+        },
+    });
+    rl.registerAction("record.update", {
+        description: "Update records in a table",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Document ID" },
+            tableId: { type: "string", required: true, description: "Table ID" },
+            records: { type: "array", required: true, description: "Array of {id, fields: {col: value}} objects" },
+        },
+        async execute(input, ctx) {
+            const { docId, tableId, records } = input;
+            const { baseUrl, apiKey } = getConn(ctx);
+            return apiRequest(baseUrl, apiKey, "PATCH", `/docs/${docId}/tables/${tableId}/records`, { records });
+        },
+    });
+    rl.registerAction("record.delete", {
+        description: "Delete records from a table",
+        inputSchema: {
+            docId: { type: "string", required: true, description: "Document ID" },
+            tableId: { type: "string", required: true, description: "Table ID" },
+            rowIds: { type: "array", required: true, description: "Array of row IDs to delete" },
+        },
+        async execute(input, ctx) {
+            const { docId, tableId, rowIds } = input;
+            const { baseUrl, apiKey } = getConn(ctx);
+            return apiRequest(baseUrl, apiKey, "POST", `/docs/${docId}/tables/${tableId}/data/delete`, rowIds);
+        },
+    });
+}

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

@@ -0,0 +1,89 @@
+const ALGOLIA_URL = "http://hn.algolia.com/api/v1";
+const FIREBASE_URL = "https://hacker-news.firebaseio.com/v0";
+async function algoliaRequest(endpoint, qs) {
+    const url = new URL(`${ALGOLIA_URL}/${endpoint}`);
+    if (qs) {
+        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(`HN API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+async function firebaseRequest(endpoint) {
+    const res = await fetch(`${FIREBASE_URL}/${endpoint}.json`);
+    if (!res.ok)
+        throw new Error(`HN Firebase API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+export default function hackernews(rl) {
+    rl.setName("hackernews");
+    rl.setVersion("0.1.0");
+    // No auth needed
+    rl.setConnectionSchema({});
+    rl.registerAction("article.get", {
+        description: "Get a Hacker News article/item by ID",
+        inputSchema: { articleId: { type: "string", required: true, description: "Item ID" } },
+        async execute(input) {
+            return firebaseRequest(`item/${input.articleId}`);
+        },
+    });
+    rl.registerAction("article.search", {
+        description: "Search Hacker News articles",
+        inputSchema: {
+            query: { type: "string", required: true, description: "Search query" },
+            tags: { type: "string", required: false, description: "Filter tags: story, comment, ask_hn, show_hn, poll, front_page" },
+            limit: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input) {
+            const { query, tags, limit } = (input ?? {});
+            const qs = { query };
+            if (tags)
+                qs.tags = tags;
+            if (limit)
+                qs.hitsPerPage = limit;
+            const data = (await algoliaRequest("search", qs));
+            return data.hits;
+        },
+    });
+    rl.registerAction("user.get", {
+        description: "Get a Hacker News user by username",
+        inputSchema: { username: { type: "string", required: true, description: "Username" } },
+        async execute(input) {
+            return firebaseRequest(`user/${input.username}`);
+        },
+    });
+    rl.registerAction("all.top", {
+        description: "Get top stories",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results (default: 30)" } },
+        async execute(input) {
+            const { limit = 30 } = (input ?? {});
+            const ids = (await firebaseRequest("topstories"));
+            const items = await Promise.all(ids.slice(0, limit).map((id) => firebaseRequest(`item/${id}`)));
+            return items;
+        },
+    });
+    rl.registerAction("all.new", {
+        description: "Get newest stories",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results (default: 30)" } },
+        async execute(input) {
+            const { limit = 30 } = (input ?? {});
+            const ids = (await firebaseRequest("newstories"));
+            const items = await Promise.all(ids.slice(0, limit).map((id) => firebaseRequest(`item/${id}`)));
+            return items;
+        },
+    });
+    rl.registerAction("all.best", {
+        description: "Get best stories",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results (default: 30)" } },
+        async execute(input) {
+            const { limit = 30 } = (input ?? {});
+            const ids = (await firebaseRequest("beststories"));
+            const items = await Promise.all(ids.slice(0, limit).map((id) => firebaseRequest(`item/${id}`)));
+            return items;
+        },
+    });
+}

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

@@ -0,0 +1,79 @@
+let cachedToken = null;
+async function getToken(authUrl, clientId, clientSecret, scope, tenant) {
+    if (cachedToken && Date.now() < cachedToken.expiresAt)
+        return cachedToken.token;
+    const url = tenant ? `${authUrl}?tenant=${tenant}` : authUrl;
+    const body = new URLSearchParams({ grant_type: "client_credentials", client_id: clientId, client_secret: clientSecret, scope });
+    const res = await fetch(url, { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: body.toString() });
+    if (!res.ok)
+        throw new Error(`HaloPSA auth error ${res.status}: ${await res.text()}`);
+    const data = (await res.json());
+    cachedToken = { token: data.access_token, expiresAt: Date.now() + (data.expires_in - 60) * 1000 };
+    return cachedToken.token;
+}
+async function apiRequest(apiUrl, token, method, endpoint, body, qs) {
+    const url = new URL(`${apiUrl}${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: `Bearer ${token}`, "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(`HaloPSA API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+async function req(ctx, method, endpoint, body, qs) {
+    const cfg = ctx.connection.config;
+    const authUrl = cfg.hostingType === "on-premise" ? `${cfg.appUrl}/auth/token` : `${cfg.authUrl}/token`;
+    const token = await getToken(authUrl, cfg.clientId, cfg.clientSecret, cfg.scope ?? "all", cfg.tenant);
+    return apiRequest(cfg.resourceApiUrl.replace(/\/$/, ""), token, method, endpoint, body, qs);
+}
+function registerCrud(rl, resource, apiPath) {
+    rl.registerAction(`${resource}.create`, {
+        description: `Create a ${resource}`, inputSchema: { properties: { type: "object", required: true, description: `${resource} data` } },
+        async execute(input, ctx) { return req(ctx, "POST", apiPath, { ...input.properties }); },
+    });
+    rl.registerAction(`${resource}.get`, {
+        description: `Get a ${resource}`, inputSchema: { id: { type: "number", required: true, description: `${resource} ID` } },
+        async execute(input, ctx) { return req(ctx, "GET", `${apiPath}/${input.id}`); },
+    });
+    rl.registerAction(`${resource}.list`, {
+        description: `List ${resource}s`, inputSchema: { limit: { type: "number", required: false, description: "Max results" }, page: { type: "number", required: false, description: "Page" } },
+        async execute(input, ctx) { const { limit, page } = (input ?? {}); const qs = {}; if (limit)
+            qs.count = limit; if (page)
+            qs.page_no = page; return req(ctx, "GET", apiPath, undefined, qs); },
+    });
+    rl.registerAction(`${resource}.update`, {
+        description: `Update a ${resource}`, inputSchema: { id: { type: "number", required: true, description: `${resource} ID` }, properties: { type: "object", required: true, description: "Fields to update" } },
+        async execute(input, ctx) { const { id, properties } = input; return req(ctx, "PUT", apiPath, { id, ...properties }); },
+    });
+    rl.registerAction(`${resource}.delete`, {
+        description: `Delete a ${resource}`, inputSchema: { id: { type: "number", required: true, description: `${resource} ID` } },
+        async execute(input, ctx) { await req(ctx, "DELETE", `${apiPath}/${input.id}`); return { success: true }; },
+    });
+}
+export default function halopsa(rl) {
+    rl.setName("halopsa");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        hostingType: { type: "string", required: false, description: "cloud (default) or on-premise", default: "cloud" },
+        authUrl: { type: "string", required: false, description: "Auth server URL (cloud)", env: "HALOPSA_AUTH_URL" },
+        appUrl: { type: "string", required: false, description: "App URL (on-premise)", env: "HALOPSA_APP_URL" },
+        resourceApiUrl: { type: "string", required: true, description: "Resource API URL", env: "HALOPSA_API_URL" },
+        clientId: { type: "string", required: true, description: "OAuth2 client ID", env: "HALOPSA_CLIENT_ID" },
+        clientSecret: { type: "string", required: true, description: "OAuth2 client secret", env: "HALOPSA_CLIENT_SECRET" },
+        scope: { type: "string", required: false, description: "OAuth2 scope (default: all)", default: "all" },
+        tenant: { type: "string", required: false, description: "Tenant (cloud only)" },
+    });
+    registerCrud(rl, "client", "/client");
+    registerCrud(rl, "site", "/site");
+    registerCrud(rl, "ticket", "/tickets");
+    registerCrud(rl, "user", "/users");
+}

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

@@ -0,0 +1,163 @@
+const BASE_URL = "https://api.harvestapp.com/v2";
+async function apiRequest(token, accountId, 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: { Authorization: `Bearer ${token}`, "Harvest-Account-Id": accountId, "Content-Type": "application/json", "User-Agent": "Runline" },
+    };
+    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(`Harvest API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+function getConn(ctx) {
+    return { token: ctx.connection.config.token, accountId: ctx.connection.config.accountId };
+}
+function hv(ctx, method, endpoint, body, qs) {
+    const { token, accountId } = getConn(ctx);
+    return apiRequest(token, accountId, method, endpoint, body, qs);
+}
+function unwrapList(data, key) {
+    if (data && typeof data === "object" && key in data)
+        return data[key];
+    return data;
+}
+function registerCrud(rl, resource, apiPath, listKey) {
+    rl.registerAction(`${resource}.create`, {
+        description: `Create a ${resource}`, inputSchema: { properties: { type: "object", required: true, description: `${resource} data` } },
+        async execute(input, ctx) { return hv(ctx, "POST", apiPath, input.properties); },
+    });
+    rl.registerAction(`${resource}.get`, {
+        description: `Get a ${resource}`, inputSchema: { id: { type: "number", required: true, description: `${resource} ID` } },
+        async execute(input, ctx) { return hv(ctx, "GET", `${apiPath}/${input.id}`); },
+    });
+    rl.registerAction(`${resource}.list`, {
+        description: `List ${resource}s`, inputSchema: { limit: { type: "number", required: false, description: "Max results" }, page: { type: "number", required: false, description: "Page" } },
+        async execute(input, ctx) { const { limit, page } = (input ?? {}); const qs = {}; if (limit)
+            qs.per_page = limit; if (page)
+            qs.page = page; return unwrapList(await hv(ctx, "GET", apiPath, undefined, qs), listKey); },
+    });
+    rl.registerAction(`${resource}.update`, {
+        description: `Update a ${resource}`, inputSchema: { id: { type: "number", required: true, description: `${resource} ID` }, properties: { type: "object", required: true, description: "Fields to update" } },
+        async execute(input, ctx) { const { id, properties } = input; return hv(ctx, "PATCH", `${apiPath}/${id}`, properties); },
+    });
+    rl.registerAction(`${resource}.delete`, {
+        description: `Delete a ${resource}`, inputSchema: { id: { type: "number", required: true, description: `${resource} ID` } },
+        async execute(input, ctx) { await hv(ctx, "DELETE", `${apiPath}/${input.id}`); return { success: true }; },
+    });
+}
+export default function harvest(rl) {
+    rl.setName("harvest");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        token: { type: "string", required: true, description: "Harvest personal access token", env: "HARVEST_TOKEN" },
+        accountId: { type: "string", required: true, description: "Harvest account ID", env: "HARVEST_ACCOUNT_ID" },
+    });
+    // Standard CRUD resources
+    registerCrud(rl, "client", "clients", "clients");
+    registerCrud(rl, "project", "projects", "projects");
+    registerCrud(rl, "task", "tasks", "tasks");
+    registerCrud(rl, "contact", "contacts", "contacts");
+    registerCrud(rl, "invoice", "invoices", "invoices");
+    registerCrud(rl, "expense", "expenses", "expenses");
+    registerCrud(rl, "estimate", "estimates", "estimates");
+    // User (CRUD + me)
+    registerCrud(rl, "user", "users", "users");
+    rl.registerAction("user.me", {
+        description: "Get the currently authenticated user",
+        async execute(_input, ctx) { return hv(ctx, "GET", "users/me"); },
+    });
+    // Time entry (special operations)
+    rl.registerAction("timeEntry.create", {
+        description: "Create a time entry",
+        inputSchema: {
+            projectId: { type: "number", required: true, description: "Project ID" },
+            taskId: { type: "number", required: true, description: "Task ID" },
+            spentDate: { type: "string", required: true, description: "Date (YYYY-MM-DD)" },
+            hours: { type: "number", required: false, description: "Hours (for duration-based)" },
+            startedTime: { type: "string", required: false, description: "Start time HH:MM (for start/end)" },
+            endedTime: { type: "string", required: false, description: "End time HH:MM" },
+            notes: { type: "string", required: false, description: "Notes" },
+            userId: { type: "number", required: false, description: "User ID (admin only)" },
+        },
+        async execute(input, ctx) {
+            const { projectId, taskId, spentDate, hours, startedTime, endedTime, notes, userId } = input;
+            const body = { project_id: projectId, task_id: taskId, spent_date: spentDate };
+            if (hours !== undefined)
+                body.hours = hours;
+            if (startedTime)
+                body.started_time = startedTime;
+            if (endedTime)
+                body.ended_time = endedTime;
+            if (notes)
+                body.notes = notes;
+            if (userId)
+                body.user_id = userId;
+            return hv(ctx, "POST", "time_entries", body);
+        },
+    });
+    rl.registerAction("timeEntry.get", {
+        description: "Get a time entry", inputSchema: { id: { type: "number", required: true, description: "Time entry ID" } },
+        async execute(input, ctx) { return hv(ctx, "GET", `time_entries/${input.id}`); },
+    });
+    rl.registerAction("timeEntry.list", {
+        description: "List time entries",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results" },
+            page: { type: "number", required: false, description: "Page" },
+            from: { type: "string", required: false, description: "From date (YYYY-MM-DD)" },
+            to: { type: "string", required: false, description: "To date (YYYY-MM-DD)" },
+            userId: { type: "number", required: false, description: "Filter by user" },
+            projectId: { type: "number", required: false, description: "Filter by project" },
+        },
+        async execute(input, ctx) {
+            const { limit, page, from, to, userId, projectId } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.per_page = limit;
+            if (page)
+                qs.page = page;
+            if (from)
+                qs.from = from;
+            if (to)
+                qs.to = to;
+            if (userId)
+                qs.user_id = userId;
+            if (projectId)
+                qs.project_id = projectId;
+            return unwrapList(await hv(ctx, "GET", "time_entries", undefined, qs), "time_entries");
+        },
+    });
+    rl.registerAction("timeEntry.update", {
+        description: "Update a time entry",
+        inputSchema: { id: { type: "number", required: true, description: "Time entry ID" }, properties: { type: "object", required: true, description: "Fields to update" } },
+        async execute(input, ctx) { const { id, properties } = input; return hv(ctx, "PATCH", `time_entries/${id}`, properties); },
+    });
+    rl.registerAction("timeEntry.delete", {
+        description: "Delete a time entry", inputSchema: { id: { type: "number", required: true, description: "Time entry ID" } },
+        async execute(input, ctx) { await hv(ctx, "DELETE", `time_entries/${input.id}`); return { success: true }; },
+    });
+    rl.registerAction("timeEntry.restart", {
+        description: "Restart a stopped time entry", inputSchema: { id: { type: "number", required: true, description: "Time entry ID" } },
+        async execute(input, ctx) { return hv(ctx, "PATCH", `time_entries/${input.id}/restart`); },
+    });
+    rl.registerAction("timeEntry.stop", {
+        description: "Stop a running time entry", inputSchema: { id: { type: "number", required: true, description: "Time entry ID" } },
+        async execute(input, ctx) { return hv(ctx, "PATCH", `time_entries/${input.id}/stop`); },
+    });
+    // Company (read-only)
+    rl.registerAction("company.get", {
+        description: "Get company info",
+        async execute(_input, ctx) { return hv(ctx, "GET", "company"); },
+    });
+}

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

@@ -0,0 +1,176 @@
+const BASE_URL = "https://api.helpscout.net/v2";
+async function apiRequest(token, method, endpoint, body, qs) {
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = { method, headers: { Authorization: `Bearer ${token}`, "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(`HelpScout API error ${res.status}: ${await res.text()}`);
+    if (res.status === 201 || res.status === 204)
+        return { success: true, location: res.headers.get("Location") };
+    return res.json();
+}
+function unwrapEmbedded(data, key) {
+    if (data && typeof data === "object" && "_embedded" in data) {
+        return data._embedded[key];
+    }
+    return data;
+}
+export default function helpscout(rl) {
+    rl.setName("helpscout");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        accessToken: { type: "string", required: true, description: "HelpScout OAuth2 access token", env: "HELPSCOUT_ACCESS_TOKEN" },
+    });
+    const tok = (ctx) => ctx.connection.config.accessToken;
+    // ── Conversation ────────────────────────────────────
+    rl.registerAction("conversation.create", {
+        description: "Create a conversation",
+        inputSchema: {
+            subject: { type: "string", required: true, description: "Subject" },
+            customer: { type: "object", required: true, description: "{email} or {id}" },
+            mailboxId: { type: "number", required: true, description: "Mailbox ID" },
+            type: { type: "string", required: true, description: "email, phone, chat" },
+            threads: { type: "array", required: true, description: "Array of thread objects [{type, text}]" },
+            status: { type: "string", required: false, description: "active, pending, closed, spam" },
+            tags: { type: "array", required: false, description: "Tag names" },
+        },
+        async execute(input, ctx) {
+            const { subject, customer, mailboxId, type, threads, status, tags } = input;
+            const body = { subject, customer, mailboxId, type, threads };
+            if (status)
+                body.status = status;
+            if (tags)
+                body.tags = tags;
+            return apiRequest(tok(ctx), "POST", "/conversations", body);
+        },
+    });
+    rl.registerAction("conversation.get", {
+        description: "Get a conversation",
+        inputSchema: { conversationId: { type: "number", required: true, description: "Conversation ID" } },
+        async execute(input, ctx) { return apiRequest(tok(ctx), "GET", `/conversations/${input.conversationId}`); },
+    });
+    rl.registerAction("conversation.list", {
+        description: "List conversations",
+        inputSchema: {
+            mailboxId: { type: "number", required: false, description: "Filter by mailbox" },
+            status: { type: "string", required: false, description: "active, pending, closed, spam, all" },
+            limit: { type: "number", required: false, description: "Max results" },
+            page: { type: "number", required: false, description: "Page" },
+        },
+        async execute(input, ctx) {
+            const { mailboxId, status, limit, page } = (input ?? {});
+            const qs = {};
+            if (mailboxId)
+                qs.mailbox = mailboxId;
+            if (status)
+                qs.status = status;
+            if (limit)
+                qs.pageSize = limit;
+            if (page)
+                qs.page = page;
+            return unwrapEmbedded(await apiRequest(tok(ctx), "GET", "/conversations", undefined, qs), "conversations");
+        },
+    });
+    rl.registerAction("conversation.delete", {
+        description: "Delete a conversation",
+        inputSchema: { conversationId: { type: "number", required: true, description: "Conversation ID" } },
+        async execute(input, ctx) { await apiRequest(tok(ctx), "DELETE", `/conversations/${input.conversationId}`); return { success: true }; },
+    });
+    // ── Customer ────────────────────────────────────────
+    rl.registerAction("customer.create", {
+        description: "Create a customer",
+        inputSchema: {
+            firstName: { type: "string", required: true, description: "First name" },
+            lastName: { type: "string", required: false, description: "Last name" },
+            emails: { type: "array", required: false, description: "Array of {type, value} email objects" },
+            phones: { type: "array", required: false, description: "Phone objects" },
+        },
+        async execute(input, ctx) {
+            const { firstName, lastName, emails, phones } = input;
+            const body = { firstName };
+            if (lastName)
+                body.lastName = lastName;
+            if (emails)
+                body.emails = emails;
+            if (phones)
+                body.phones = phones;
+            return apiRequest(tok(ctx), "POST", "/customers", body);
+        },
+    });
+    rl.registerAction("customer.get", {
+        description: "Get a customer",
+        inputSchema: { customerId: { type: "number", required: true, description: "Customer ID" } },
+        async execute(input, ctx) { return apiRequest(tok(ctx), "GET", `/customers/${input.customerId}`); },
+    });
+    rl.registerAction("customer.list", {
+        description: "List customers",
+        inputSchema: { limit: { type: "number", required: false, description: "Max results" }, page: { type: "number", required: false, description: "Page" } },
+        async execute(input, ctx) {
+            const { limit, page } = (input ?? {});
+            const qs = {};
+            if (limit)
+                qs.pageSize = limit;
+            if (page)
+                qs.page = page;
+            return unwrapEmbedded(await apiRequest(tok(ctx), "GET", "/customers", undefined, qs), "customers");
+        },
+    });
+    rl.registerAction("customer.update", {
+        description: "Update a customer",
+        inputSchema: {
+            customerId: { type: "number", required: true, description: "Customer ID" },
+            properties: { type: "object", required: true, description: "Fields to update" },
+        },
+        async execute(input, ctx) {
+            const { customerId, properties } = input;
+            return apiRequest(tok(ctx), "PUT", `/customers/${customerId}`, properties);
+        },
+    });
+    rl.registerAction("customer.getProperties", {
+        description: "Get custom properties for a customer",
+        inputSchema: { customerId: { type: "number", required: true, description: "Customer ID" } },
+        async execute(input, ctx) { return apiRequest(tok(ctx), "GET", `/customers/${input.customerId}/properties`); },
+    });
+    // ── Mailbox ─────────────────────────────────────────
+    rl.registerAction("mailbox.get", {
+        description: "Get a mailbox",
+        inputSchema: { mailboxId: { type: "number", required: true, description: "Mailbox ID" } },
+        async execute(input, ctx) { return apiRequest(tok(ctx), "GET", `/mailboxes/${input.mailboxId}`); },
+    });
+    rl.registerAction("mailbox.list", {
+        description: "List mailboxes",
+        async execute(_input, ctx) { return unwrapEmbedded(await apiRequest(tok(ctx), "GET", "/mailboxes"), "mailboxes"); },
+    });
+    // ── Thread ──────────────────────────────────────────
+    rl.registerAction("thread.create", {
+        description: "Create a thread (reply/note) on a conversation",
+        inputSchema: {
+            conversationId: { type: "number", required: true, description: "Conversation ID" },
+            type: { type: "string", required: true, description: "reply, note, phone, chat" },
+            text: { type: "string", required: true, description: "Thread body (HTML)" },
+            customer: { type: "object", required: false, description: "Customer {email} or {id}" },
+        },
+        async execute(input, ctx) {
+            const { conversationId, type, text, customer } = input;
+            const body = { type, text };
+            if (customer)
+                body.customer = customer;
+            return apiRequest(tok(ctx), "POST", `/conversations/${conversationId}/reply`, body);
+        },
+    });
+    rl.registerAction("thread.list", {
+        description: "List threads in a conversation",
+        inputSchema: { conversationId: { type: "number", required: true, description: "Conversation ID" } },
+        async execute(input, ctx) {
+            return unwrapEmbedded(await apiRequest(tok(ctx), "GET", `/conversations/${input.conversationId}/threads`), "threads");
+        },
+    });
+}