runline 0.11.2 → 0.11.4

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

@@ -0,0 +1,110 @@
+import { googleAccessToken } from "../../_shared/googleAuth.js";
+export const SCOPES = [
+    "https://www.googleapis.com/auth/documents",
+    "https://www.googleapis.com/auth/drive.file",
+];
+export const DOCS_BASE = "https://docs.googleapis.com/v1";
+export const DRIVE_BASE = "https://www.googleapis.com/drive/v3";
+export async function accessToken(ctx) {
+    return googleAccessToken(ctx, "googleDocs", SCOPES);
+}
+export async function docsRequest(ctx, method, path, body, qs, baseOverride) {
+    const token = await accessToken(ctx);
+    const url = new URL(`${baseOverride ?? DOCS_BASE}${path}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v === undefined || v === null)
+                continue;
+            url.searchParams.set(k, String(v));
+        }
+    }
+    const init = {
+        method,
+        headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+    };
+    if (body && Object.keys(body).length > 0) {
+        init.headers["Content-Type"] =
+            "application/json";
+        init.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), init);
+    if (res.status === 204)
+        return { success: true };
+    const text = await res.text();
+    if (!res.ok) {
+        throw new Error(`googleDocs: ${method} ${path} → ${res.status} ${text}`);
+    }
+    return text ? JSON.parse(text) : { success: true };
+}
+const DOC_URL_REGEX = /https:\/\/docs\.google\.com\/document\/d\/([a-zA-Z0-9-_]+)/;
+export function extractDocumentId(input) {
+    if (!input)
+        throw new Error("googleDocs: documentId or URL is required");
+    const m = input.match(DOC_URL_REGEX);
+    return m ? m[1] : input;
+}
+export function buildLocation(kind, segmentId, index, tabId) {
+    const seg = segmentId && segmentId !== "body" ? segmentId : "";
+    if (kind === "endOfSegmentLocation") {
+        return { endOfSegmentLocation: compact({ segmentId: seg, tabId }) };
+    }
+    if (index === undefined || index === null) {
+        throw new Error("googleDocs: `index` is required when location kind is 'location'");
+    }
+    return { location: location(index, segmentId, tabId) };
+}
+export function location(index, segmentId, tabId) {
+    const seg = segmentId && segmentId !== "body" ? segmentId : "";
+    return compact({ segmentId: seg, index, tabId });
+}
+export function compact(obj) {
+    for (const key of Object.keys(obj)) {
+        if (obj[key] === undefined || obj[key] === null)
+            delete obj[key];
+    }
+    return obj;
+}
+export async function runBatchUpdate(ctx, documentId, requestOrRequests, writeControl) {
+    const requests = Array.isArray(requestOrRequests)
+        ? requestOrRequests
+        : [requestOrRequests];
+    const body = { requests };
+    if (writeControl)
+        body.writeControl = writeControl;
+    const res = (await docsRequest(ctx, "POST", `/documents/${documentId}:batchUpdate`, body));
+    if (requests.length !== 1)
+        return { documentId, replies: res.replies ?? [] };
+    const reply = res.replies?.[0] ?? {};
+    const key = Object.keys(reply)[0];
+    return { documentId, ...(key ? { [key]: reply[key] } : {}) };
+}
+export function flattenBodyText(body) {
+    const parts = [];
+    const content = body?.content ?? [];
+    for (const item of content) {
+        const para = item.paragraph;
+        if (!para?.elements)
+            continue;
+        for (const el of para.elements) {
+            const tr = el.textRun;
+            if (tr?.content)
+                parts.push(tr.content);
+        }
+    }
+    return parts.join("");
+}
+export function hexToRgbF(hex) {
+    const h = hex.replace(/^#/, "");
+    const full = h.length === 3
+        ? h
+            .split("")
+            .map((c) => c + c)
+            .join("")
+        : h;
+    const n = parseInt(full, 16);
+    return {
+        red: ((n >> 16) & 0xff) / 255,
+        green: ((n >> 8) & 0xff) / 255,
+        blue: (n & 0xff) / 255,
+    };
+}

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

@@ -0,0 +1,392 @@
+import { buildLocation, compact, extractDocumentId, location, runBatchUpdate, } from "./shared.js";
+function range(p) {
+    return compact({
+        segmentId: p.segmentId && p.segmentId !== "body" ? p.segmentId : "",
+        startIndex: p.startIndex,
+        endIndex: p.endIndex,
+        tabId: p.tabId,
+    });
+}
+function point(value) {
+    return { magnitude: value, unit: "PT" };
+}
+export function registerStructureActions(rl) {
+    rl.registerAction("document.insertPageBreak", {
+        description: "Insert a page break at an index or at the end of a segment.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            locationKind: { type: "string", required: false },
+            index: { 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 kind = p.locationKind ?? "location";
+            return runBatchUpdate(ctx, documentId, {
+                insertPageBreak: buildLocation(kind, p.segmentId, p.index, p.tabId),
+            });
+        },
+    });
+    rl.registerAction("document.createNamedRange", {
+        description: "Create a named range over a span of text (useful for later programmatic edits).",
+        inputSchema: {
+            document: { type: "string", required: true },
+            name: { type: "string", required: true },
+            startIndex: { type: "number", required: true },
+            endIndex: { type: "number", required: true },
+            segmentId: { type: "string", required: false },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            return runBatchUpdate(ctx, documentId, {
+                createNamedRange: {
+                    name: p.name,
+                    range: range(p),
+                },
+            });
+        },
+    });
+    rl.registerAction("document.deleteNamedRange", {
+        description: "Delete named range(s). Pass one of `namedRangeId` or `name`; the latter deletes every range sharing that name.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            namedRangeId: { type: "string", required: false },
+            name: { type: "string", required: false },
+            tabIds: {
+                type: "array",
+                required: false,
+                description: "Optional tab IDs for tabsCriteria.",
+            },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            if (!p.namedRangeId && !p.name) {
+                throw new Error("googleDocs: provide namedRangeId or name");
+            }
+            const req = p.namedRangeId
+                ? { namedRangeId: p.namedRangeId }
+                : { name: p.name };
+            if (Array.isArray(p.tabIds))
+                req.tabsCriteria = { tabIds: p.tabIds };
+            return runBatchUpdate(ctx, documentId, { deleteNamedRange: req });
+        },
+    });
+    rl.registerAction("document.createHeader", {
+        description: "Create a DEFAULT header attached to a SectionBreak.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            locationKind: { type: "string", required: false },
+            index: { 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 kind = p.locationKind ?? "location";
+            const seg = p.segmentId && p.segmentId !== "body" ? p.segmentId : "";
+            const sectionBreakLocation = compact({
+                segmentId: seg,
+                tabId: p.tabId,
+            });
+            if (kind === "location") {
+                if (p.index === undefined) {
+                    throw new Error("googleDocs: `index` is required when locationKind=location");
+                }
+                sectionBreakLocation.index = p.index;
+            }
+            return runBatchUpdate(ctx, documentId, {
+                createHeader: { type: "DEFAULT", sectionBreakLocation },
+            });
+        },
+    });
+    rl.registerAction("document.deleteHeader", {
+        description: "Delete a header by ID.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            headerId: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            return runBatchUpdate(ctx, documentId, {
+                deleteHeader: compact({ headerId: p.headerId, tabId: p.tabId }),
+            });
+        },
+    });
+    rl.registerAction("document.createFooter", {
+        description: "Create a DEFAULT footer attached to a SectionBreak.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            locationKind: { type: "string", required: false },
+            index: { 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 kind = p.locationKind ?? "location";
+            const seg = p.segmentId && p.segmentId !== "body" ? p.segmentId : "";
+            const sectionBreakLocation = compact({
+                segmentId: seg,
+                tabId: p.tabId,
+            });
+            if (kind === "location") {
+                if (p.index === undefined) {
+                    throw new Error("googleDocs: `index` is required when locationKind=location");
+                }
+                sectionBreakLocation.index = p.index;
+            }
+            return runBatchUpdate(ctx, documentId, {
+                createFooter: { type: "DEFAULT", sectionBreakLocation },
+            });
+        },
+    });
+    rl.registerAction("document.deleteFooter", {
+        description: "Delete a footer by ID.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            footerId: { type: "string", required: true },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            return runBatchUpdate(ctx, documentId, {
+                deleteFooter: compact({ footerId: p.footerId, tabId: p.tabId }),
+            });
+        },
+    });
+    rl.registerAction("document.deletePositionedObject", {
+        description: "Delete a positioned object (inline image, floating image, etc.) by its objectId.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            objectId: { type: "string", required: true },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            return runBatchUpdate(ctx, documentId, {
+                deletePositionedObject: compact({
+                    objectId: p.objectId,
+                    tabId: p.tabId,
+                }),
+            });
+        },
+    });
+    rl.registerAction("document.createFootnote", {
+        description: "Create a footnote reference at a location or at the end of the document body.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            locationKind: {
+                type: "string",
+                required: false,
+                description: "location (default; requires index) | endOfSegmentLocation",
+            },
+            index: { 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 kind = p.locationKind ?? "location";
+            return runBatchUpdate(ctx, documentId, {
+                createFootnote: buildLocation(kind, p.segmentId, p.index, p.tabId),
+            });
+        },
+    });
+    rl.registerAction("document.replaceNamedRangeContent", {
+        description: "Replace the content of a named range by ID or name with text.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            text: { type: "string", required: true },
+            namedRangeId: { type: "string", required: false },
+            namedRangeName: { type: "string", required: false },
+            tabIds: {
+                type: "array",
+                required: false,
+                description: "Optional tab IDs for tabsCriteria.",
+            },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            if (!p.namedRangeId && !p.namedRangeName) {
+                throw new Error("googleDocs: provide namedRangeId or namedRangeName");
+            }
+            return runBatchUpdate(ctx, documentId, {
+                replaceNamedRangeContent: compact({
+                    text: p.text,
+                    namedRangeId: p.namedRangeId,
+                    namedRangeName: p.namedRangeName,
+                    tabsCriteria: Array.isArray(p.tabIds)
+                        ? { tabIds: p.tabIds }
+                        : undefined,
+                }),
+            });
+        },
+    });
+    rl.registerAction("document.updateSectionStyle", {
+        description: "Update section style over a range, such as margins or column properties.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            startIndex: { type: "number", required: true },
+            endIndex: { type: "number", required: true },
+            marginTopPt: { type: "number", required: false },
+            marginBottomPt: { type: "number", required: false },
+            marginLeftPt: { type: "number", required: false },
+            marginRightPt: { type: "number", required: false },
+            columnSeparatorStyle: {
+                type: "string",
+                required: false,
+                description: "NONE | BETWEEN_EACH_COLUMN",
+            },
+            contentDirection: {
+                type: "string",
+                required: false,
+                description: "LEFT_TO_RIGHT | RIGHT_TO_LEFT",
+            },
+            fields: {
+                type: "string",
+                required: false,
+                description: "Field mask. Defaults to fields implied by supplied properties.",
+            },
+            segmentId: { type: "string", required: false },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            const sectionStyle = {};
+            const fields = [];
+            if (p.marginTopPt !== undefined) {
+                sectionStyle.marginTop = point(p.marginTopPt);
+                fields.push("marginTop");
+            }
+            if (p.marginBottomPt !== undefined) {
+                sectionStyle.marginBottom = point(p.marginBottomPt);
+                fields.push("marginBottom");
+            }
+            if (p.marginLeftPt !== undefined) {
+                sectionStyle.marginLeft = point(p.marginLeftPt);
+                fields.push("marginLeft");
+            }
+            if (p.marginRightPt !== undefined) {
+                sectionStyle.marginRight = point(p.marginRightPt);
+                fields.push("marginRight");
+            }
+            if (p.columnSeparatorStyle) {
+                sectionStyle.columnSeparatorStyle = p.columnSeparatorStyle;
+                fields.push("columnSeparatorStyle");
+            }
+            if (p.contentDirection) {
+                sectionStyle.contentDirection = p.contentDirection;
+                fields.push("contentDirection");
+            }
+            const mask = p.fields ?? fields.join(",");
+            if (!mask)
+                throw new Error("googleDocs.document.updateSectionStyle: fields or section style property required");
+            return runBatchUpdate(ctx, documentId, {
+                updateSectionStyle: {
+                    range: range(p),
+                    sectionStyle,
+                    fields: mask,
+                },
+            });
+        },
+    });
+    rl.registerAction("document.insertSectionBreak", {
+        description: "Insert a section break at the given location.",
+        inputSchema: {
+            document: { type: "string", required: true },
+            index: { type: "number", required: true },
+            sectionType: {
+                type: "string",
+                required: false,
+                description: "CONTINUOUS | NEXT_PAGE. Default CONTINUOUS.",
+            },
+            segmentId: { type: "string", required: false },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            return runBatchUpdate(ctx, documentId, [
+                {
+                    insertSectionBreak: {
+                        location: location(p.index, p.segmentId, p.tabId),
+                        sectionType: p.sectionType ?? "CONTINUOUS",
+                    },
+                },
+            ]);
+        },
+    });
+    rl.registerAction("document.updateDocumentStyle", {
+        description: "Update document-level style (page size, margins, page numbers, default direction).",
+        inputSchema: {
+            document: { type: "string", required: true },
+            pageMarginTopPt: { type: "number", required: false },
+            pageMarginBottomPt: { type: "number", required: false },
+            pageMarginLeftPt: { type: "number", required: false },
+            pageMarginRightPt: { type: "number", required: false },
+            pageSizeWidthPt: { type: "number", required: false },
+            pageSizeHeightPt: { type: "number", required: false },
+            useCustomHeaderFooterMargins: { type: "boolean", required: false },
+            tabId: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const documentId = extractDocumentId(p.document);
+            const ds = {};
+            const fields = [];
+            const pt = (n) => ({ magnitude: n, unit: "PT" });
+            if (p.pageMarginTopPt !== undefined) {
+                ds.marginTop = pt(p.pageMarginTopPt);
+                fields.push("marginTop");
+            }
+            if (p.pageMarginBottomPt !== undefined) {
+                ds.marginBottom = pt(p.pageMarginBottomPt);
+                fields.push("marginBottom");
+            }
+            if (p.pageMarginLeftPt !== undefined) {
+                ds.marginLeft = pt(p.pageMarginLeftPt);
+                fields.push("marginLeft");
+            }
+            if (p.pageMarginRightPt !== undefined) {
+                ds.marginRight = pt(p.pageMarginRightPt);
+                fields.push("marginRight");
+            }
+            if (p.pageSizeWidthPt !== undefined || p.pageSizeHeightPt !== undefined) {
+                ds.pageSize = {};
+                if (p.pageSizeWidthPt !== undefined)
+                    ds.pageSize.width = pt(p.pageSizeWidthPt);
+                if (p.pageSizeHeightPt !== undefined)
+                    ds.pageSize.height = pt(p.pageSizeHeightPt);
+                fields.push("pageSize");
+            }
+            if (p.useCustomHeaderFooterMargins !== undefined) {
+                ds.useCustomHeaderFooterMargins = p.useCustomHeaderFooterMargins;
+                fields.push("useCustomHeaderFooterMargins");
+            }
+            if (fields.length === 0) {
+                throw new Error("googleDocs.document.updateDocumentStyle: pass at least one property");
+            }
+            return runBatchUpdate(ctx, documentId, [
+                {
+                    updateDocumentStyle: compact({
+                        documentStyle: ds,
+                        fields: fields.join(","),
+                        tabId: p.tabId,
+                    }),
+                },
+            ]);
+        },
+    });
+}