runline 0.28.1 → 0.30.0

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

@@ -55,7 +55,7 @@
  */
 import { createReadStream, readFileSync, statSync, writeFileSync } from "node:fs";
 import * as t from "typebox";
-import { googleAccessToken } from "../../_shared/googleAuth.js";
+import { googleJsonRequest, googleResponse } from "../../_shared/googleAuth.js";
 import { Id, NonEmptyString, RawGoogleObject, StringMap, StringOrStringArray, stringEnum, } from "../../_shared/googleSchemas.js";
 const PermissionRole = stringEnum([
     "owner",
@@ -105,46 +105,23 @@ const DRIVE = {
     UNKNOWN: "application/vnd.google-apps.unknown",
 };
 // ─── Auth ────────────────────────────────────────────────────────
-async function accessToken(ctx) {
-    return googleAccessToken(ctx, "googleDrive", SCOPES);
+function driveResponse(ctx, url, init = {}) {
+    return googleResponse(ctx, "googleDrive", SCOPES, url, init);
 }
 // ─── Request ─────────────────────────────────────────────────────
 const API_BASE = "https://www.googleapis.com";
+function filePathId(id) {
+    if (!/^[a-zA-Z0-9_-]+$/.test(id))
+        throw new Error("googleDrive: invalid file ID");
+    return id;
+}
+function uploadSession(value) {
+    if (!value || !/^https:\/\/www\.googleapis\.com\/upload\/drive\/v3\/files(?:\/[a-zA-Z0-9_-]+)?\?/.test(value))
+        throw new Error("googleDrive: invalid resumable session Location");
+    return value;
+}
 async function driveRequest(ctx, method, path, body, qs) {
-    const token = await accessToken(ctx);
-    const url = new URL(`${API_BASE}${path}`);
-    if (qs) {
-        for (const [k, v] of Object.entries(qs)) {
-            if (v === undefined || v === null)
-                continue;
-            if (Array.isArray(v)) {
-                for (const entry of v)
-                    url.searchParams.append(k, String(entry));
-            }
-            else {
-                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(`googleDrive: ${method} ${path} → ${res.status} ${text}`);
-    }
-    return text ? JSON.parse(text) : { success: true };
+    return googleJsonRequest(ctx, "googleDrive", SCOPES, method, `${API_BASE}${path}`, body, qs);
 }
 /**
  * Paginate any Drive list endpoint by repeatedly following
@@ -233,7 +210,6 @@ function buildMultipart(metadata, content, mimeType) {
  */
 async function uploadBytes(ctx, metadata, c, extraQs = {}) {
     const mimeType = c.mimeType ?? "application/octet-stream";
-    const token = await accessToken(ctx);
     if (c.buffer) {
         const body = buildMultipart(metadata, c.buffer, mimeType);
         const url = new URL(`${API_BASE}/upload/drive/v3/files`);
@@ -243,19 +219,17 @@ async function uploadBytes(ctx, metadata, c, extraQs = {}) {
             if (v !== undefined)
                 url.searchParams.set(k, String(v));
         }
-        const res = await fetch(url.toString(), {
+        const res = await driveResponse(ctx, url.toString(), {
             method: "POST",
             headers: {
-                Authorization: `Bearer ${token}`,
                 "Content-Type": `multipart/related; boundary=${MULTIPART_BOUNDARY}`,
-                "Content-Length": String(body.byteLength),
             },
             // Buffer is a Uint8Array so it's a valid BodyInit.
             body: new Uint8Array(body),
         });
         const text = await res.text();
         if (!res.ok) {
-            throw new Error(`googleDrive: upload failed (${res.status}): ${text}`);
+            throw new Error(`googleDrive: upload failed (HTTP ${res.status})`);
         }
         return JSON.parse(text);
     }
@@ -267,10 +241,9 @@ async function uploadBytes(ctx, metadata, c, extraQs = {}) {
         if (v !== undefined)
             initUrl.searchParams.set(k, String(v));
     }
-    const initRes = await fetch(initUrl.toString(), {
+    const initRes = await driveResponse(ctx, initUrl.toString(), {
         method: "POST",
         headers: {
-            Authorization: `Bearer ${token}`,
             "Content-Type": "application/json; charset=UTF-8",
             "X-Upload-Content-Type": mimeType,
             "X-Upload-Content-Length": String(c.size),
@@ -278,12 +251,9 @@ async function uploadBytes(ctx, metadata, c, extraQs = {}) {
         body: JSON.stringify(metadata),
     });
     if (!initRes.ok) {
-        const t = await initRes.text();
-        throw new Error(`googleDrive: resumable init failed (${initRes.status}): ${t}`);
+        throw new Error(`googleDrive: resumable init failed (HTTP ${initRes.status})`);
     }
-    const uploadUrl = initRes.headers.get("location");
-    if (!uploadUrl)
-        throw new Error("googleDrive: resumable session missing Location header");
+    const uploadUrl = uploadSession(initRes.headers.get("location"));
     // Stream in 2 MiB chunks. Must be a multiple of 256 KiB per Drive docs.
     const CHUNK_SIZE = 2 * 1024 * 1024;
     const stream = createReadStream(c.path, { highWaterMark: CHUNK_SIZE });
@@ -294,10 +264,9 @@ async function uploadBytes(ctx, metadata, c, extraQs = {}) {
     const flushChunk = async (chunk, isLast) => {
         const start = offset;
         const end = offset + chunk.byteLength - 1;
-        const res = await fetch(uploadUrl, {
+        const res = await driveResponse(ctx, uploadUrl, {
             method: "PUT",
             headers: {
-                "Content-Length": String(chunk.byteLength),
                 "Content-Range": `bytes ${start}-${end}/${c.size}`,
             },
             body: new Uint8Array(chunk),
@@ -313,8 +282,7 @@ async function uploadBytes(ctx, metadata, c, extraQs = {}) {
             await res.text();
         }
         else {
-            const t = await res.text();
-            throw new Error(`googleDrive: resumable chunk failed (${res.status}): ${t}`);
+            throw new Error(`googleDrive: resumable chunk failed (HTTP ${res.status})`);
         }
         void isLast;
     };
@@ -418,6 +386,7 @@ export default function googleDrive(rl) {
         ],
     });
     rl.setConnectionSchema({
+        authMethod: { type: "string", required: false, description: "delegated or serviceAccount (legacy configs infer the method)" },
         clientId: {
             type: "string",
             required: false,
@@ -554,11 +523,9 @@ export default function googleDrive(rl) {
                 const doc = (await driveRequest(ctx, "POST", "/drive/v3/files", metadata, {
                     supportsAllDrives: true,
                 }));
-                const token = await accessToken(ctx);
-                const res = await fetch(`https://docs.googleapis.com/v1/documents/${doc.id}:batchUpdate`, {
+                const res = await driveResponse(ctx, `https://docs.googleapis.com/v1/documents/${encodeURIComponent(doc.id)}:batchUpdate`, {
                     method: "POST",
                     headers: {
-                        Authorization: `Bearer ${token}`,
                         "Content-Type": "application/json",
                     },
                     body: JSON.stringify({
@@ -573,7 +540,7 @@ export default function googleDrive(rl) {
                     }),
                 });
                 if (!res.ok) {
-                    throw new Error(`googleDrive: docs.batchUpdate failed (${res.status}): ${await res.text()}`);
+                    throw new Error(`googleDrive: docs.batchUpdate failed (HTTP ${res.status})`);
                 }
                 return { id: doc.id };
             }
@@ -608,7 +575,6 @@ export default function googleDrive(rl) {
             const fileId = p.fileId;
             const meta = (await driveRequest(ctx, "GET", `/drive/v3/files/${fileId}`, undefined, { fields: "mimeType,name", supportsAllDrives: true }));
             const isGoogleNative = meta.mimeType?.includes("vnd.google-apps");
-            const token = await accessToken(ctx);
             let url;
             let contentType = meta.mimeType;
             if (isGoogleNative) {
@@ -621,22 +587,20 @@ export default function googleDrive(rl) {
                 };
                 const mime = p.googleDocFormat ?? defaults[type] ?? "application/pdf";
                 contentType = mime;
-                const u = new URL(`${API_BASE}/drive/v3/files/${fileId}/export`);
+                const u = new URL(`${API_BASE}/drive/v3/files/${filePathId(fileId)}/export`);
                 u.searchParams.set("mimeType", mime);
                 u.searchParams.set("supportsAllDrives", "true");
                 url = u.toString();
             }
             else {
-                const u = new URL(`${API_BASE}/drive/v3/files/${fileId}`);
+                const u = new URL(`${API_BASE}/drive/v3/files/${filePathId(fileId)}`);
                 u.searchParams.set("alt", "media");
                 u.searchParams.set("supportsAllDrives", "true");
                 url = u.toString();
             }
-            const res = await fetch(url, {
-                headers: { Authorization: `Bearer ${token}` },
-            });
+            const res = await driveResponse(ctx, url);
             if (!res.ok) {
-                throw new Error(`googleDrive: download failed (${res.status}): ${await res.text()}`);
+                throw new Error(`googleDrive: download failed (HTTP ${res.status})`);
             }
             const bytes = Buffer.from(await res.arrayBuffer());
             const fileName = meta.name;
@@ -754,9 +718,8 @@ export default function googleDrive(rl) {
             if (hasBytes) {
                 const c = resolveContent(p);
                 const mimeType = c.mimeType ?? p.mimeType ?? "application/octet-stream";
-                const token = await accessToken(ctx);
                 if (c.buffer) {
-                    const url = new URL(`${API_BASE}/upload/drive/v3/files/${fileId}`);
+                    const url = new URL(`${API_BASE}/upload/drive/v3/files/${filePathId(fileId)}`);
                     url.searchParams.set("uploadType", "media");
                     url.searchParams.set("supportsAllDrives", "true");
                     for (const key of [
@@ -768,22 +731,20 @@ export default function googleDrive(rl) {
                             url.searchParams.set(key, String(p[key]));
                         }
                     }
-                    const res = await fetch(url.toString(), {
+                    const res = await driveResponse(ctx, url.toString(), {
                         method: "PATCH",
                         headers: {
-                            Authorization: `Bearer ${token}`,
                             "Content-Type": mimeType,
-                            "Content-Length": String(c.buffer.byteLength),
                         },
                         body: new Uint8Array(c.buffer),
                     });
                     if (!res.ok) {
-                        throw new Error(`googleDrive: content update failed (${res.status}): ${await res.text()}`);
+                        throw new Error(`googleDrive: content update failed (HTTP ${res.status})`);
                     }
                 }
                 else if (c.path) {
                     // Resumable PATCH
-                    const initUrl = new URL(`${API_BASE}/upload/drive/v3/files/${fileId}`);
+                    const initUrl = new URL(`${API_BASE}/upload/drive/v3/files/${filePathId(fileId)}`);
                     initUrl.searchParams.set("uploadType", "resumable");
                     initUrl.searchParams.set("supportsAllDrives", "true");
                     for (const key of [
@@ -795,36 +756,34 @@ export default function googleDrive(rl) {
                             initUrl.searchParams.set(key, String(p[key]));
                         }
                     }
-                    const initRes = await fetch(initUrl.toString(), {
+                    const initRes = await driveResponse(ctx, initUrl.toString(), {
                         method: "PATCH",
                         headers: {
-                            Authorization: `Bearer ${token}`,
                             "X-Upload-Content-Type": mimeType,
                             "X-Upload-Content-Length": String(c.size),
                         },
                     });
                     if (!initRes.ok) {
-                        throw new Error(`googleDrive: resumable update init failed (${initRes.status}): ${await initRes.text()}`);
+                        throw new Error(`googleDrive: resumable update init failed (HTTP ${initRes.status})`);
                     }
-                    const uploadUrl = initRes.headers.get("location");
-                    if (!uploadUrl)
-                        throw new Error("googleDrive: missing Location on resumable init");
+                    const uploadUrl = uploadSession(initRes.headers.get("location"));
                     const CHUNK = 2 * 1024 * 1024;
                     const stream = createReadStream(c.path, { highWaterMark: CHUNK });
                     let offset = 0;
                     let pending = Buffer.alloc(0);
+                    let lastStatus = 0;
                     const flush = async (chunk) => {
-                        const res = await fetch(uploadUrl, {
+                        const res = await driveResponse(ctx, uploadUrl, {
                             method: "PUT",
                             headers: {
-                                "Content-Length": String(chunk.byteLength),
                                 "Content-Range": `bytes ${offset}-${offset + chunk.byteLength - 1}/${c.size}`,
                             },
                             body: new Uint8Array(chunk),
                         });
                         offset += chunk.byteLength;
+                        lastStatus = res.status;
                         if (res.status !== 200 && res.status !== 201 && res.status !== 308) {
-                            throw new Error(`googleDrive: resumable chunk failed (${res.status}): ${await res.text()}`);
+                            throw new Error(`googleDrive: resumable chunk failed (HTTP ${res.status})`);
                         }
                         await res.text();
                     };
@@ -837,6 +796,8 @@ export default function googleDrive(rl) {
                     }
                     if (pending.byteLength > 0)
                         await flush(pending);
+                    if (offset !== c.size || (lastStatus !== 200 && lastStatus !== 201))
+                        throw new Error("googleDrive: resumable update did not complete");
                 }
             }
             // Step 2: metadata patch
@@ -1484,14 +1445,11 @@ export default function googleDrive(rl) {
             const p = (input ?? {});
             const fileId = p.fileId;
             const revisionId = p.revisionId;
-            const token = await accessToken(ctx);
-            const url = new URL(`${API_BASE}/drive/v3/files/${fileId}/revisions/${revisionId}`);
+            const url = new URL(`${API_BASE}/drive/v3/files/${filePathId(fileId)}/revisions/${filePathId(revisionId)}`);
             url.searchParams.set("alt", "media");
-            const res = await fetch(url.toString(), {
-                headers: { Authorization: `Bearer ${token}` },
-            });
+            const res = await driveResponse(ctx, url.toString());
             if (!res.ok) {
-                throw new Error(`googleDrive: revision download failed (${res.status}): ${await res.text()}`);
+                throw new Error(`googleDrive: revision download failed (HTTP ${res.status})`);
             }
             const bytes = Buffer.from(await res.arrayBuffer());
             const mimeType = res.headers.get("content-type") ?? "application/octet-stream";
@@ -1563,33 +1521,30 @@ export default function googleDrive(rl) {
             const p = (input ?? {});
             const fileId = p.fileId;
             const revisionId = p.revisionId;
-            const token = await accessToken(ctx);
             // 1. Pull the chosen revision's bytes.
-            const dl = await fetch(`${API_BASE}/drive/v3/files/${fileId}/revisions/${revisionId}?alt=media`, { headers: { Authorization: `Bearer ${token}` } });
+            const dl = await driveResponse(ctx, `${API_BASE}/drive/v3/files/${encodeURIComponent(fileId)}/revisions/${encodeURIComponent(revisionId)}?alt=media`);
             if (!dl.ok) {
-                throw new Error(`googleDrive: revision restore download failed (${dl.status}): ${await dl.text()}`);
+                throw new Error(`googleDrive: revision restore download failed (HTTP ${dl.status})`);
             }
             const bytes = Buffer.from(await dl.arrayBuffer());
             const mime = p.mimeType ??
                 dl.headers.get("content-type") ??
                 "application/octet-stream";
             // 2. Multipart-PATCH them as the new head of the same file.
-            const url = new URL(`${API_BASE}/upload/drive/v3/files/${fileId}`);
+            const url = new URL(`${API_BASE}/upload/drive/v3/files/${filePathId(fileId)}`);
             url.searchParams.set("uploadType", "multipart");
             url.searchParams.set("supportsAllDrives", "true");
             url.searchParams.set("fields", "id,name,mimeType,modifiedTime,size,headRevisionId,webViewLink");
             const body = buildMultipart({ mimeType: mime }, bytes, mime);
-            const res = await fetch(url.toString(), {
+            const res = await driveResponse(ctx, url.toString(), {
                 method: "PATCH",
                 headers: {
-                    Authorization: `Bearer ${token}`,
                     "Content-Type": `multipart/related; boundary=${MULTIPART_BOUNDARY}`,
-                    "Content-Length": String(body.byteLength),
                 },
                 body: new Uint8Array(body),
             });
             if (!res.ok) {
-                throw new Error(`googleDrive: revision restore upload failed (${res.status}): ${await res.text()}`);
+                throw new Error(`googleDrive: revision restore upload failed (HTTP ${res.status})`);
             }
             const head = (await res.json());
             return { fileId, restoredFromRevisionId: revisionId, head };
@@ -1816,12 +1771,11 @@ export default function googleDrive(rl) {
         }, { additionalProperties: false }),
         async execute(input, ctx) {
             const p = (input ?? {});
-            const token = await accessToken(ctx);
-            const u = new URL(`${API_BASE}/drive/v3/files/${p.fileId}/export`);
+            const u = new URL(`${API_BASE}/drive/v3/files/${filePathId(String(p.fileId))}/export`);
             u.searchParams.set("mimeType", p.mimeType);
-            const res = await fetch(u.toString(), { headers: { Authorization: `Bearer ${token}` } });
+            const res = await driveResponse(ctx, u.toString());
             if (!res.ok) {
-                throw new Error(`googleDrive: export failed (${res.status}): ${await res.text()}`);
+                throw new Error(`googleDrive: export failed (HTTP ${res.status})`);
             }
             const bytes = Buffer.from(await res.arrayBuffer());
             const contentType = res.headers.get("content-type") ?? p.mimeType;

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

@@ -35,7 +35,7 @@
  * raw rows / objects and callers post-filter.
  */
 import * as t from "typebox";
-import { googleAccessToken } from "../../_shared/googleAuth.js";
+import { googleJsonRequest } from "../../_shared/googleAuth.js";
 import { Id, JsonValue, NonEmptyString, NonNegativeInteger, PositiveInteger, RawGoogleObject, StringArray, stringEnum, } from "../../_shared/googleSchemas.js";
 const ROW_NUMBER = "row_number";
 const sheetReferenceSchema = t.Union([NonEmptyString, NonNegativeInteger]);
@@ -73,48 +73,10 @@ const initialSheetSchema = t.Object({
         columnGroupControlAfter: t.Optional(t.Boolean()),
     }, { additionalProperties: false })),
 }, { additionalProperties: false });
-// ─── Auth ────────────────────────────────────────────────────────
-async function accessToken(ctx) {
-    return googleAccessToken(ctx, "googleSheets", SCOPES);
-}
 // ─── Request ─────────────────────────────────────────────────────
 const SHEETS_BASE = "https://sheets.googleapis.com";
 async function sheetsRequest(ctx, method, path, body, qs, baseOverride) {
-    const token = await accessToken(ctx);
-    const url = new URL(`${baseOverride ?? SHEETS_BASE}${path}`);
-    if (qs) {
-        for (const [k, v] of Object.entries(qs)) {
-            if (v === undefined || v === null)
-                continue;
-            if (Array.isArray(v)) {
-                for (const entry of v)
-                    url.searchParams.append(k, String(entry));
-            }
-            else {
-                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(`googleSheets: ${method} ${path} → ${res.status} ${text}`);
-    }
-    return text ? JSON.parse(text) : { success: true };
+    return googleJsonRequest(ctx, "googleSheets", SCOPES, method, `${baseOverride ?? SHEETS_BASE}${path}`, body, qs);
 }
 // ─── A1 helpers ─────────────────────────────────────────────────
 /**
@@ -411,6 +373,7 @@ export default function googleSheets(rl) {
         ],
     });
     rl.setConnectionSchema({
+        authMethod: { type: "string", required: false, description: "delegated or serviceAccount (legacy configs infer the method)" },
         clientId: {
             type: "string",
             required: false,

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

@@ -21,47 +21,12 @@
  */
 import { writeFileSync } from "node:fs";
 import * as t from "typebox";
-import { googleAccessToken } from "../../_shared/googleAuth.js";
+import { googleJsonRequest, googleDownload } from "../../_shared/googleAuth.js";
 import { Id, NonEmptyString, PositiveInteger, RawGoogleObject, StringArray, stringEnum, } from "../../_shared/googleSchemas.js";
-// ─── Auth ────────────────────────────────────────────────────────
-async function accessToken(ctx) {
-    return googleAccessToken(ctx, "googleSlides", SCOPES);
-}
 // ─── Request ─────────────────────────────────────────────────────
 const API_BASE = "https://slides.googleapis.com/v1";
 async function slidesRequest(ctx, method, path, body, qs) {
-    const token = await accessToken(ctx);
-    const url = new URL(`${API_BASE}${path}`);
-    if (qs) {
-        for (const [k, v] of Object.entries(qs)) {
-            if (v === undefined || v === null)
-                continue;
-            if (Array.isArray(v)) {
-                for (const entry of v)
-                    url.searchParams.append(k, String(entry));
-            }
-            else {
-                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(`googleSlides: ${method} ${path} → ${res.status} ${text}`);
-    }
-    return text ? JSON.parse(text) : { success: true };
+    return googleJsonRequest(ctx, "googleSlides", SCOPES, method, `${API_BASE}${path}`, body, qs);
 }
 // ─── Helpers ────────────────────────────────────────────────────
 const PRES_URL_REGEX = /https:\/\/docs\.google\.com\/presentation\/d\/([a-zA-Z0-9-_]+)/;
@@ -112,6 +77,7 @@ export default function googleSlides(rl) {
         ],
     });
     rl.setConnectionSchema({
+        authMethod: { type: "string", required: false, description: "delegated or serviceAccount (legacy configs infer the method)" },
         clientId: {
             type: "string",
             required: false,
@@ -289,9 +255,9 @@ export default function googleSlides(rl) {
             if (!p.savePath && !p.download)
                 return res;
             // contentUrl is a signed Google URL — fetch without auth headers.
-            const imgRes = await fetch(res.contentUrl);
+            const imgRes = await googleDownload(res.contentUrl);
             if (!imgRes.ok) {
-                throw new Error(`googleSlides: thumbnail fetch failed (${imgRes.status}): ${await imgRes.text()}`);
+                throw new Error(`googleSlides: thumbnail fetch failed (HTTP ${imgRes.status})`);
             }
             const bytes = Buffer.from(await imgRes.arrayBuffer());
             if (typeof p.savePath === "string") {

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

@@ -20,40 +20,12 @@
  * normalize ISO input via `Date.toISOString()` when detected.
  */
 import * as t from "typebox";
-import { googleAccessToken } from "../../_shared/googleAuth.js";
+import { googleJsonRequest } from "../../_shared/googleAuth.js";
 import { GoogleTimestamp, Id, stringEnum, } from "../../_shared/googleSchemas.js";
-// ─── Auth ────────────────────────────────────────────────────────
-async function accessToken(ctx) {
-    return googleAccessToken(ctx, "googleTasks", SCOPES);
-}
 // ─── Request ─────────────────────────────────────────────────────
 const API_BASE = "https://tasks.googleapis.com/tasks/v1";
 async function tasksRequest(ctx, method, path, body, qs) {
-    const token = await accessToken(ctx);
-    const url = new URL(`${API_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(`googleTasks: ${method} ${path} → ${res.status} ${text}`);
-    }
-    return text ? JSON.parse(text) : { success: true };
+    return googleJsonRequest(ctx, "googleTasks", SCOPES, method, `${API_BASE}${path}`, body, qs);
 }
 async function paginateAll(ctx, path, qs) {
     const out = [];
@@ -129,6 +101,7 @@ export default function googleTasks(rl) {
         ],
     });
     rl.setConnectionSchema({
+        authMethod: { type: "string", required: false, description: "delegated or serviceAccount (legacy configs infer the method)" },
         clientId: { type: "string", required: false, env: "GOOGLE_TASKS_CLIENT_ID" },
         clientSecret: { type: "string", required: false, env: "GOOGLE_TASKS_CLIENT_SECRET" },
         refreshToken: { type: "string", required: false, env: "GOOGLE_TASKS_REFRESH_TOKEN" },

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

@@ -1,28 +1,4 @@
-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;
-}
+import { coordinatedAccessToken, requestToken, } from "../../_shared/tokenRefresh.js";
 async function apiRequest(apiUrl, token, method, endpoint, body, qs) {
     const url = new URL(`${apiUrl}${endpoint}`);
     if (qs) {
@@ -51,12 +27,21 @@ async function apiRequest(apiUrl, token, method, endpoint, body, qs) {
     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);
+    const token = await coordinatedAccessToken(ctx, (cfg) => {
+        const url = new URL(cfg.hostingType === "on-premise"
+            ? `${cfg.appUrl}/auth/token`
+            : `${cfg.authUrl}/token`);
+        if (cfg.tenant)
+            url.searchParams.set("tenant", cfg.tenant);
+        return requestToken({ url: url.toString(), clientAuthentication: "client_secret_post" }, {
+            grant_type: "client_credentials",
+            scope: cfg.scope ?? "all",
+        }, {
+            clientId: cfg.clientId,
+            clientSecret: cfg.clientSecret,
+        });
+    });
+    return apiRequest(ctx.connection.config.resourceApiUrl.replace(/\/$/, ""), token, method, endpoint, body, qs);
 }
 function registerCrud(rl, resource, apiPath) {
     rl.registerAction(`${resource}.create`, {

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

@@ -1,9 +1,9 @@
 import * as t from "typebox";
 import { assertCommentInScope, assertIssueInScope, COMMENT_FIELDS, gql, key, requireUnscoped, } from "./shared.js";
 export function registerCommentActions(rl) {
-    rl.registerAction("issue.addComment", {
+    rl.registerAction("comment.create", {
         access: "write",
-        description: "Add a comment to an issue. Pass parentId to nest as a reply.",
+        description: "Create a comment on 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')",

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

@@ -14,7 +14,7 @@ import { registerViewActions } from "./views.js";
 import { registerWebhookActions } from "./webhooks.js";
 export default function linear(rl) {
     rl.setName("linear");
-    rl.setVersion("0.4.0");
+    rl.setVersion("0.5.0");
     rl.setConnectionSchema(t.Object({
         apiKey: t.String({
             description: "Linear API key (https://linear.app/settings/account/security)",