runline 0.11.2 → 0.11.4

package/dist/plugin/loader.js

@@ -55,6 +55,9 @@ export async function loadPluginFromPath(path) {
         : mod;
     return resolvePluginExport(pluginExport, pluginId);
 }
+function isPrivatePluginDirectory(entry) {
+    return entry.startsWith("_") || entry.startsWith(".");
+}
 async function loadFromDirectory(dir) {
     const plugins = [];
     if (!existsSync(dir))
@@ -75,6 +78,8 @@ async function loadFromDirectory(dir) {
             }
         }
         else if (stat.isDirectory()) {
+            if (isPrivatePluginDirectory(entry))
+                continue;
             const candidates = [
                 join(fullPath, "index.ts"),
                 join(fullPath, "index.js"),

package/dist/plugins/googleDocs/src/documents.js

@@ -0,0 +1,91 @@
+import { DRIVE_BASE, docsRequest, extractDocumentId, flattenBodyText, } from "./shared.js";
+export function registerDocumentsActions(rl) {
+    rl.registerAction("document.create", {
+        description: "Create a new Google Doc, optionally in a specific Drive folder (goes through the Drive API; needs drive.file scope).",
+        inputSchema: {
+            title: { type: "string", required: true },
+            folderId: {
+                type: "string",
+                required: false,
+                description: "Parent folder in Drive. Omit to place in My Drive root.",
+            },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const body = {
+                name: p.title,
+                mimeType: "application/vnd.google-apps.document",
+            };
+            if (p.folderId) {
+                body.parents = [p.folderId];
+            }
+            return docsRequest(ctx, "POST", "/files", body, undefined, DRIVE_BASE);
+        },
+    });
+    rl.registerAction("document.createBlank", {
+        description: "Create a blank Google Doc through the native Docs API. Use document.create when you need Drive folder placement.",
+        inputSchema: {
+            title: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            return docsRequest(ctx, "POST", "/documents", { title: p.title });
+        },
+    });
+    rl.registerAction("document.get", {
+        description: "Get a document. Accepts a bare ID or a docs.google.com URL. `simple=true` collapses the body to plain text.",
+        inputSchema: {
+            document: {
+                type: "string",
+                required: true,
+                description: "Document ID or URL",
+            },
+            simple: { type: "boolean", required: false },
+            suggestionsViewMode: {
+                type: "string",
+                required: false,
+                description: "DEFAULT_FOR_CURRENT_ACCESS | SUGGESTIONS_INLINE | PREVIEW_SUGGESTIONS_ACCEPTED | PREVIEW_WITHOUT_SUGGESTIONS",
+            },
+            includeTabsContent: {
+                type: "boolean",
+                required: false,
+                description: "Return content for all tabs in document.tabs instead of only first-tab legacy fields.",
+            },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            const qs = {};
+            if (p.suggestionsViewMode)
+                qs.suggestionsViewMode = p.suggestionsViewMode;
+            if (p.includeTabsContent !== undefined)
+                qs.includeTabsContent = p.includeTabsContent;
+            const res = (await docsRequest(ctx, "GET", `/documents/${documentId}`, undefined, qs));
+            if (!p.simple)
+                return res;
+            return { documentId, content: flattenBodyText(res.body) };
+        },
+    });
+    rl.registerAction("document.batchUpdate", {
+        description: "Raw passthrough to documents.batchUpdate — pass a full `requests` array for atomic multi-edit operations.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            requests: { type: "array", required: true },
+            writeControl: {
+                type: "object",
+                required: false,
+                description: "{requiredRevisionId} | {targetRevisionId}",
+            },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            const body = {
+                requests: p.requests,
+            };
+            if (p.writeControl)
+                body.writeControl = p.writeControl;
+            return docsRequest(ctx, "POST", `/documents/${documentId}:batchUpdate`, body);
+        },
+    });
+}

package/dist/plugins/googleDocs/src/formatting.js

@@ -0,0 +1,126 @@
+import { compact, extractDocumentId, runBatchUpdate } from "./shared.js";
+export function registerFormattingActions(rl) {
+    rl.registerAction("document.updateParagraphStyle", {
+        description: "Apply paragraph styling (alignment, named style, indents, spacing, direction) to the paragraphs intersecting the range.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            startIndex: { type: "number", required: true },
+            endIndex: { type: "number", required: true },
+            alignment: {
+                type: "string",
+                required: false,
+                description: "START | CENTER | END | JUSTIFIED",
+            },
+            namedStyleType: {
+                type: "string",
+                required: false,
+                description: "NORMAL_TEXT | TITLE | SUBTITLE | HEADING_1 .. HEADING_6",
+            },
+            direction: {
+                type: "string",
+                required: false,
+                description: "LEFT_TO_RIGHT | RIGHT_TO_LEFT",
+            },
+            indentFirstLinePt: { type: "number", required: false },
+            indentStartPt: { type: "number", required: false },
+            indentEndPt: { type: "number", required: false },
+            spaceAbovePt: { type: "number", required: false },
+            spaceBelowPt: { type: "number", required: false },
+            lineSpacing: {
+                type: "number",
+                required: false,
+                description: "Percentage; 100 = single, 150 = 1.5x.",
+            },
+            segmentId: { type: "string", required: false },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            const ps = {};
+            const fields = [];
+            const pt = (n) => ({ magnitude: n, unit: "PT" });
+            if (p.alignment) {
+                ps.alignment = p.alignment;
+                fields.push("alignment");
+            }
+            if (p.namedStyleType) {
+                ps.namedStyleType = p.namedStyleType;
+                fields.push("namedStyleType");
+            }
+            if (p.direction) {
+                ps.direction = p.direction;
+                fields.push("direction");
+            }
+            if (p.indentFirstLinePt !== undefined) {
+                ps.indentFirstLine = pt(p.indentFirstLinePt);
+                fields.push("indentFirstLine");
+            }
+            if (p.indentStartPt !== undefined) {
+                ps.indentStart = pt(p.indentStartPt);
+                fields.push("indentStart");
+            }
+            if (p.indentEndPt !== undefined) {
+                ps.indentEnd = pt(p.indentEndPt);
+                fields.push("indentEnd");
+            }
+            if (p.spaceAbovePt !== undefined) {
+                ps.spaceAbove = pt(p.spaceAbovePt);
+                fields.push("spaceAbove");
+            }
+            if (p.spaceBelowPt !== undefined) {
+                ps.spaceBelow = pt(p.spaceBelowPt);
+                fields.push("spaceBelow");
+            }
+            if (p.lineSpacing !== undefined) {
+                ps.lineSpacing = p.lineSpacing;
+                fields.push("lineSpacing");
+            }
+            if (fields.length === 0) {
+                throw new Error("googleDocs.document.updateParagraphStyle: at least one property required");
+            }
+            return runBatchUpdate(ctx, documentId, [
+                {
+                    updateParagraphStyle: {
+                        range: compact({
+                            startIndex: p.startIndex,
+                            endIndex: p.endIndex,
+                            segmentId: p.segmentId,
+                            tabId: p.tabId,
+                        }),
+                        paragraphStyle: ps,
+                        fields: fields.join(","),
+                    },
+                },
+            ]);
+        },
+    });
+    rl.registerAction("document.updateNamedStyle", {
+        description: "Update a named style such as NORMAL_TEXT, TITLE, or HEADING_1 using a Docs API NamedStyle object.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            namedStyle: {
+                type: "object",
+                required: true,
+                description: "Docs API NamedStyle object. Must include namedStyleType.",
+            },
+            fields: {
+                type: "string",
+                required: true,
+                description: "Field mask such as textStyle.bold or paragraphStyle.alignment.",
+            },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            return runBatchUpdate(ctx, documentId, {
+                updateNamedStyle: compact({
+                    namedStyle: p.namedStyle,
+                    fields: p.fields,
+                    tabId: p.tabId,
+                }),
+            });
+        },
+    });
+}

