runline 0.7.7 → 0.8.1

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

@@ -0,0 +1,203 @@
+import { googleAccessToken } from "../../_shared/googleAuth.js";
+const SCRIPT_API = "https://script.googleapis.com/v1";
+const DRIVE_API = "https://www.googleapis.com/drive/v3";
+const SCOPES = [
+    "https://www.googleapis.com/auth/script.projects",
+    "https://www.googleapis.com/auth/script.deployments",
+    "https://www.googleapis.com/auth/script.processes",
+    "https://www.googleapis.com/auth/drive.metadata.readonly",
+];
+function accessToken(ctx) {
+    return googleAccessToken(ctx, "googleAppsScript", SCOPES);
+}
+async function call(ctx, method, url, payload) {
+    const headers = { Authorization: `Bearer ${await accessToken(ctx)}` };
+    if (payload !== undefined)
+        headers["Content-Type"] = "application/json";
+    const res = await fetch(url, {
+        method,
+        headers,
+        body: payload !== undefined ? JSON.stringify(payload) : undefined,
+    });
+    const text = await res.text();
+    let json;
+    try {
+        json = text ? JSON.parse(text) : {};
+    }
+    catch {
+        json = { raw: text };
+    }
+    if (!res.ok) {
+        const msg = json?.error?.message || json?.error_description || text.slice(0, 300) || res.status;
+        throw new Error(`googleAppsScript: ${method} ${res.status}: ${msg}`);
+    }
+    return json;
+}
+export default function googleAppsScript(rl) {
+    rl.setName("googleAppsScript");
+    rl.setVersion("1.0.0");
+    rl.setConnectionSchema({
+        clientId: { type: "string", required: false, description: "OAuth client ID", env: "GOOGLE_APPS_SCRIPT_CLIENT_ID" },
+        clientSecret: { type: "string", required: false, description: "OAuth client secret", env: "GOOGLE_APPS_SCRIPT_CLIENT_SECRET" },
+        refreshToken: { type: "string", required: false, description: "OAuth refresh token", env: "GOOGLE_APPS_SCRIPT_REFRESH_TOKEN" },
+        serviceAccountJson: { type: "string", required: false, description: "Service-account key JSON", env: "GOOGLE_APPS_SCRIPT_SERVICE_ACCOUNT_JSON" },
+        serviceAccountEmail: { type: "string", required: false, description: "Service-account email", env: "GOOGLE_APPS_SCRIPT_SERVICE_ACCOUNT_EMAIL" },
+        serviceAccountPrivateKey: { type: "string", required: false, description: "Service-account private key", env: "GOOGLE_APPS_SCRIPT_SERVICE_ACCOUNT_PRIVATE_KEY" },
+        serviceAccountSubject: { type: "string", required: false, description: "User to impersonate (domain-wide delegation)", env: "GOOGLE_APPS_SCRIPT_SERVICE_ACCOUNT_SUBJECT" },
+    });
+    rl.registerAction("script.list", {
+        description: "List Apps Script projects in Drive (standalone scripts; bound scripts live inside their container and don't appear here).",
+        inputSchema: {
+            query: { type: "string", required: false, description: "Case-insensitive name substring filter." },
+            pageSize: { type: "number", required: false, description: "Max results (default 50)." },
+        },
+        async execute(input, ctx) {
+            const params = new URLSearchParams({
+                q: "mimeType='application/vnd.google-apps.script' and trashed=false",
+                fields: "files(id,name,modifiedTime)",
+                pageSize: String(input.pageSize ?? 50),
+                orderBy: "modifiedTime desc",
+            });
+            const res = await call(ctx, "GET", `${DRIVE_API}/files?${params}`);
+            let files = res.files ?? [];
+            if (input.query) {
+                const q = String(input.query).toLowerCase();
+                files = files.filter((f) => (f.name || "").toLowerCase().includes(q));
+            }
+            return { count: files.length, scripts: files };
+        },
+    });
+    rl.registerAction("project.getContent", {
+        description: "Get all files of an Apps Script project (name, type, source).",
+        inputSchema: { scriptId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            const res = await call(ctx, "GET", `${SCRIPT_API}/projects/${input.scriptId}/content`);
+            return { scriptId: input.scriptId, files: res.files ?? [] };
+        },
+    });
+    rl.registerAction("project.readFile", {
+        description: "Read one file's source from a project.",
+        inputSchema: {
+            scriptId: { type: "string", required: true },
+            name: { type: "string", required: true, description: "File name without extension (e.g. 'Code', 'appsscript')." },
+        },
+        async execute(input, ctx) {
+            const res = await call(ctx, "GET", `${SCRIPT_API}/projects/${input.scriptId}/content`);
+            const file = (res.files ?? []).find((f) => f.name === input.name);
+            if (!file)
+                throw new Error(`No file "${input.name}". Available: ${(res.files ?? []).map((f) => f.name).join(", ")}`);
+            return { name: file.name, type: file.type, source: file.source };
+        },
+    });
+    rl.registerAction("file.edit", {
+        description: "Replace (or add) a single file's source, leaving other files untouched. Read-modify-write — the safe way to change code.",
+        inputSchema: {
+            scriptId: { type: "string", required: true },
+            name: { type: "string", required: true },
+            source: { type: "string", required: true },
+            type: { type: "string", required: false, description: "SERVER_JS (default), HTML, or JSON (for appsscript)." },
+        },
+        async execute(input, ctx) {
+            const cur = await call(ctx, "GET", `${SCRIPT_API}/projects/${input.scriptId}/content`);
+            const files = cur.files ?? [];
+            const idx = files.findIndex((f) => f.name === input.name);
+            const type = input.type || (input.name === "appsscript" ? "JSON" : files[idx]?.type || "SERVER_JS");
+            const entry = { name: input.name, type, source: input.source };
+            if (idx >= 0)
+                files[idx] = entry;
+            else
+                files.push(entry);
+            await call(ctx, "PUT", `${SCRIPT_API}/projects/${input.scriptId}/content`, { files });
+            return { scriptId: input.scriptId, updated: input.name, fileCount: files.length };
+        },
+    });
+    rl.registerAction("project.updateContent", {
+        description: "Replace the entire project file set. files = [{name, type, source}], must include the appsscript JSON manifest. Prefer file.edit for single changes.",
+        inputSchema: {
+            scriptId: { type: "string", required: true },
+            files: { type: "array", required: true, description: "[{name, type: SERVER_JS|HTML|JSON, source}]" },
+        },
+        async execute(input, ctx) {
+            const res = await call(ctx, "PUT", `${SCRIPT_API}/projects/${input.scriptId}/content`, { files: input.files });
+            return { scriptId: input.scriptId, fileCount: (res.files ?? []).length };
+        },
+    });
+    rl.registerAction("project.create", {
+        description: "Create a new Apps Script project. Pass parentId (a Drive file id, e.g. a Sheet) to bind it to that container.",
+        inputSchema: {
+            title: { type: "string", required: true },
+            parentId: { type: "string", required: false, description: "Container Drive file id for a bound script." },
+        },
+        async execute(input, ctx) {
+            const payload = { title: input.title };
+            if (input.parentId)
+                payload.parentId = input.parentId;
+            const res = await call(ctx, "POST", `${SCRIPT_API}/projects`, payload);
+            return { scriptId: res.scriptId, title: res.title, parentId: res.parentId };
+        },
+    });
+    rl.registerAction("version.create", {
+        description: "Create an immutable version of the project (needed before deploying).",
+        inputSchema: {
+            scriptId: { type: "string", required: true },
+            description: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const res = await call(ctx, "POST", `${SCRIPT_API}/projects/${input.scriptId}/versions`, { description: input.description || "" });
+            return { scriptId: input.scriptId, versionNumber: res.versionNumber, description: res.description };
+        },
+    });
+    rl.registerAction("deployment.create", {
+        description: "Deploy a version. For function.run, deploy with an API-executable manifest (executionApi access).",
+        inputSchema: {
+            scriptId: { type: "string", required: true },
+            versionNumber: { type: "number", required: true },
+            description: { type: "string", required: false },
+            manifestFileName: { type: "string", required: false, description: "Defaults to 'appsscript'." },
+        },
+        async execute(input, ctx) {
+            const res = await call(ctx, "POST", `${SCRIPT_API}/projects/${input.scriptId}/deployments`, {
+                versionNumber: input.versionNumber,
+                manifestFileName: input.manifestFileName || "appsscript",
+                description: input.description || "",
+            });
+            return { deploymentId: res.deploymentId, entryPoints: res.entryPoints };
+        },
+    });
+    rl.registerAction("function.run", {
+        description: "Run a function via scripts.run. Requires the project linked to a standard GCP project, the Apps Script API enabled, and an API-executable deployment (or devMode for the owner).",
+        inputSchema: {
+            scriptId: { type: "string", required: true },
+            functionName: { type: "string", required: true },
+            parameters: { type: "array", required: false, description: "Positional args for the function." },
+            devMode: { type: "boolean", required: false, description: "Run latest saved code (owner only). Default true." },
+        },
+        async execute(input, ctx) {
+            const res = await call(ctx, "POST", `${SCRIPT_API}/scripts/${input.scriptId}:run`, {
+                function: input.functionName,
+                parameters: input.parameters ?? [],
+                devMode: input.devMode === undefined ? true : input.devMode,
+            });
+            if (res.error) {
+                const d = res.error.details?.[0];
+                throw new Error(`Function error: ${d?.errorMessage || res.error.message}`);
+            }
+            return { done: res.done, result: res.response?.result ?? null };
+        },
+    });
+    rl.registerAction("process.list", {
+        description: "Recent executions for a project (status, function, times) — a log view.",
+        inputSchema: {
+            scriptId: { type: "string", required: true },
+            pageSize: { type: "number", required: false, description: "Default 20." },
+        },
+        async execute(input, ctx) {
+            const params = new URLSearchParams({
+                "userProcessFilter.scriptId": input.scriptId,
+                pageSize: String(input.pageSize ?? 20),
+            });
+            const res = await call(ctx, "GET", `${SCRIPT_API}/processes?${params}`);
+            return { count: (res.processes ?? []).length, processes: res.processes ?? [] };
+        },
+    });
+}

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

