runline 0.1.0

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

@@ -0,0 +1,413 @@
+const BASE_URL = "https://app.asana.com/api/1.0";
+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)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify({ data: body });
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Asana API error ${res.status}: ${text}`);
+    }
+    if (res.status === 204)
+        return { success: true };
+    const json = (await res.json());
+    return json.data ?? json;
+}
+async function paginateAll(token, endpoint, qs, limit) {
+    const results = [];
+    const _qs = { limit: 100, ...qs };
+    let uri;
+    while (true) {
+        const fetchUrl = uri ?? `${BASE_URL}${endpoint}`;
+        const url = new URL(fetchUrl);
+        if (!uri) {
+            for (const [k, v] of Object.entries(_qs)) {
+                if (v !== undefined)
+                    url.searchParams.set(k, String(v));
+            }
+        }
+        const res = await fetch(url.toString(), {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            throw new Error(`Asana API error ${res.status}: ${await res.text()}`);
+        const json = (await res.json());
+        const data = json.data ?? [];
+        results.push(...data);
+        if (limit && results.length >= limit)
+            return results.slice(0, limit);
+        const nextPage = json.next_page;
+        if (!nextPage?.uri)
+            break;
+        uri = nextPage.uri;
+    }
+    return results;
+}
+function getToken(ctx) {
+    return ctx.connection.config.token;
+}
+export default function asana(rl) {
+    rl.setName("asana");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        token: {
+            type: "string",
+            required: true,
+            description: "Asana personal access token",
+            env: "ASANA_TOKEN",
+        },
+    });
+    // ── Task ────────────────────────────────────────────
+    rl.registerAction("task.create", {
+        description: "Create a new task",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Task name" },
+            workspace: { type: "string", required: true, description: "Workspace GID" },
+            assignee: { type: "string", required: false, description: "Assignee GID" },
+            projects: { type: "array", required: false, description: "Array of project GIDs" },
+            notes: { type: "string", required: false, description: "Task notes" },
+            dueOn: { type: "string", required: false, description: "Due date (YYYY-MM-DD)" },
+            completed: { type: "boolean", required: false, description: "Mark as completed" },
+        },
+        async execute(input, ctx) {
+            const { name, workspace, assignee, projects, notes, dueOn, completed, ...rest } = input;
+            const body = { name, workspace, ...rest };
+            if (assignee)
+                body.assignee = assignee;
+            if (projects)
+                body.projects = projects;
+            if (notes)
+                body.notes = notes;
+            if (dueOn)
+                body.due_on = dueOn;
+            if (completed !== undefined)
+                body.completed = completed;
+            return apiRequest(getToken(ctx), "POST", "/tasks", body);
+        },
+    });
+    rl.registerAction("task.get", {
+        description: "Get a task by ID",
+        inputSchema: {
+            taskId: { type: "string", required: true, description: "Task GID" },
+        },
+        async execute(input, ctx) {
+            const { taskId } = input;
+            return apiRequest(getToken(ctx), "GET", `/tasks/${taskId}`);
+        },
+    });
+    rl.registerAction("task.list", {
+        description: "List tasks (requires project, section, or workspace+assignee filter)",
+        inputSchema: {
+            project: { type: "string", required: false, description: "Project GID" },
+            section: { type: "string", required: false, description: "Section GID" },
+            workspace: { type: "string", required: false, description: "Workspace GID" },
+            assignee: { type: "string", required: false, description: "Assignee GID (required with workspace)" },
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { project, section, workspace, assignee, limit } = (input ?? {});
+            const qs = {};
+            if (project)
+                qs.project = project;
+            if (section)
+                qs.section = section;
+            if (workspace)
+                qs.workspace = workspace;
+            if (assignee)
+                qs.assignee = assignee;
+            return paginateAll(getToken(ctx), "/tasks", qs, limit);
+        },
+    });
+    rl.registerAction("task.update", {
+        description: "Update a task",
+        inputSchema: {
+            taskId: { type: "string", required: true, description: "Task GID" },
+            name: { type: "string", required: false, description: "Task name" },
+            notes: { type: "string", required: false, description: "Task notes" },
+            assignee: { type: "string", required: false, description: "Assignee GID" },
+            dueOn: { type: "string", required: false, description: "Due date (YYYY-MM-DD)" },
+            completed: { type: "boolean", required: false, description: "Mark as completed" },
+        },
+        async execute(input, ctx) {
+            const { taskId, dueOn, ...fields } = input;
+            const body = { ...fields };
+            if (dueOn)
+                body.due_on = dueOn;
+            return apiRequest(getToken(ctx), "PUT", `/tasks/${taskId}`, body);
+        },
+    });
+    rl.registerAction("task.delete", {
+        description: "Delete a task",
+        inputSchema: {
+            taskId: { type: "string", required: true, description: "Task GID" },
+        },
+        async execute(input, ctx) {
+            const { taskId } = input;
+            await apiRequest(getToken(ctx), "DELETE", `/tasks/${taskId}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("task.move", {
+        description: "Move a task to a section",
+        inputSchema: {
+            taskId: { type: "string", required: true, description: "Task GID" },
+            sectionId: { type: "string", required: true, description: "Section GID to move into" },
+        },
+        async execute(input, ctx) {
+            const { taskId, sectionId } = input;
+            await apiRequest(getToken(ctx), "POST", `/sections/${sectionId}/addTask`, { task: taskId });
+            return { success: true };
+        },
+    });
+    rl.registerAction("task.search", {
+        description: "Search for tasks in a workspace",
+        inputSchema: {
+            workspace: { type: "string", required: true, description: "Workspace GID" },
+            text: { type: "string", required: false, description: "Text to search in name/notes" },
+            completed: { type: "boolean", required: false, description: "Filter by completed status" },
+        },
+        async execute(input, ctx) {
+            const { workspace, text, completed } = input;
+            const qs = {};
+            if (text)
+                qs.text = text;
+            if (completed !== undefined)
+                qs.completed = completed;
+            return apiRequest(getToken(ctx), "GET", `/workspaces/${workspace}/tasks/search`, undefined, qs);
+        },
+    });
+    // ── Subtask ─────────────────────────────────────────
+    rl.registerAction("subtask.create", {
+        description: "Create a subtask on a task",
+        inputSchema: {
+            taskId: { type: "string", required: true, description: "Parent task GID" },
+            name: { type: "string", required: true, description: "Subtask name" },
+            assignee: { type: "string", required: false, description: "Assignee GID" },
+            notes: { type: "string", required: false, description: "Subtask notes" },
+            dueOn: { type: "string", required: false, description: "Due date (YYYY-MM-DD)" },
+            completed: { type: "boolean", required: false, description: "Mark as completed" },
+        },
+        async execute(input, ctx) {
+            const { taskId, dueOn, ...fields } = input;
+            const body = { ...fields };
+            if (dueOn)
+                body.due_on = dueOn;
+            return apiRequest(getToken(ctx), "POST", `/tasks/${taskId}/subtasks`, body);
+        },
+    });
+    rl.registerAction("subtask.list", {
+        description: "List subtasks of a task",
+        inputSchema: {
+            taskId: { type: "string", required: true, description: "Parent task GID" },
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { taskId, limit } = input;
+            const data = (await apiRequest(getToken(ctx), "GET", `/tasks/${taskId}/subtasks`));
+            if (limit)
+                return data.slice(0, limit);
+            return data;
+        },
+    });
+    // ── Task Comment ────────────────────────────────────
+    rl.registerAction("taskComment.add", {
+        description: "Add a comment to a task",
+        inputSchema: {
+            taskId: { type: "string", required: true, description: "Task GID" },
+            text: { type: "string", required: true, description: "Comment text" },
+            isHtml: { type: "boolean", required: false, description: "Whether text is HTML" },
+            isPinned: { type: "boolean", required: false, description: "Pin the comment" },
+        },
+        async execute(input, ctx) {
+            const { taskId, text, isHtml, isPinned } = input;
+            const body = isHtml ? { html_text: text } : { text };
+            if (isPinned)
+                body.is_pinned = true;
+            return apiRequest(getToken(ctx), "POST", `/tasks/${taskId}/stories`, body);
+        },
+    });
+    rl.registerAction("taskComment.remove", {
+        description: "Remove a comment (story) from a task",
+        inputSchema: {
+            commentId: { type: "string", required: true, description: "Comment/story GID" },
+        },
+        async execute(input, ctx) {
+            const { commentId } = input;
+            await apiRequest(getToken(ctx), "DELETE", `/stories/${commentId}`);
+            return { success: true };
+        },
+    });
+    // ── Task Tag ────────────────────────────────────────
+    rl.registerAction("taskTag.add", {
+        description: "Add a tag to a task",
+        inputSchema: {
+            taskId: { type: "string", required: true, description: "Task GID" },
+            tagId: { type: "string", required: true, description: "Tag GID" },
+        },
+        async execute(input, ctx) {
+            const { taskId, tagId } = input;
+            await apiRequest(getToken(ctx), "POST", `/tasks/${taskId}/addTag`, { tag: tagId });
+            return { success: true };
+        },
+    });
+    rl.registerAction("taskTag.remove", {
+        description: "Remove a tag from a task",
+        inputSchema: {
+            taskId: { type: "string", required: true, description: "Task GID" },
+            tagId: { type: "string", required: true, description: "Tag GID" },
+        },
+        async execute(input, ctx) {
+            const { taskId, tagId } = input;
+            await apiRequest(getToken(ctx), "POST", `/tasks/${taskId}/removeTag`, { tag: tagId });
+            return { success: true };
+        },
+    });
+    // ── Task Project ────────────────────────────────────
+    rl.registerAction("taskProject.add", {
+        description: "Add a task to a project",
+        inputSchema: {
+            taskId: { type: "string", required: true, description: "Task GID" },
+            projectId: { type: "string", required: true, description: "Project GID" },
+            section: { type: "string", required: false, description: "Section GID to insert into" },
+        },
+        async execute(input, ctx) {
+            const { taskId, projectId, section } = input;
+            const body = { project: projectId };
+            if (section)
+                body.section = section;
+            await apiRequest(getToken(ctx), "POST", `/tasks/${taskId}/addProject`, body);
+            return { success: true };
+        },
+    });
+    rl.registerAction("taskProject.remove", {
+        description: "Remove a task from a project",
+        inputSchema: {
+            taskId: { type: "string", required: true, description: "Task GID" },
+            projectId: { type: "string", required: true, description: "Project GID" },
+        },
+        async execute(input, ctx) {
+            const { taskId, projectId } = input;
+            await apiRequest(getToken(ctx), "POST", `/tasks/${taskId}/removeProject`, { project: projectId });
+            return { success: true };
+        },
+    });
+    // ── User ────────────────────────────────────────────
+    rl.registerAction("user.get", {
+        description: "Get a user by ID (or 'me' for current user)",
+        inputSchema: {
+            userId: { type: "string", required: true, description: "User GID or 'me'" },
+        },
+        async execute(input, ctx) {
+            const { userId } = input;
+            return apiRequest(getToken(ctx), "GET", `/users/${userId}`);
+        },
+    });
+    rl.registerAction("user.list", {
+        description: "List users in a workspace",
+        inputSchema: {
+            workspace: { type: "string", required: true, description: "Workspace GID" },
+        },
+        async execute(input, ctx) {
+            const { workspace } = input;
+            return apiRequest(getToken(ctx), "GET", `/workspaces/${workspace}/users`);
+        },
+    });
+    // ── Project ─────────────────────────────────────────
+    rl.registerAction("project.create", {
+        description: "Create a new project",
+        inputSchema: {
+            name: { type: "string", required: true, description: "Project name" },
+            workspace: { type: "string", required: true, description: "Workspace GID" },
+            team: { type: "string", required: true, description: "Team GID" },
+            notes: { type: "string", required: false, description: "Project description" },
+            color: { type: "string", required: false, description: "Project color" },
+            dueOn: { type: "string", required: false, description: "Due date (YYYY-MM-DD)" },
+        },
+        async execute(input, ctx) {
+            const { name, workspace, team, notes, color, dueOn } = input;
+            const body = { name, workspace };
+            if (notes)
+                body.notes = notes;
+            if (color)
+                body.color = color;
+            if (dueOn)
+                body.due_on = dueOn;
+            return apiRequest(getToken(ctx), "POST", `/teams/${team}/projects`, body);
+        },
+    });
+    rl.registerAction("project.get", {
+        description: "Get a project by ID",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project GID" },
+        },
+        async execute(input, ctx) {
+            const { projectId } = input;
+            return apiRequest(getToken(ctx), "GET", `/projects/${projectId}`);
+        },
+    });
+    rl.registerAction("project.list", {
+        description: "List projects in a workspace",
+        inputSchema: {
+            workspace: { type: "string", required: true, description: "Workspace GID" },
+            team: { type: "string", required: false, description: "Filter by team GID" },
+            archived: { type: "boolean", required: false, description: "Filter by archived status" },
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { workspace, team, archived, limit } = (input ?? {});
+            const qs = {};
+            if (team) {
+                qs.team = team;
+            }
+            else {
+                qs.workspace = workspace;
+            }
+            if (archived !== undefined)
+                qs.archived = archived;
+            return paginateAll(getToken(ctx), "/projects", qs, limit);
+        },
+    });
+    rl.registerAction("project.update", {
+        description: "Update a project",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project GID" },
+            name: { type: "string", required: false, description: "Project name" },
+            notes: { type: "string", required: false, description: "Project description" },
+            color: { type: "string", required: false, description: "Project color" },
+            owner: { type: "string", required: false, description: "Owner GID" },
+            dueOn: { type: "string", required: false, description: "Due date (YYYY-MM-DD)" },
+        },
+        async execute(input, ctx) {
+            const { projectId, dueOn, ...fields } = input;
+            const body = { ...fields };
+            if (dueOn)
+                body.due_on = dueOn;
+            return apiRequest(getToken(ctx), "PUT", `/projects/${projectId}`, body);
+        },
+    });
+    rl.registerAction("project.delete", {
+        description: "Delete a project",
+        inputSchema: {
+            projectId: { type: "string", required: true, description: "Project GID" },
+        },
+        async execute(input, ctx) {
+            const { projectId } = input;
+            await apiRequest(getToken(ctx), "DELETE", `/projects/${projectId}`);
+            return { success: true };
+        },
+    });
+}

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