package/dist/plugins/googleDocs/src/images.js

@@ -0,0 +1,66 @@
+import { buildLocation, extractDocumentId, runBatchUpdate } from "./shared.js";
+export function registerImagesActions(rl) {
+    rl.registerAction("document.insertInlineImage", {
+        description: "Insert an inline image at the given location. `uri` must point to a publicly fetchable image.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            locationKind: {
+                type: "string",
+                required: false,
+                description: "location (default; requires index) | endOfSegmentLocation",
+            },
+            index: { type: "number", required: false },
+            uri: { type: "string", required: true },
+            widthPt: { type: "number", required: false },
+            heightPt: { type: "number", required: false },
+            segmentId: { type: "string", required: false },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            const pt = (n) => ({ magnitude: n, unit: "PT" });
+            const kind = p.locationKind ?? "location";
+            const req = {
+                ...buildLocation(kind, p.segmentId, p.index, p.tabId),
+                uri: p.uri,
+            };
+            if (p.widthPt !== undefined || p.heightPt !== undefined) {
+                req.objectSize = {};
+                if (p.widthPt !== undefined)
+                    req.objectSize.width = pt(p.widthPt);
+                if (p.heightPt !== undefined)
+                    req.objectSize.height = pt(p.heightPt);
+            }
+            return runBatchUpdate(ctx, documentId, [{ insertInlineImage: req }]);
+        },
+    });
+    rl.registerAction("document.replaceImage", {
+        description: "Replace an existing image (identified by its inline-object id) with a new image from a publicly fetchable URI.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            imageObjectId: { type: "string", required: true },
+            uri: { type: "string", required: true },
+            imageReplaceMethod: {
+                type: "string",
+                required: false,
+                description: "CENTER_CROP (default) | (others as Docs API adds them)",
+            },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            return runBatchUpdate(ctx, documentId, [
+                {
+                    replaceImage: {
+                        imageObjectId: p.imageObjectId,
+                        uri: p.uri,
+                        imageReplaceMethod: p.imageReplaceMethod ?? "CENTER_CROP",
+                        ...(p.tabId ? { tabId: p.tabId } : {}),
+                    },
+                },
+            ]);
+        },
+    });
+}