@@ -6,15 +6,20 @@
  * API key. Kept under the `googleImage` namespace so it doesn't
  * collide with `googleDrive`, `googleDocs`, etc.
  *
- *   await googleImage.image.create({ prompt: "a watercolor fox" })
- *   await googleImage.image.create({
- *     prompt: "edit: make the sky stormier",
- *     model: "gemini-3-pro-image-preview",
- *   })
+ *   const { images } = await googleImage.image.create({ prompt: "a watercolor fox" })
+ *   // images[0].path -> "/tmp/googleImage-….png"
+ *
+ * Generated images are written to disk and the action returns their file
+ * `path`s — never raw base64, which bloats the agent context and is
+ * stripped before delivery. Hand each `path` to the host's file-sending
+ * tool (e.g. send_file) to deliver the image.
  *
  * Nano Banana supports conversational editing — chain prompts in
  * follow-up calls and it'll keep iterating on the last image.
  */
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 const BASE = "https://generativelanguage.googleapis.com/v1beta/models";
 export default function googleImage(rl) {
     rl.setName("googleImage");
@@ -28,7 +33,7 @@ export default function googleImage(rl) {
         },
     });
     rl.registerAction("image.create", {
-        description: "Generate an image with Google's Gemini image models (Nano Banana / Imagen). Returns base64 bytes per candidate.",
+        description: "Generate an image with Google's Gemini image models (Nano Banana / Imagen). Writes the image(s) to disk and returns their file `path`s — not base64. Deliver each image to the user with send_file using its `path`.",
         inputSchema: {
             prompt: {
                 type: "string",
@@ -40,6 +45,11 @@ export default function googleImage(rl) {
                 required: false,
                 description: "gemini-2.5-flash-image (Nano Banana, default) | gemini-3-pro-image-preview | gemini-3.1-flash-image-preview",
             },
+            saveDir: {
+                type: "string",
+                required: false,
+                description: "Directory to write the image file(s) into. Defaults to the OS temp dir.",
+            },
         },
         async execute(input, ctx) {
             const p = (input ?? {});
@@ -62,18 +72,27 @@ export default function googleImage(rl) {
                 throw new Error(`Google API error ${res.status}: ${await res.text()}`);
             }
             const data = (await res.json());
+            const dir = (typeof p.saveDir === "string" && p.saveDir.trim()) || tmpdir();
+            const stamp = Date.now();
             const images = [];
             for (const candidate of data.candidates ?? []) {
                 for (const part of candidate.content?.parts ?? []) {
                     if (part.inlineData?.data) {
-                        images.push({
-                            base64: part.inlineData.data,
-                            mimeType: part.inlineData.mimeType ?? "image/png",
-                        });
+                        const mimeType = part.inlineData.mimeType ?? "image/png";
+                        const ext = mimeType.includes("jpeg") ? "jpg" : mimeType.split("/")[1] || "png";
+                        const bytes = Buffer.from(part.inlineData.data, "base64");
+                        const path = join(dir, `googleImage-${stamp}-${images.length}.${ext}`);
+                        writeFileSync(path, bytes);
+                        images.push({ path, mimeType, byteLength: bytes.length });
                     }
                 }
             }
-            return { provider: "googleImage", model, images };
+            return {
+                provider: "googleImage",
+                model,
+                images,
+                note: "Image(s) written to disk. Deliver each to the user with send_file using its `path`.",
+            };
         },
     });
 }

