runline 0.33.0 → 0.35.0

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

@@ -1,30 +1,18 @@
-const BASE = "https://api.phantombuster.com/api/v2";
-async function apiRequest(apiKey, method, path, body, qs) {
-    const url = new URL(`${BASE}${path}`);
-    if (qs) {
-        for (const [k, v] of Object.entries(qs)) {
-            if (v !== undefined && v !== null)
-                url.searchParams.set(k, String(v));
-        }
-    }
-    const init = {
+import { credentialJson } from "../../_shared/credentials.js";
+import { phantombusterCredential } from "./credentials.js";
+function api(ctx, method, path, body, qs) {
+    return credentialJson(ctx, phantombusterCredential, "phantombuster", {
+        target: "api",
+        path,
         method,
-        headers: {
-            "X-Phantombuster-Key": apiKey,
-            "Content-Type": "application/json",
-        },
-    };
-    if (body && Object.keys(body).length > 0)
-        init.body = JSON.stringify(body);
-    const res = await fetch(url.toString(), init);
-    if (!res.ok)
-        throw new Error(`Phantombuster error ${res.status}: ${await res.text()}`);
-    const text = await res.text();
-    return text ? JSON.parse(text) : {};
+        query: qs,
+        ...(body && Object.keys(body).length > 0 ? { json: body } : {}),
+    });
 }
 export default function phantombuster(rl) {
     rl.setName("phantombuster");
     rl.setVersion("0.1.0");
+    rl.setCredential(phantombusterCredential);
     rl.setConnectionSchema({
         apiKey: {
             type: "string",
@@ -33,14 +21,13 @@ export default function phantombuster(rl) {
             env: "PHANTOMBUSTER_API_KEY",
         },
     });
-    const key = (ctx) => ctx.connection.config.apiKey;
     rl.registerAction("agent.delete", {
         access: "write",
         description: "Delete an agent",
         inputSchema: { agentId: { type: "string", required: true } },
         async execute(input, ctx) {
             const { agentId } = input;
-            await apiRequest(key(ctx), "POST", "/agents/delete", { id: agentId });
+            await api(ctx, "POST", "agents/delete", { id: agentId });
             return { success: true };
         },
     });
@@ -50,9 +37,7 @@ export default function phantombuster(rl) {
         inputSchema: { agentId: { type: "string", required: true } },
         async execute(input, ctx) {
             const { agentId } = input;
-            return apiRequest(key(ctx), "GET", "/agents/fetch", undefined, {
-                id: agentId,
-            });
+            return api(ctx, "GET", "agents/fetch", undefined, { id: agentId });
         },
     });
     rl.registerAction("agent.getOutput", {
@@ -68,9 +53,11 @@ export default function phantombuster(rl) {
         },
         async execute(input, ctx) {
             const p = input;
-            const data = (await apiRequest(key(ctx), "GET", "/agents/fetch-output", undefined, { id: p.agentId }));
+            const data = (await api(ctx, "GET", "agents/fetch-output", undefined, {
+                id: p.agentId,
+            }));
             if (p.resolveData) {
-                const result = (await apiRequest(key(ctx), "GET", "/containers/fetch-result-object", undefined, { id: data.containerId }));
+                const result = (await api(ctx, "GET", "containers/fetch-result-object", undefined, { id: data.containerId }));
                 if (!result.resultObject)
                     return {};
                 return JSON.parse(result.resultObject);
@@ -83,7 +70,7 @@ export default function phantombuster(rl) {
         description: "List all agents",
         inputSchema: { limit: { type: "number", required: false } },
         async execute(input, ctx) {
-            const agents = (await apiRequest(key(ctx), "GET", "/agents/fetch-all"));
+            const agents = (await api(ctx, "GET", "agents/fetch-all"));
             const limit = input?.limit;
             if (limit)
                 return agents.slice(0, limit);
@@ -118,9 +105,9 @@ export default function phantombuster(rl) {
                 body.arguments = p.arguments;
             if (p.bonusArgument)
                 body.bonusArgument = p.bonusArgument;
-            const data = (await apiRequest(key(ctx), "POST", "/agents/launch", body));
+            const data = (await api(ctx, "POST", "agents/launch", body));
             if (p.resolveData) {
-                return apiRequest(key(ctx), "GET", "/containers/fetch", undefined, {
+                return api(ctx, "GET", "containers/fetch", undefined, {
                     id: data.containerId,
                 });
             }

package/dist/plugins/philipsHue/src/credentials.js

@@ -0,0 +1,17 @@
+import { staticCredential } from "../../_shared/credentials.js";
+/**
+ * An OAuth2 access token, sent as a bearer to the Hue remote API. The
+ * bridge username is public config and rides in the request path beneath
+ * the target, never in the declaration.
+ */
+export const philipsHueCredential = staticCredential({
+    id: "philipsHue",
+    auth: { kind: "bearer" },
+    local: { secret: "accessToken" },
+    targets: {
+        api: {
+            baseUrl: "https://api.meethue.com/route/",
+            methods: ["GET", "PUT", "DELETE"],
+        },
+    },
+});

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

@@ -1,22 +1,17 @@
-const BASE = "https://api.meethue.com/route";
-async function apiRequest(accessToken, method, path, body) {
-    const init = {
+import { credentialJson, pathSegment } from "../../_shared/credentials.js";
+import { philipsHueCredential } from "./credentials.js";
+function apiRequest(ctx, method, path, body) {
+    return credentialJson(ctx, philipsHueCredential, "philipsHue", {
+        target: "api",
+        path,
         method,
-        headers: {
-            Authorization: `Bearer ${accessToken}`,
-            "Content-Type": "application/json",
-        },
-    };
-    if (body && Object.keys(body).length > 0)
-        init.body = JSON.stringify(body);
-    const res = await fetch(`${BASE}${path}`, init);
-    if (!res.ok)
-        throw new Error(`Philips Hue error ${res.status}: ${await res.text()}`);
-    return res.json();
+        ...(body && Object.keys(body).length > 0 ? { json: body } : {}),
+    });
 }
 export default function philipsHue(rl) {
     rl.setName("philipsHue");
     rl.setVersion("0.1.0");
+    rl.setCredential(philipsHueCredential);
     rl.setConnectionSchema({
         accessToken: {
             type: "string",
@@ -31,11 +26,8 @@ export default function philipsHue(rl) {
             env: "PHILIPS_HUE_USERNAME",
         },
     });
-    function conn(ctx) {
-        return {
-            token: ctx.connection.config.accessToken,
-            user: ctx.connection.config.username,
-        };
+    function user(ctx) {
+        return pathSegment(ctx.connection.config.username);
     }
     rl.registerAction("light.get", {
         access: "read",
@@ -43,8 +35,7 @@ export default function philipsHue(rl) {
         inputSchema: { lightId: { type: "string", required: true } },
         async execute(input, ctx) {
             const { lightId } = input;
-            const c = conn(ctx);
-            return apiRequest(c.token, "GET", `/api/${c.user}/lights/${lightId}`);
+            return apiRequest(ctx, "GET", `api/${user(ctx)}/lights/${pathSegment(lightId)}`);
         },
     });
     rl.registerAction("light.list", {
@@ -52,8 +43,7 @@ export default function philipsHue(rl) {
         description: "List all lights",
         inputSchema: { limit: { type: "number", required: false } },
         async execute(input, ctx) {
-            const c = conn(ctx);
-            const data = (await apiRequest(c.token, "GET", `/api/${c.user}/lights`));
+            const data = (await apiRequest(ctx, "GET", `api/${user(ctx)}/lights`));
             const lights = Object.entries(data).map(([id, v]) => ({
                 id,
                 ...v,
@@ -113,7 +103,6 @@ export default function philipsHue(rl) {
         },
         async execute(input, ctx) {
             const p = input;
-            const c = conn(ctx);
             const body = { on: p.on };
             if (p.bri !== undefined)
                 body.bri = p.bri;
@@ -131,7 +120,7 @@ export default function philipsHue(rl) {
                 body.alert = p.alert;
             if (p.effect)
                 body.effect = p.effect;
-            const data = (await apiRequest(c.token, "PUT", `/api/${c.user}/lights/${p.lightId}/state`, body));
+            const data = (await apiRequest(ctx, "PUT", `api/${user(ctx)}/lights/${pathSegment(p.lightId)}/state`, body));
             const result = {};
             for (const item of data) {
                 if (item.success)
@@ -146,8 +135,7 @@ export default function philipsHue(rl) {
         inputSchema: { lightId: { type: "string", required: true } },
         async execute(input, ctx) {
             const { lightId } = input;
-            const c = conn(ctx);
-            return apiRequest(c.token, "DELETE", `/api/${c.user}/lights/${lightId}`);
+            return apiRequest(ctx, "DELETE", `api/${user(ctx)}/lights/${pathSegment(lightId)}`);
         },
     });
 }

package/dist/plugins/pipedrive/src/credentials.js

@@ -0,0 +1,26 @@
+import { staticCredential } from "../../_shared/credentials.js";
+/**
+ * An API token, appended by the transport as the api_token query parameter
+ * on Pipedrive's v2 and v1 API bases.
+ */
+export const pipedriveCredential = staticCredential({
+    id: "pipedrive",
+    auth: { kind: "queryKey", param: "api_token" },
+    local: { secret: "apiToken" },
+    targets: {
+        v2: {
+            baseUrl: "https://api.pipedrive.com/api/v2/",
+            methods: ["GET", "POST", "PATCH", "DELETE"],
+        },
+        v1: {
+            baseUrl: "https://api.pipedrive.com/v1/",
+            methods: ["GET", "PUT", "DELETE"],
+        },
+    },
+    probe: {
+        target: "v1",
+        path: "users/me",
+        method: "GET",
+        acceptedStatuses: [200],
+    },
+});

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

@@ -1,51 +1,32 @@
-const V2 = "https://api.pipedrive.com/api/v2";
-const V1 = "https://api.pipedrive.com/v1";
-function getConn(ctx) {
-    return ctx.connection.config.apiToken;
-}
-async function api(token, method, endpoint, body, qs, version = "v2") {
-    const base = version === "v1" ? V1 : V2;
-    const url = new URL(`${base}${endpoint}`);
-    url.searchParams.set("api_token", token);
-    if (qs) {
-        for (const [k, v] of Object.entries(qs)) {
-            if (v !== undefined && v !== null)
-                url.searchParams.set(k, String(v));
-        }
-    }
-    const init = {
+import { answerFailed, credentialJson, pathSegment, } from "../../_shared/credentials.js";
+import { pipedriveCredential } from "./credentials.js";
+async function api(ctx, method, path, body, qs, version = "v2") {
+    const json = (await credentialJson(ctx, pipedriveCredential, "pipedrive", {
+        target: version,
+        path,
         method,
-        headers: { Accept: "application/json", "Content-Type": "application/json" },
-    };
-    if (body && Object.keys(body).length > 0)
-        init.body = JSON.stringify(body);
-    const res = await fetch(url.toString(), init);
-    if (!res.ok)
-        throw new Error(`Pipedrive error ${res.status}: ${await res.text()}`);
-    const json = (await res.json());
+        query: qs,
+        ...(body && Object.keys(body).length > 0 ? { json: body } : {}),
+    }));
     if (json.success === false)
-        throw new Error(`Pipedrive: ${JSON.stringify(json)}`);
+        throw answerFailed("pipedrive", {
+            code: json.errorCode,
+            message: json.error,
+        });
     return json.data ?? json;
 }
-async function paginate(token, endpoint, qs = {}) {
+async function paginate(ctx, path, qs = {}) {
     const results = [];
     qs.limit = 500;
     let cursor;
     do {
         if (cursor)
             qs.cursor = cursor;
-        const url = new URL(`${V2}${endpoint}`);
-        url.searchParams.set("api_token", token);
-        for (const [k, v] of Object.entries(qs)) {
-            if (v !== undefined && v !== null)
-                url.searchParams.set(k, String(v));
-        }
-        const res = await fetch(url.toString(), {
-            headers: { Accept: "application/json" },
-        });
-        if (!res.ok)
-            throw new Error(`Pipedrive error ${res.status}: ${await res.text()}`);
-        const json = (await res.json());
+        const json = (await credentialJson(ctx, pipedriveCredential, "pipedrive", {
+            target: "v2",
+            path,
+            query: qs,
+        }));
         const data = json.data;
         if (Array.isArray(data))
             results.push(...data);
@@ -57,8 +38,7 @@ async function paginate(token, endpoint, qs = {}) {
     return results;
 }
 function registerCrud(rl, resource, endpoint, opts) {
-    const cap = resource.charAt(0).toUpperCase() + resource.slice(1);
-    const updateMethod = opts?.updateMethod ?? "PATCH";
+    const updateMethod = (opts?.updateMethod ?? "PATCH");
     rl.registerAction(`${resource}.create`, {
         access: "write",
         description: `Create a ${resource}`,
@@ -71,8 +51,7 @@ function registerCrud(rl, resource, endpoint, opts) {
             ...(opts?.extraCreate ?? {}),
         },
         async execute(input, ctx) {
-            const t = getConn(ctx);
-            return api(t, "POST", endpoint, input.data);
+            return api(ctx, "POST", endpoint, input.data);
         },
     });
     rl.registerAction(`${resource}.get`, {
@@ -80,8 +59,7 @@ function registerCrud(rl, resource, endpoint, opts) {
         description: `Get a ${resource}`,
         inputSchema: { id: { type: "number", required: true } },
         async execute(input, ctx) {
-            const t = getConn(ctx);
-            return api(t, "GET", `${endpoint}/${input.id}`);
+            return api(ctx, "GET", `${endpoint}/${pathSegment(input.id)}`);
         },
     });
     rl.registerAction(`${resource}.list`, {
@@ -92,16 +70,15 @@ function registerCrud(rl, resource, endpoint, opts) {
             filterId: { type: "number", required: false },
         },
         async execute(input, ctx) {
-            const t = getConn(ctx);
             const p = (input ?? {});
             const qs = {};
             if (p.filterId)
                 qs.filter_id = p.filterId;
             if (p.limit) {
                 qs.limit = p.limit;
-                return api(t, "GET", endpoint, undefined, qs);
+                return api(ctx, "GET", endpoint, undefined, qs);
             }
-            return paginate(t, endpoint, qs);
+            return paginate(ctx, endpoint, qs);
         },
     });
     rl.registerAction(`${resource}.update`, {
@@ -113,9 +90,8 @@ function registerCrud(rl, resource, endpoint, opts) {
             ...(opts?.extraUpdate ?? {}),
         },
         async execute(input, ctx) {
-            const t = getConn(ctx);
             const p = input;
-            return api(t, updateMethod, `${endpoint}/${p.id}`, p.data);
+            return api(ctx, updateMethod, `${endpoint}/${pathSegment(p.id)}`, p.data);
         },
     });
     rl.registerAction(`${resource}.delete`, {
@@ -123,8 +99,7 @@ function registerCrud(rl, resource, endpoint, opts) {
         description: `Delete a ${resource}`,
         inputSchema: { id: { type: "number", required: true } },
         async execute(input, ctx) {
-            const t = getConn(ctx);
-            await api(t, "DELETE", `${endpoint}/${input.id}`);
+            await api(ctx, "DELETE", `${endpoint}/${pathSegment(input.id)}`);
             return { success: true };
         },
     });
@@ -143,7 +118,6 @@ function registerCrud(rl, resource, endpoint, opts) {
                 },
             },
             async execute(input, ctx) {
-                const t = getConn(ctx);
                 const p = input;
                 const qs = { term: p.term };
                 if (p.exactMatch)
@@ -153,7 +127,7 @@ function registerCrud(rl, resource, endpoint, opts) {
                 if (p.fields)
                     qs.fields = p.fields;
                 // Search uses v1 API
-                const res = (await api(t, "GET", `${endpoint}/search`, undefined, qs, "v1"));
+                const res = (await api(ctx, "GET", `${endpoint}/search`, undefined, qs, "v1"));
                 if (Array.isArray(res))
                     return res.map((r) => r.item ?? r);
                 return res;
@@ -166,8 +140,7 @@ function registerCrud(rl, resource, endpoint, opts) {
             description: `Duplicate a ${resource}`,
             inputSchema: { id: { type: "number", required: true } },
             async execute(input, ctx) {
-                const t = getConn(ctx);
-                return api(t, "POST", `${endpoint}/${input.id}/duplicate`);
+                return api(ctx, "POST", `${endpoint}/${pathSegment(input.id)}/duplicate`);
             },
         });
     }
@@ -175,6 +148,7 @@ function registerCrud(rl, resource, endpoint, opts) {
 export default function pipedrive(rl) {
     rl.setName("pipedrive");
     rl.setVersion("0.1.0");
+    rl.setCredential(pipedriveCredential);
     rl.setConnectionSchema({
         apiToken: {
             type: "string",
@@ -184,9 +158,9 @@ export default function pipedrive(rl) {
         },
     });
     // ── Activity ────────────────────────────────────────
-    registerCrud(rl, "activity", "/activities");
+    registerCrud(rl, "activity", "activities");
     // ── Deal ────────────────────────────────────────────
-    registerCrud(rl, "deal", "/deals", { hasSearch: true, hasDuplicate: true });
+    registerCrud(rl, "deal", "deals", { hasSearch: true, hasDuplicate: true });
     // ── Deal Product ────────────────────────────────────
     rl.registerAction("dealProduct.add", {
         access: "write",
@@ -205,9 +179,8 @@ export default function pipedrive(rl) {
             comments: { type: "string", required: false },
         },
         async execute(input, ctx) {
-            const t = getConn(ctx);
             const { dealId, ...body } = input;
-            return api(t, "POST", `/deals/${dealId}/products`, {
+            return api(ctx, "POST", `deals/${pathSegment(dealId)}/products`, {
                 product_id: body.productId,
                 item_price: body.itemPrice,
                 quantity: body.quantity,
@@ -225,12 +198,11 @@ export default function pipedrive(rl) {
             limit: { type: "number", required: false },
         },
         async execute(input, ctx) {
-            const t = getConn(ctx);
             const p = input;
             const qs = {};
             if (p.limit)
                 qs.limit = p.limit;
-            return api(t, "GET", `/deals/${p.dealId}/products`, undefined, qs);
+            return api(ctx, "GET", `deals/${pathSegment(p.dealId)}/products`, undefined, qs);
         },
     });
     rl.registerAction("dealProduct.update", {
@@ -242,9 +214,8 @@ export default function pipedrive(rl) {
             data: { type: "object", required: true },
         },
         async execute(input, ctx) {
-            const t = getConn(ctx);
             const p = input;
-            return api(t, "PATCH", `/deals/${p.dealId}/products/${p.productAttachmentId}`, p.data);
+            return api(ctx, "PATCH", `deals/${pathSegment(p.dealId)}/products/${pathSegment(p.productAttachmentId)}`, p.data);
         },
     });
     rl.registerAction("dealProduct.remove", {
@@ -255,9 +226,8 @@ export default function pipedrive(rl) {
             productAttachmentId: { type: "number", required: true },
         },
         async execute(input, ctx) {
-            const t = getConn(ctx);
             const p = input;
-            await api(t, "DELETE", `/deals/${p.dealId}/products/${p.productAttachmentId}`);
+            await api(ctx, "DELETE", `deals/${pathSegment(p.dealId)}/products/${pathSegment(p.productAttachmentId)}`);
             return { success: true };
         },
     });
@@ -267,7 +237,7 @@ export default function pipedrive(rl) {
         description: "Get file metadata",
         inputSchema: { id: { type: "number", required: true } },
         async execute(input, ctx) {
-            return api(getConn(ctx), "GET", `/files/${input.id}`, undefined, undefined, "v1");
+            return api(ctx, "GET", `files/${pathSegment(input.id)}`, undefined, undefined, "v1");
         },
     });
     rl.registerAction("file.delete", {
@@ -275,7 +245,7 @@ export default function pipedrive(rl) {
         description: "Delete a file",
         inputSchema: { id: { type: "number", required: true } },
         async execute(input, ctx) {
-            await api(getConn(ctx), "DELETE", `/files/${input.id}`, undefined, undefined, "v1");
+            await api(ctx, "DELETE", `files/${pathSegment(input.id)}`, undefined, undefined, "v1");
             return { success: true };
         },
     });
@@ -289,17 +259,17 @@ export default function pipedrive(rl) {
         },
         async execute(input, ctx) {
             const { id, ...body } = input;
-            return api(getConn(ctx), "PUT", `/files/${id}`, body, undefined, "v1");
+            return api(ctx, "PUT", `files/${pathSegment(id)}`, body, undefined, "v1");
         },
     });
     // ── Lead ────────────────────────────────────────────
-    registerCrud(rl, "lead", "/leads");
+    registerCrud(rl, "lead", "leads");
     // ── Note ────────────────────────────────────────────
-    registerCrud(rl, "note", "/notes");
+    registerCrud(rl, "note", "notes");
     // ── Organization ────────────────────────────────────
-    registerCrud(rl, "organization", "/organizations", { hasSearch: true });
+    registerCrud(rl, "organization", "organizations", { hasSearch: true });
     // ── Person ──────────────────────────────────────────
-    registerCrud(rl, "person", "/persons", { hasSearch: true });
+    registerCrud(rl, "person", "persons", { hasSearch: true });
     // ── Product ─────────────────────────────────────────
-    registerCrud(rl, "product", "/products", { hasSearch: true });
+    registerCrud(rl, "product", "products", { hasSearch: true });
 }

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

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { blockContent, blocks, dateBoundary, list, PLAUD_OAUTH, PLAUD_PUBLIC_CLIENT_ID, PLAUD_REDIRECT_URI, recording, request, scan, } from "./shared.js";
+import { blockContent, blocks, dateBoundary, list, PLAUD_OAUTH, PLAUD_PUBLIC_CLIENT_ID, PLAUD_REDIRECT_URI, plaudCredential, recording, request, scan, } from "./shared.js";
 const strict = { additionalProperties: false };
 const Id = t.String({ minLength: 1, maxLength: 512 });
 const RecordingInput = t.Object({ id: Id }, strict);
@@ -43,6 +43,7 @@ const SummaryInput = t.Object({ id: Id, index: t.Optional(t.Integer({ minimum: 0
 export default function plaud(rl) {
     rl.setName("plaud");
     rl.setVersion("0.1.0");
+    rl.setCredential(plaudCredential);
     rl.setOAuth({
         protocol: PLAUD_OAUTH,
         scopes: [],

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

@@ -1,6 +1,5 @@
-import { AuthError, downloadResource, OAuthGrantSchema, } from "runline";
-import * as t from "typebox";
-import { credentialRuntime } from "../../_shared/credentialAdapter.js";
+import { AuthError, downloadResource, } from "runline";
+import { credentialOk, grantSchema, pathSegment, } from "../../_shared/credentials.js";
 const BASE = "https://platform.plaud.ai/developer/api";
 /** Public client identifier and fixed callback published in Plaud's official CLI. */
 export const PLAUD_PUBLIC_CLIENT_ID = "client_f9e0b214-c11f-434b-8b95-c4497d1feb81";
@@ -27,10 +26,10 @@ export const PLAUD_CREDENTIAL = {
     id: "plaud",
     methods: {
         oauth2: {
-            schema: t.Object({ grant: t.Optional(OAuthGrantSchema) }, { additionalProperties: false }),
+            schema: grantSchema,
             authentication: {
                 kind: "oauth2",
-                grantField: "grant",
+                field: "grant",
                 definition: PLAUD_OAUTH,
                 renewal: "refresh",
             },
@@ -46,34 +45,39 @@ export const PLAUD_CREDENTIAL = {
         },
     },
 };
-export function plaudRuntime(ctx) {
-    return credentialRuntime(ctx, PLAUD_CREDENTIAL, "oauth2", (config) => [
-        config.clientId,
-    ]);
-}
+/** Plaud signs one way: its public client's OAuth grant. */
+export const plaudCredential = (config) => ({
+    type: PLAUD_CREDENTIAL,
+    method: "oauth2",
+    application: { clientId: config.clientId },
+});
 function object(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new AuthError("invalid_response");
     return value;
 }
-export async function request(ctx, path) {
-    const { binding, transport } = plaudRuntime(ctx);
-    const response = await transport.request(binding, { target: "api", path });
-    if (!response.ok)
-        throw new Error(`plaud: request failed (HTTP ${response.status})`);
+/** Every Plaud answer is one JSON object; anything else, empty included, is invalid_response. */
+export async function request(ctx, path, query) {
+    const response = await credentialOk(ctx, plaudCredential, "plaud", {
+        target: "api",
+        path,
+        query,
+    });
     try {
-        return object(await response.json());
+        return object(JSON.parse(await response.text()));
     }
     catch {
         throw new AuthError("invalid_response");
     }
 }
 export async function recording(ctx, id) {
-    // Encoding protects separators/query injection; the transport also rejects traversal.
-    return request(ctx, `files/${encodeURIComponent(id)}`);
+    return request(ctx, `files/${pathSegment(id)}`);
 }
 export async function list(ctx, page, pageSize) {
-    const result = await request(ctx, `files/?${new URLSearchParams({ page: String(page), page_size: String(pageSize) })}`);
+    const result = await request(ctx, "files/", {
+        page,
+        page_size: pageSize,
+    });
     if (!Array.isArray(result.data) || result.data.length > pageSize)
         throw new AuthError("invalid_response");
     const data = result.data.map(object);

package/dist/plugins/plivo/src/credentials.js

@@ -0,0 +1,20 @@
+import { staticCredential } from "../../_shared/credentials.js";
+/**
+ * The auth ID and token: the ID is both the Basic username and the account
+ * segment of every path, so one stored part serves both.
+ */
+export const plivoCredential = staticCredential({
+    id: "plivo",
+    auth: {
+        kind: "static",
+        parts: ["authId", "authToken"],
+        placements: [
+            { in: "path", part: "authId" },
+            { in: "basic", username: "authId", password: "authToken" },
+        ],
+    },
+    local: { authId: "authId", authToken: "authToken" },
+    targets: {
+        api: { baseUrl: "https://api.plivo.com/v1/Account/", methods: ["POST"] },
+    },
+});