runline 0.32.0 → 0.34.0

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

@@ -18,8 +18,10 @@
  * downloaded to local files so callers can deliver them directly.
  */
 import { Buffer } from "node:buffer";
-import { readImageInput, SEND_FILE_NOTE, writeMediaFile } from "../../_shared/mediaFile.js";
+import { credentialJson, pathSegments, pathWithin, } from "../../_shared/credentials.js";
+import { readImageInput, SEND_FILE_NOTE, writeMediaFile, } from "../../_shared/mediaFile.js";
 import { parseSize } from "../../_shared/parseSize.js";
+import { replicateCredential } from "./credentials.js";
 const POLL_INTERVAL_MS = 2_000;
 const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
 function stringifyError(err) {
@@ -41,23 +43,15 @@ function stringifyError(err) {
  * only thing that differs between them is the prediction `input`.
  */
 async function runPrediction(opts) {
-    const { apiToken, model, input, timeoutMs, saveDir } = opts;
+    const { ctx, model, input, timeoutMs, saveDir } = opts;
     const deadline = Date.now() + timeoutMs;
-    const createRes = await fetch(`https://api.replicate.com/v1/models/${model}/predictions`, {
+    let prediction = (await credentialJson(ctx, replicateCredential, "replicate", {
+        target: "api",
+        path: `models/${pathSegments(model)}/predictions`,
         method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${apiToken}`,
-            // `Prefer: wait` lets the server hold the connection open for
-            // fast jobs so we don't have to poll at all on the happy path.
-            Prefer: "wait",
-        },
-        body: JSON.stringify({ input }),
-    });
-    if (!createRes.ok) {
-        throw new Error(`Replicate API error ${createRes.status}: ${await createRes.text()}`);
-    }
-    let prediction = (await createRes.json());
+        headers: { Prefer: "wait" },
+        json: { input },
+    }));
     while (prediction.status !== "succeeded" &&
         prediction.status !== "failed" &&
         prediction.status !== "canceled") {
@@ -65,13 +59,10 @@ async function runPrediction(opts) {
             throw new Error(`Replicate generation timed out after ${timeoutMs}ms (still ${prediction.status})`);
         }
         await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
-        const pollRes = await fetch(prediction.urls.get, {
-            headers: { Authorization: `Bearer ${apiToken}` },
-        });
-        if (!pollRes.ok) {
-            throw new Error(`Replicate poll error ${pollRes.status}: ${await pollRes.text()}`);
-        }
-        prediction = (await pollRes.json());
+        prediction = (await credentialJson(ctx, replicateCredential, "replicate", {
+            target: "api",
+            path: pathWithin(ctx, replicateCredential, "api", prediction.urls.get),
+        }));
     }
     if (prediction.status !== "succeeded") {
         throw new Error(`Replicate generation ${prediction.status}: ${stringifyError(prediction.error)}`);
@@ -124,6 +115,7 @@ async function runPrediction(opts) {
 export default function replicate(rl) {
     rl.setName("replicate");
     rl.setVersion("0.1.0");
+    rl.setCredential(replicateCredential);
     rl.setConnectionSchema({
         apiToken: {
             type: "string",
@@ -172,11 +164,10 @@ export default function replicate(rl) {
             if (typeof p.prompt !== "string" || p.prompt.length === 0) {
                 throw new Error("replicate: prompt is required");
             }
-            const apiToken = ctx.connection.config.apiToken;
             const model = p.model ?? "black-forest-labs/flux-dev";
             const { width, height } = parseSize(p.size, "replicate");
             const { images, failures } = await runPrediction({
-                apiToken,
+                ctx,
                 model,
                 input: {
                     prompt: p.prompt,
@@ -234,11 +225,10 @@ export default function replicate(rl) {
                 throw new Error("replicate: prompt is required");
             }
             const img = readImageInput(p.imagePath, "replicate");
-            const apiToken = ctx.connection.config.apiToken;
             const model = p.model ?? "black-forest-labs/flux-kontext-pro";
             const imageKey = p.imageInputKey ?? "input_image";
             const { images, failures } = await runPrediction({
-                apiToken,
+                ctx,
                 model,
                 input: {
                     prompt: p.prompt,

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

@@ -0,0 +1,17 @@
+import { httpsBase, staticCredential } from "../../_shared/credentials.js";
+/**
+ * A personal auth token in the X-Auth-Token header. Its public companion,
+ * the X-User-Id identifier, rides as an allowed header.
+ */
+export const rocketchatCredential = staticCredential({
+    id: "rocketchat",
+    auth: { kind: "apiKey", header: "X-Auth-Token" },
+    local: { secret: "authToken" },
+    targets: (config) => ({
+        api: {
+            baseUrl: httpsBase(config.domain, "api/v1/"),
+            methods: ["POST"],
+            allowedHeaders: ["X-User-Id"],
+        },
+    }),
+});

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

@@ -1,14 +1,9 @@
-function getConn(ctx) {
-    const c = ctx.connection.config;
-    return {
-        domain: c.domain.replace(/\/$/, ""),
-        userId: c.userId,
-        authToken: c.authToken,
-    };
-}
+import { credentialJson } from "../../_shared/credentials.js";
+import { rocketchatCredential } from "./credentials.js";
 export default function rocketchat(rl) {
     rl.setName("rocketchat");
     rl.setVersion("0.1.0");
+    rl.setCredential(rocketchatCredential);
     rl.setConnectionSchema({
         domain: {
             type: "string",
@@ -62,7 +57,6 @@ export default function rocketchat(rl) {
         },
         async execute(input, ctx) {
             const p = input;
-            const conn = getConn(ctx);
             const body = {
                 channel: p.channel,
                 text: p.text,
@@ -75,18 +69,13 @@ export default function rocketchat(rl) {
                 body.avatar = p.avatar;
             if (p.attachments)
                 body.attachments = p.attachments;
-            const res = await fetch(`${conn.domain}/api/v1/chat.postMessage`, {
+            return credentialJson(ctx, rocketchatCredential, "rocketchat", {
+                target: "api",
+                path: "chat.postMessage",
                 method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "X-Auth-Token": conn.authToken,
-                    "X-User-Id": conn.userId,
-                },
-                body: JSON.stringify(body),
+                headers: { "X-User-Id": String(ctx.connection.config.userId ?? "") },
+                json: body,
             });
-            if (!res.ok)
-                throw new Error(`Rocket.Chat error ${res.status}: ${await res.text()}`);
-            return res.json();
         },
     });
 }

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

@@ -0,0 +1,16 @@
+import { httpsBase, staticCredential } from "../../_shared/credentials.js";
+/**
+ * An API token, appended by the transport as the authtoken query parameter
+ * on the connection's own Rundeck server beneath /api/.
+ */
+export const rundeckCredential = staticCredential({
+    id: "rundeck",
+    auth: { kind: "queryKey", param: "authtoken" },
+    local: { secret: "token" },
+    targets: (config) => ({
+        api: {
+            baseUrl: httpsBase(config.url, "api/"),
+            methods: ["GET", "POST"],
+        },
+    }),
+});

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

@@ -1,33 +1,18 @@
-function getConn(ctx) {
-    const c = ctx.connection.config;
-    return {
-        url: c.url.replace(/\/$/, ""),
-        token: c.token,
-    };
-}
-async function apiRequest(conn, method, endpoint, body, qs) {
-    const url = new URL(`${conn.url}${endpoint}`);
-    url.searchParams.set("authtoken", conn.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 { credentialJson, pathSegment } from "../../_shared/credentials.js";
+import { rundeckCredential } from "./credentials.js";
+function apiRequest(ctx, method, path, body, qs) {
+    return credentialJson(ctx, rundeckCredential, "rundeck", {
+        target: "api",
+        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(`Rundeck error ${res.status}: ${await res.text()}`);
-    return res.json();
+        query: qs,
+        ...(body && Object.keys(body).length > 0 ? { json: body } : {}),
+    });
 }
 export default function rundeck(rl) {
     rl.setName("rundeck");
     rl.setVersion("0.1.0");
+    rl.setCredential(rundeckCredential);
     rl.setConnectionSchema({
         url: {
             type: "string",
@@ -60,7 +45,6 @@ export default function rundeck(rl) {
         },
         async execute(input, ctx) {
             const p = input;
-            const conn = getConn(ctx);
             let argString = "";
             if (p.arguments) {
                 for (const arg of p.arguments) {
@@ -70,7 +54,7 @@ export default function rundeck(rl) {
             const qs = {};
             if (p.filter)
                 qs.filter = p.filter;
-            return apiRequest(conn, "POST", `/api/14/job/${p.jobId}/run`, { argString: argString.trim() }, qs);
+            return apiRequest(ctx, "POST", `14/job/${pathSegment(p.jobId)}/run`, { argString: argString.trim() }, qs);
         },
     });
     rl.registerAction("job.getMetadata", {
@@ -79,7 +63,7 @@ export default function rundeck(rl) {
         inputSchema: { jobId: { type: "string", required: true } },
         async execute(input, ctx) {
             const { jobId } = input;
-            return apiRequest(getConn(ctx), "GET", `/api/18/job/${jobId}/info`);
+            return apiRequest(ctx, "GET", `18/job/${pathSegment(jobId)}/info`);
         },
     });
 }

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

@@ -0,0 +1,73 @@
+import { AuthError, } from "runline";
+import { configChoice, grantSchema, httpsBase, staticCredential, } from "../../_shared/credentials.js";
+/**
+ * A path beneath the org's My Domain URL. A Lightning UI host serves no
+ * API, and is refused as invalid_credentials.
+ */
+function myDomain(value, path) {
+    const url = httpsBase(value, path);
+    if (/\.lightning\.force\.com$/i.test(new URL(url).hostname))
+        throw new AuthError("invalid_credentials");
+    return url;
+}
+/** The REST API on the org's My Domain instance. */
+function api(config) {
+    return {
+        baseUrl: myDomain(config.instanceUrl ?? config.loginUrl, ""),
+        methods: ["GET", "POST", "PATCH", "DELETE"],
+    };
+}
+const accessToken = staticCredential({
+    id: "salesforce",
+    auth: { kind: "bearer" },
+    local: { secret: "accessToken" },
+    targets: (config) => ({ api: api(config) }),
+});
+/**
+ * A static access token as a bearer, or a Connected App's client
+ * credentials exchanged at the My Domain token endpoint; either signs the
+ * REST API on the same My Domain instance. `authMethod` picks one;
+ * without it, a connection naming a client ID uses client credentials —
+ * the token the CLI keeps from that exchange is stored as `accessToken`
+ * too, so a token alone does not decide — and any other uses its token.
+ */
+export const salesforceCredential = (config) => {
+    const token = accessToken(config);
+    const method = configChoice(config.authMethod ??
+        (config.clientId ? "clientCredentials" : "accessToken"), ["accessToken", "clientCredentials"], "accessToken");
+    const type = {
+        id: "salesforce",
+        methods: {
+            ...token.type.methods,
+            clientCredentials: {
+                schema: grantSchema,
+                authentication: {
+                    kind: "oauth2",
+                    field: "grant",
+                    renewal: "clientCredentials",
+                    definition: {
+                        id: "salesforce.oauth2",
+                        provider: "salesforce",
+                        clientCredentials: {
+                            url: myDomain(config.loginUrl ?? config.instanceUrl, "services/oauth2/token"),
+                            clientAuthentication: "client_secret_post",
+                        },
+                    },
+                },
+                targets: { api: api(config) },
+            },
+        },
+    };
+    if (method === "accessToken")
+        return { ...token, type };
+    return {
+        type,
+        method: "clientCredentials",
+        application: {
+            clientId: config.clientId,
+            ...(typeof config.clientSecret === "string"
+                ? { clientSecret: config.clientSecret }
+                : {}),
+        },
+    };
+};

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

@@ -1,15 +1,21 @@
 import * as t from "typebox";
+import { salesforceCredential } from "./credentials.js";
 import { registerMetadataActions } from "./metadata.js";
 import { registerQueryActions } from "./query.js";
 import { registerGenericSObjectActions, registerStandardSObjectActions, } from "./sobjects.js";
 export default function salesforce(rl) {
     rl.setName("salesforce");
     rl.setVersion("0.2.0");
+    rl.setCredential(salesforceCredential);
     rl.setConnectionSchema(t.Object({
         instanceUrl: t.Optional(t.String({
             description: "Salesforce API instance URL, e.g. https://your-domain.my.salesforce.com. Required for static accessToken auth; optional for client credentials when loginUrl is set.",
             env: "SALESFORCE_INSTANCE_URL",
         })),
+        authMethod: t.Optional(t.String({
+            description: "accessToken or clientCredentials (inferred from which credential the connection holds)",
+            env: "SALESFORCE_AUTH_METHOD",
+        })),
         accessToken: t.Optional(t.String({
             description: "Salesforce OAuth2 access token. Use for static-token auth.",
             env: "SALESFORCE_ACCESS_TOKEN",

package/dist/plugins/salesforce/src/metadata.js

@@ -1,29 +1,16 @@
 import * as t from "typebox";
-import { api, getSession, identity } from "./shared.js";
+import { api, identity } from "./shared.js";
 export function registerMetadataActions(rl) {
     rl.registerAction("connection.test", {
         access: "read",
         description: "Validate Salesforce auth and return safe connection metadata",
         inputSchema: t.Object({}),
         async execute(_input, ctx) {
-            const sessionPromise = getSession(ctx);
-            const session = await sessionPromise;
-            let limits;
-            let limitsError;
-            try {
-                limits = (await api(ctx, "GET", "/limits", undefined, undefined, sessionPromise));
-            }
-            catch (error) {
-                limitsError = error instanceof Error ? error.message : String(error);
-            }
+            const limits = (await api(ctx, "GET", "/limits"));
             return {
                 ok: true,
-                instanceUrl: session.instanceUrl,
-                tokenType: session.tokenType,
-                scope: session.scope,
-                id: session.id,
+                instanceUrl: ctx.connection.config.instanceUrl ?? ctx.connection.config.loginUrl,
                 limits,
-                limitsError,
             };
         },
     });

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

@@ -1,107 +1,32 @@
-import { requestOAuth2Token } from "runline";
+import { AuthError } from "runline";
+import { credentialJson } from "../../_shared/credentials.js";
+import { salesforceCredential } from "./credentials.js";
 export const DEFAULT_API_VERSION = "v59.0";
-export function config(ctx) {
-    return ctx.connection.config;
-}
-export function trimTrailingSlash(url) {
-    return url.replace(/\/+$/, "");
-}
-function requireString(value, name) {
-    if (typeof value !== "string" || value.trim() === "") {
-        throw new Error(`Salesforce connection is missing ${name}`);
-    }
-    return value.trim();
-}
+/** The connection's REST API version, as `vNN.N`; anything else is refused. */
 export function apiVersion(ctx) {
-    const raw = config(ctx).apiVersion;
+    const raw = ctx.connection.config.apiVersion;
     if (typeof raw !== "string" || raw.trim() === "")
         return DEFAULT_API_VERSION;
-    const version = raw.trim();
-    return version.startsWith("v") ? version : `v${version}`;
-}
-export function validateInstanceUrl(url) {
-    const normalized = trimTrailingSlash(url.trim());
-    if (/\.lightning\.force\.com$/i.test(new URL(normalized).hostname)) {
-        throw new Error("Salesforce instanceUrl/loginUrl must be the API My Domain URL, not the Lightning UI URL. Use a URL like https://your-domain.my.salesforce.com.");
-    }
-    return normalized;
-}
-export async function getSession(ctx) {
-    const c = config(ctx);
-    if (c.accessToken) {
-        return {
-            instanceUrl: validateInstanceUrl(requireString(c.instanceUrl, "instanceUrl")),
-            accessToken: requireString(c.accessToken, "accessToken"),
-            tokenType: "Bearer",
-        };
-    }
-    const loginUrl = validateInstanceUrl(requireString(c.loginUrl ?? c.instanceUrl, "loginUrl or instanceUrl"));
-    const clientId = requireString(c.clientId, "clientId");
-    const clientSecret = requireString(c.clientSecret, "clientSecret");
-    const tokens = await requestOAuth2Token({
-        url: `${loginUrl}/services/oauth2/token`,
-        clientAuthentication: "client_secret_post",
-        response: {
-            metadata: {
-                instanceUrl: "instance_url",
-                id: "id",
-                issuedAt: "issued_at",
-            },
-        },
-    }, { grant_type: "client_credentials" }, { clientId, clientSecret });
-    return {
-        instanceUrl: validateInstanceUrl(requireString(tokens.metadata?.instanceUrl, "token response instance_url")),
-        accessToken: tokens.accessToken,
-        tokenType: tokens.tokenType ?? "Bearer",
-        scope: tokens.scope,
-        id: tokens.metadata?.id,
-        issuedAt: tokens.metadata?.issuedAt,
-    };
-}
-export async function api(ctx, method, endpoint, body, qs, session = getSession(ctx)) {
-    return rest(ctx, method, `/services/data/${apiVersion(ctx)}${endpoint}`, body, qs, session);
-}
-export async function rest(ctx, method, path, body, qs, session = getSession(ctx)) {
-    const resolvedSession = await session;
-    const url = new URL(path, resolvedSession.instanceUrl);
-    if (qs) {
-        for (const [k, v] of Object.entries(qs)) {
-            if (v !== undefined && v !== null)
-                url.searchParams.set(k, String(v));
-        }
-    }
-    const init = {
+    const version = raw.trim().startsWith("v") ? raw.trim() : `v${raw.trim()}`;
+    if (!/^v\d+\.\d+$/.test(version))
+        throw new AuthError("invalid_credentials");
+    return version;
+}
+/** A request on the org's instance, by a path from its root. */
+export function rest(ctx, method, path, body, query) {
+    return credentialJson(ctx, salesforceCredential, "salesforce", {
+        target: "api",
+        path: path.replace(/^\//, ""),
         method,
-        headers: {
-            Authorization: `Bearer ${resolvedSession.accessToken}`,
-            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.status === 204)
-        return { success: true };
-    const text = await res.text();
-    if (!res.ok)
-        throw new Error(`Salesforce error ${res.status}: ${text}`);
-    return text ? JSON.parse(text) : null;
-}
-export async function identity(ctx) {
-    const session = await getSession(ctx);
-    if (!session.id) {
-        return { instanceUrl: session.instanceUrl, tokenType: session.tokenType };
-    }
-    const res = await fetch(session.id, {
-        headers: {
-            Authorization: `Bearer ${session.accessToken}`,
-            Accept: "application/json",
-        },
+        query,
+        ...(body && Object.keys(body).length > 0 ? { json: body } : {}),
     });
-    const text = await res.text();
-    if (!res.ok) {
-        throw new Error(`Salesforce identity error ${res.status}: ${text}`);
-    }
-    return text ? JSON.parse(text) : {};
+}
+/** A REST API request beneath `services/data/<version>`. */
+export function api(ctx, method, endpoint, body, query) {
+    return rest(ctx, method, `services/data/${apiVersion(ctx)}${endpoint}`, body, query);
+}
+/** The signed-in user, from the instance's OpenID Connect userinfo endpoint. */
+export function identity(ctx) {
+    return rest(ctx, "GET", "services/oauth2/userinfo");
 }

package/dist/plugins/salesforce/src/sobjects.js

@@ -1,4 +1,5 @@
 import * as t from "typebox";
+import { pathSegment } from "../../_shared/credentials.js";
 import { records } from "./queryResult.js";
 import { api } from "./shared.js";
 export const SOBJECTS = [
@@ -54,7 +55,7 @@ function registerSObject(rl, sObject) {
         description: `Get a ${sObject} by ID`,
         inputSchema: t.Object({ id: t.String() }),
         async execute(input, ctx) {
-            return api(ctx, "GET", `/sobjects/${sObject}/${input.id}`);
+            return api(ctx, "GET", `/sobjects/${sObject}/${pathSegment(input.id)}`);
         },
     });
     rl.registerAction(`${lower}.update`, {
@@ -63,7 +64,7 @@ function registerSObject(rl, sObject) {
         inputSchema: t.Object({ id: t.String(), data: Data }),
         async execute(input, ctx) {
             const p = input;
-            await api(ctx, "PATCH", `/sobjects/${sObject}/${p.id}`, p.data);
+            await api(ctx, "PATCH", `/sobjects/${sObject}/${pathSegment(p.id)}`, p.data);
             return { success: true, id: p.id };
         },
     });
@@ -72,7 +73,7 @@ function registerSObject(rl, sObject) {
         description: `Delete a ${sObject}`,
         inputSchema: t.Object({ id: t.String() }),
         async execute(input, ctx) {
-            await api(ctx, "DELETE", `/sobjects/${sObject}/${input.id}`);
+            await api(ctx, "DELETE", `/sobjects/${sObject}/${pathSegment(input.id)}`);
             return { success: true };
         },
     });
@@ -106,7 +107,7 @@ function registerSObject(rl, sObject) {
         }),
         async execute(input, ctx) {
             const p = input;
-            return api(ctx, "PATCH", `/sobjects/${sObject}/${p.externalIdField}/${p.externalIdValue}`, p.data);
+            return api(ctx, "PATCH", `/sobjects/${sObject}/${pathSegment(p.externalIdField)}/${pathSegment(p.externalIdValue)}`, p.data);
         },
     });
 }
@@ -121,7 +122,7 @@ export function registerGenericSObjectActions(rl) {
         inputSchema: t.Object({ sObject: t.String(), data: Data }),
         async execute(input, ctx) {
             const p = input;
-            return api(ctx, "POST", `/sobjects/${p.sObject}`, p.data);
+            return api(ctx, "POST", `/sobjects/${pathSegment(p.sObject)}`, p.data);
         },
     });
     rl.registerAction("sobject.get", {
@@ -130,7 +131,7 @@ export function registerGenericSObjectActions(rl) {
         inputSchema: t.Object({ sObject: t.String(), id: t.String() }),
         async execute(input, ctx) {
             const p = input;
-            return api(ctx, "GET", `/sobjects/${p.sObject}/${p.id}`);
+            return api(ctx, "GET", `/sobjects/${pathSegment(p.sObject)}/${pathSegment(p.id)}`);
         },
     });
     rl.registerAction("sobject.update", {
@@ -139,7 +140,7 @@ export function registerGenericSObjectActions(rl) {
         inputSchema: t.Object({ sObject: t.String(), id: t.String(), data: Data }),
         async execute(input, ctx) {
             const p = input;
-            await api(ctx, "PATCH", `/sobjects/${p.sObject}/${p.id}`, p.data);
+            await api(ctx, "PATCH", `/sobjects/${pathSegment(p.sObject)}/${pathSegment(p.id)}`, p.data);
             return { success: true };
         },
     });
@@ -149,7 +150,7 @@ export function registerGenericSObjectActions(rl) {
         inputSchema: t.Object({ sObject: t.String(), id: t.String() }),
         async execute(input, ctx) {
             const p = input;
-            await api(ctx, "DELETE", `/sobjects/${p.sObject}/${p.id}`);
+            await api(ctx, "DELETE", `/sobjects/${pathSegment(p.sObject)}/${pathSegment(p.id)}`);
             return { success: true };
         },
     });
@@ -158,7 +159,7 @@ export function registerGenericSObjectActions(rl) {
         description: "Describe an sObject's metadata/fields",
         inputSchema: t.Object({ sObject: t.String() }),
         async execute(input, ctx) {
-            return api(ctx, "GET", `/sobjects/${input.sObject}/describe`);
+            return api(ctx, "GET", `/sobjects/${pathSegment(input.sObject)}/describe`);
         },
     });
 }

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

@@ -0,0 +1,17 @@
+import { staticCredential } from "../../_shared/credentials.js";
+/**
+ * A session token in the sessionToken header, to Salesmate's one API
+ * origin. The public workspace linkname rides along as x-linkname.
+ */
+export const salesmateCredential = staticCredential({
+    id: "salesmate",
+    auth: { kind: "apiKey", header: "sessionToken" },
+    local: { secret: "sessionToken" },
+    targets: {
+        api: {
+            baseUrl: "https://apis.salesmate.io/",
+            methods: ["GET", "POST", "PUT", "DELETE"],
+            allowedHeaders: ["x-linkname"],
+        },
+    },
+});