package/dist/plugins/linear/src/attachments.js

@@ -0,0 +1,65 @@
+import * as t from "typebox";
+import { ATTACHMENT_FIELDS, bindGetAction, bindListAction, gql, key } from "./shared.js";
+export function registerAttachmentActions(rl) {
+    const listAction = bindListAction(rl);
+    const getAction = bindGetAction(rl);
+    listAction("attachment.list", "List issue attachments.", "attachments", "AttachmentFilter", ATTACHMENT_FIELDS);
+    getAction("attachment.get", "Get an attachment by ID.", "attachment", ATTACHMENT_FIELDS);
+    rl.registerAction("attachment.create", {
+        description: "Create an attachment on an issue.",
+        inputSchema: t.Object({
+            issueId: t.String({ description: "The issue to associate the attachment with. UUID or issue identifier (e.g., 'LIN-123')" }),
+            title: t.String({ description: "The attachment title" }),
+            url: t.String({ description: "Attachment location, also used as a unique identifier. Re-creating with the same url updates the existing record" }),
+            subtitle: t.Optional(t.String({ description: "The attachment subtitle" })),
+            iconUrl: t.Optional(t.String({ description: "An icon url to display with the attachment (jpg or png, max 1MB, ideally 20x20px)" })),
+            commentBody: t.Optional(t.String({ description: "Create a linked comment with markdown body" })),
+            groupBySource: t.Optional(t.Boolean({ description: "Whether attachments for the same source application should be grouped in the Linear UI" })),
+            metadata: t.Optional(t.Object({}, { description: "Attachment metadata object with string and number values (JSONObject)" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+        }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($input: AttachmentCreateInput!) { attachmentCreate(input: $input) { success attachment { ${ATTACHMENT_FIELDS} } } }`, { input: input });
+            return data.attachmentCreate?.attachment;
+        },
+    });
+    rl.registerAction("attachment.update", {
+        description: "Update an attachment. title is required.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the attachment to update" }),
+            title: t.String({ description: "The attachment title" }),
+            subtitle: t.Optional(t.String({ description: "The attachment subtitle" })),
+            iconUrl: t.Optional(t.String({ description: "An icon url to display with the attachment" })),
+            metadata: t.Optional(t.Object({}, { description: "Attachment metadata object with string and number values (JSONObject)" })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: AttachmentUpdateInput!) { attachmentUpdate(id: $id, input: $input) { success attachment { ${ATTACHMENT_FIELDS} } } }`, { id, input: fields });
+            return data.attachmentUpdate?.attachment;
+        },
+    });
+    rl.registerAction("attachment.linkURL", {
+        description: "Link any URL to an issue. If a workspace integration matches the URL (Zendesk, GitHub, Slack, etc.) a rich attachment is created; otherwise a basic one.",
+        inputSchema: t.Object({
+            issueId: t.String({ description: "The issue for which to link the url. UUID or issue identifier (e.g., 'LIN-123')" }),
+            url: t.String({ description: "The url to link" }),
+            title: t.Optional(t.String({ description: "The title to use for the attachment" })),
+            id: t.Optional(t.String({ description: "The id for the attachment (optional UUID override)" })),
+        }),
+        async execute(input, ctx) {
+            const { issueId, url, title, id } = input;
+            const data = await gql(key(ctx), `mutation($issueId: String!, $url: String!, $title: String, $id: String) {
+          attachmentLinkURL(issueId: $issueId, url: $url, title: $title, id: $id) { success attachment { ${ATTACHMENT_FIELDS} } }
+        }`, { issueId, url, title: title ?? null, id: id ?? null });
+            return data.attachmentLinkURL?.attachment;
+        },
+    });
+    rl.registerAction("attachment.delete", {
+        description: "Delete an attachment.",
+        inputSchema: t.Object({ id: t.String({ description: "The identifier of the attachment to delete" }) }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { attachmentDelete(id: $id) { success } }`, { id: input.id });
+            return data.attachmentDelete;
+        },
+    });
+}

package/dist/plugins/linear/src/comments.js

@@ -0,0 +1,50 @@
+import * as t from "typebox";
+import { COMMENT_FIELDS, bindListAction, gql, key } from "./shared.js";
+export function registerCommentActions(rl) {
+    const listAction = bindListAction(rl);
+    rl.registerAction("issue.addComment", {
+        description: "Add a comment to an issue. Pass parentId to nest as a reply.",
+        inputSchema: t.Object({
+            issueId: t.String({ description: "The issue to associate the comment with. UUID or issue identifier (e.g., 'LIN-123')" }),
+            body: t.String({ description: "The comment content in markdown format" }),
+            parentId: t.Optional(t.String({ description: "The parent comment under which to nest this comment" })),
+            doNotSubscribeToIssue: t.Optional(t.Boolean({ description: "Prevent auto-subscription to the issue the comment is created on" })),
+            quotedText: t.Optional(t.String({ description: "The text that this comment references (inline comments)" })),
+        }),
+        async execute(input, ctx) {
+            const fields = input;
+            const data = await gql(key(ctx), `mutation($input: CommentCreateInput!) { commentCreate(input: $input) { success comment { ${COMMENT_FIELDS} } } }`, { input: fields });
+            return data.commentCreate?.comment;
+        },
+    });
+    listAction("comment.list", "List comments across the workspace.", "comments", "CommentFilter", COMMENT_FIELDS);
+    rl.registerAction("comment.get", {
+        description: "Get a comment by ID.",
+        inputSchema: t.Object({ id: t.String() }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `query($id: String!) { comment(id: $id) { ${COMMENT_FIELDS} } }`, { id: input.id });
+            return data.comment;
+        },
+    });
+    rl.registerAction("comment.update", {
+        description: "Update a comment.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the comment to update" }),
+            body: t.Optional(t.String({ description: "The comment content in markdown format" })),
+            quotedText: t.Optional(t.String({ description: "The text that this comment references (inline comments)" })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: CommentUpdateInput!) { commentUpdate(id: $id, input: $input) { success comment { ${COMMENT_FIELDS} } } }`, { id, input: fields });
+            return data.commentUpdate?.comment;
+        },
+    });
+    rl.registerAction("comment.delete", {
+        description: "Delete a comment.",
+        inputSchema: t.Object({ id: t.String() }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($id: String!) { commentDelete(id: $id) { success } }`, { id: input.id });
+            return data.commentDelete;
+        },
+    });
+}

package/dist/plugins/linear/src/cycles.js

@@ -0,0 +1,40 @@
+import * as t from "typebox";
+import { CYCLE_FIELDS, bindGetAction, bindListAction, gql, key } from "./shared.js";
+export function registerCycleActions(rl) {
+    const listAction = bindListAction(rl);
+    const getAction = bindGetAction(rl);
+    listAction("cycle.list", "List cycles. Use filter for isActive/isNext/isPrevious.", "cycles", "CycleFilter", CYCLE_FIELDS);
+    getAction("cycle.get", "Get a cycle by ID.", "cycle", CYCLE_FIELDS);
+    rl.registerAction("cycle.create", {
+        description: "Create a cycle for a team.",
+        inputSchema: t.Object({
+            teamId: t.String({ description: "The team to associate the cycle with" }),
+            startsAt: t.String({ description: "The start time of the cycle (DateTime, ISO 8601)" }),
+            endsAt: t.String({ description: "The end time of the cycle (DateTime, ISO 8601)" }),
+            name: t.Optional(t.String({ description: "The custom name of the cycle" })),
+            description: t.Optional(t.String({ description: "The description of the cycle" })),
+            completedAt: t.Optional(t.String({ description: "The completion time of the cycle (DateTime). If null, the cycle hasn't been completed" })),
+            id: t.Optional(t.String({ description: "The identifier in UUID v4 format. If none is provided, the backend will generate one" })),
+        }),
+        async execute(input, ctx) {
+            const data = await gql(key(ctx), `mutation($input: CycleCreateInput!) { cycleCreate(input: $input) { success cycle { ${CYCLE_FIELDS} } } }`, { input: input });
+            return data.cycleCreate?.cycle;
+        },
+    });
+    rl.registerAction("cycle.update", {
+        description: "Update a cycle.",
+        inputSchema: t.Object({
+            id: t.String({ description: "The identifier of the cycle to update" }),
+            name: t.Optional(t.String({ description: "The custom name of the cycle" })),
+            description: t.Optional(t.String({ description: "The description of the cycle" })),
+            startsAt: t.Optional(t.String({ description: "The start time of the cycle (DateTime, ISO 8601)" })),
+            endsAt: t.Optional(t.String({ description: "The end time of the cycle (DateTime, ISO 8601)" })),
+            completedAt: t.Optional(t.String({ description: "The completion time of the cycle (DateTime). If null, the cycle hasn't been completed" })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const data = await gql(key(ctx), `mutation($id: String!, $input: CycleUpdateInput!) { cycleUpdate(id: $id, input: $input) { success cycle { ${CYCLE_FIELDS} } } }`, { id, input: fields });
+            return data.cycleUpdate?.cycle;
+        },
+    });
+}