@@ -0,0 +1,203 @@
+const BASE_URL = "https://api2.autopilothq.com/v1";
+async function apiRequest(apiKey, method, endpoint, body) {
+    const opts = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            autopilotapikey: apiKey,
+        },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(`${BASE_URL}${endpoint}`, opts);
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Autopilot API error ${res.status}: ${text}`);
+    }
+    if (res.status === 204 || res.headers.get("content-length") === "0")
+        return { success: true };
+    return res.json();
+}
+async function paginateAll(apiKey, endpoint, dataKey, limit) {
+    const results = [];
+    let currentEndpoint = endpoint;
+    while (true) {
+        const data = (await apiRequest(apiKey, "GET", currentEndpoint));
+        const items = data[dataKey] ?? [];
+        results.push(...items);
+        if (limit && results.length >= limit)
+            return results.slice(0, limit);
+        const bookmark = data.bookmark;
+        if (!bookmark)
+            break;
+        currentEndpoint = `${endpoint}/${bookmark}`;
+    }
+    return results;
+}
+function getKey(ctx) {
+    return ctx.connection.config.apiKey;
+}
+export default function autopilot(rl) {
+    rl.setName("autopilot");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: {
+            type: "string",
+            required: true,
+            description: "Autopilot API key",
+            env: "AUTOPILOT_API_KEY",
+        },
+    });
+    // ── Contact ─────────────────────────────────────────
+    rl.registerAction("contact.upsert", {
+        description: "Create or update a contact",
+        inputSchema: {
+            email: { type: "string", required: true, description: "Contact email" },
+            firstName: { type: "string", required: false, description: "First name" },
+            lastName: { type: "string", required: false, description: "Last name" },
+            company: { type: "string", required: false, description: "Company" },
+            phone: { type: "string", required: false, description: "Phone" },
+            listId: { type: "string", required: false, description: "Add to this list" },
+            newEmail: { type: "string", required: false, description: "Change email address" },
+        },
+        async execute(input, ctx) {
+            const { email, firstName, lastName, company, phone, listId, newEmail, ...rest } = input;
+            const contact = { Email: email, ...rest };
+            if (firstName)
+                contact.FirstName = firstName;
+            if (lastName)
+                contact.LastName = lastName;
+            if (company)
+                contact.Company = company;
+            if (phone)
+                contact.Phone = phone;
+            if (listId)
+                contact._autopilot_list = listId;
+            if (newEmail)
+                contact._NewEmail = newEmail;
+            return apiRequest(getKey(ctx), "POST", "/contact", { contact });
+        },
+    });
+    rl.registerAction("contact.get", {
+        description: "Get a contact by ID or email",
+        inputSchema: {
+            contactId: { type: "string", required: true, description: "Contact ID or email" },
+        },
+        async execute(input, ctx) {
+            const { contactId } = input;
+            return apiRequest(getKey(ctx), "GET", `/contact/${contactId}`);
+        },
+    });
+    rl.registerAction("contact.list", {
+        description: "List all contacts",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            return paginateAll(getKey(ctx), "/contacts", "contacts", limit);
+        },
+    });
+    rl.registerAction("contact.delete", {
+        description: "Delete a contact",
+        inputSchema: {
+            contactId: { type: "string", required: true, description: "Contact ID" },
+        },
+        async execute(input, ctx) {
+            const { contactId } = input;
+            await apiRequest(getKey(ctx), "DELETE", `/contact/${contactId}`);
+            return { success: true };
+        },
+    });
+    // ── Contact Journey ─────────────────────────────────
+    rl.registerAction("contactJourney.add", {
+        description: "Add a contact to a journey/trigger",
+        inputSchema: {
+            triggerId: { type: "string", required: true, description: "Trigger/journey ID" },
+            contactId: { type: "string", required: true, description: "Contact ID" },
+        },
+        async execute(input, ctx) {
+            const { triggerId, contactId } = input;
+            await apiRequest(getKey(ctx), "POST", `/trigger/${triggerId}/contact/${contactId}`);
+            return { success: true };
+        },
+    });
+    // ── Contact List ────────────────────────────────────
+    rl.registerAction("contactList.add", {
+        description: "Add a contact to a list",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            contactId: { type: "string", required: true, description: "Contact ID" },
+        },
+        async execute(input, ctx) {
+            const { listId, contactId } = input;
+            await apiRequest(getKey(ctx), "POST", `/list/${listId}/contact/${contactId}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("contactList.remove", {
+        description: "Remove a contact from a list",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            contactId: { type: "string", required: true, description: "Contact ID" },
+        },
+        async execute(input, ctx) {
+            const { listId, contactId } = input;
+            await apiRequest(getKey(ctx), "DELETE", `/list/${listId}/contact/${contactId}`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("contactList.exists", {
+        description: "Check if a contact is in a list",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            contactId: { type: "string", required: true, description: "Contact ID" },
+        },
+        async execute(input, ctx) {
+            const { listId, contactId } = input;
+            try {
+                await apiRequest(getKey(ctx), "GET", `/list/${listId}/contact/${contactId}`);
+                return { exists: true };
+            }
+            catch {
+                return { exists: false };
+            }
+        },
+    });
+    rl.registerAction("contactList.list", {
+        description: "List all contacts in a list",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List ID" },
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { listId, limit } = input;
+            return paginateAll(getKey(ctx), `/list/${listId}/contacts`, "contacts", limit);
+        },
+    });
+    // ── List ────────────────────────────────────────────
+    rl.registerAction("list.create", {
+        description: "Create a new list",
+        inputSchema: {
+            name: { type: "string", required: true, description: "List name" },
+        },
+        async execute(input, ctx) {
+            const { name } = input;
+            return apiRequest(getKey(ctx), "POST", "/list", { name });
+        },
+    });
+    rl.registerAction("list.list", {
+        description: "List all lists",
+        inputSchema: {
+            limit: { type: "number", required: false, description: "Max results to return" },
+        },
+        async execute(input, ctx) {
+            const { limit } = (input ?? {});
+            const data = (await apiRequest(getKey(ctx), "GET", "/lists"));
+            if (limit)
+                return data.lists.slice(0, limit);
+            return data.lists;
+        },
+    });
+}