runline 0.33.0 → 0.35.0

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

@@ -1,47 +1,24 @@
-async function apiRequest(baseUrl, username, password, method, endpoint, body, qs) {
-    const url = new URL(`${baseUrl}${endpoint}`);
-    if (qs) {
-        for (const [k, v] of Object.entries(qs)) {
-            if (v !== undefined && v !== null)
-                url.searchParams.set(k, String(v));
-        }
-    }
-    const opts = {
+import { credentialOk, jsonOrAcknowledged, pathSegment, } from "../../_shared/credentials.js";
+import { elasticsearchCredential } from "./credentials.js";
+async function req(ctx, method, path, body, query) {
+    const res = await credentialOk(ctx, elasticsearchCredential, "elasticsearch", {
+        target: "api",
+        path,
         method,
-        headers: {
-            Authorization: `Basic ${btoa(`${username}:${password}`)}`,
-            "Content-Type": "application/json",
-        },
-    };
-    if (body &&
-        Object.keys(body).length > 0 &&
-        method !== "GET" &&
-        method !== "DELETE") {
-        opts.body = JSON.stringify(body);
-    }
-    const res = await fetch(url.toString(), opts);
-    if (!res.ok)
-        throw new Error(`Elasticsearch error ${res.status}: ${await res.text()}`);
-    const ct = res.headers.get("content-type") ?? "";
-    if (ct.includes("application/json"))
-        return res.json();
-    return { success: true };
-}
-function getConn(ctx) {
-    const cfg = ctx.connection.config;
-    return {
-        baseUrl: cfg.baseUrl.replace(/\/$/, ""),
-        username: cfg.username ?? "",
-        password: cfg.password ?? "",
-    };
-}
-function req(ctx, method, endpoint, body, qs) {
-    const { baseUrl, username, password } = getConn(ctx);
-    return apiRequest(baseUrl, username, password, method, endpoint, body, qs);
+        query,
+        ...(body &&
+            Object.keys(body).length > 0 &&
+            method !== "GET" &&
+            method !== "DELETE"
+            ? { json: body }
+            : {}),
+    });
+    return jsonOrAcknowledged(res);
 }
 export default function elasticsearch(rl) {
     rl.setName("elasticsearch");
     rl.setVersion("0.1.0");
+    rl.setCredential(elasticsearchCredential);
     rl.setConnectionSchema({
         baseUrl: {
             type: "string",
@@ -77,7 +54,9 @@ export default function elasticsearch(rl) {
         },
         async execute(input, ctx) {
             const { index, id, body } = input;
-            const endpoint = id ? `/${index}/_doc/${id}` : `/${index}/_doc`;
+            const endpoint = id
+                ? `${pathSegment(index)}/_doc/${pathSegment(id)}`
+                : `${pathSegment(index)}/_doc`;
             return req(ctx, id ? "PUT" : "POST", endpoint, body);
         },
     });
@@ -90,7 +69,7 @@ export default function elasticsearch(rl) {
         },
         async execute(input, ctx) {
             const { index, id } = input;
-            return req(ctx, "GET", `/${index}/_doc/${id}`);
+            return req(ctx, "GET", `${pathSegment(index)}/_doc/${pathSegment(id)}`);
         },
     });
     rl.registerAction("document.update", {
@@ -107,7 +86,7 @@ export default function elasticsearch(rl) {
         },
         async execute(input, ctx) {
             const { index, id, body } = input;
-            return req(ctx, "POST", `/${index}/_update/${id}`, { doc: body });
+            return req(ctx, "POST", `${pathSegment(index)}/_update/${pathSegment(id)}`, { doc: body });
         },
     });
     rl.registerAction("document.delete", {
@@ -119,7 +98,7 @@ export default function elasticsearch(rl) {
         },
         async execute(input, ctx) {
             const { index, id } = input;
-            return req(ctx, "DELETE", `/${index}/_doc/${id}`);
+            return req(ctx, "DELETE", `${pathSegment(index)}/_doc/${pathSegment(id)}`);
         },
     });
     rl.registerAction("document.search", {
@@ -151,7 +130,7 @@ export default function elasticsearch(rl) {
                 body.from = offset;
             if (sort)
                 body.sort = sort;
-            const data = (await req(ctx, "POST", `/${index}/_search`, body));
+            const data = (await req(ctx, "POST", `${pathSegment(index)}/_search`, body));
             return data.hits?.hits;
         },
     });
@@ -179,7 +158,7 @@ export default function elasticsearch(rl) {
                 body.settings = settings;
             if (mappings)
                 body.mappings = mappings;
-            return req(ctx, "PUT", `/${index}`, Object.keys(body).length > 0 ? body : undefined);
+            return req(ctx, "PUT", pathSegment(index), body);
         },
     });
     rl.registerAction("index.get", {
@@ -189,14 +168,14 @@ export default function elasticsearch(rl) {
             index: { type: "string", required: true, description: "Index name" },
         },
         async execute(input, ctx) {
-            return req(ctx, "GET", `/${input.index}`);
+            return req(ctx, "GET", pathSegment(input.index));
         },
     });
     rl.registerAction("index.list", {
         access: "read",
         description: "List all indices",
         async execute(_input, ctx) {
-            return req(ctx, "GET", "/_cat/indices", undefined, { format: "json" });
+            return req(ctx, "GET", "_cat/indices", undefined, { format: "json" });
         },
     });
     rl.registerAction("index.delete", {
@@ -206,7 +185,7 @@ export default function elasticsearch(rl) {
             index: { type: "string", required: true, description: "Index name" },
         },
         async execute(input, ctx) {
-            return req(ctx, "DELETE", `/${input.index}`);
+            return req(ctx, "DELETE", pathSegment(input.index));
         },
     });
 }

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

@@ -0,0 +1,30 @@
+import { staticCredential } from "../../_shared/credentials.js";
+/**
+ * The longest request deadline: the input schemas' `timeout` maximum and the
+ * `audio` target's deadline, at the transport's default host ceiling.
+ */
+export const MAX_TIMEOUT_MS = 10 * 60_000;
+/**
+ * An ElevenLabs API key, sent as `xi-api-key` to the one API origin. The
+ * `audio` target carries generation, transcription, and downloads: it
+ * declares `MAX_TIMEOUT_MS` and the 100 MiB audio ceiling, both capped by
+ * the host. The `api` target is the catalog
+ * and management surface on the transport defaults.
+ */
+export const elevenlabsCredential = staticCredential({
+    id: "elevenlabs",
+    auth: { kind: "apiKey", header: "xi-api-key" },
+    local: { secret: "apiKey" },
+    targets: {
+        api: {
+            baseUrl: "https://api.elevenlabs.io/",
+            methods: ["GET", "POST", "DELETE"],
+        },
+        audio: {
+            baseUrl: "https://api.elevenlabs.io/",
+            methods: ["GET", "POST"],
+            timeoutMs: MAX_TIMEOUT_MS,
+            maxResponseBytes: 100 * 1024 * 1024,
+        },
+    },
+});

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

@@ -1,4 +1,5 @@
 import * as t from "typebox";
+import { elevenlabsCredential } from "./credentials.js";
 import { audioOptions, formatSchema, musicSchema as music, STRICT, seed, speechControls, text, timeout, voiceSettings, } from "./schemas.js";
 import { appendFile, audioRequest, jsonRequest, voiceForm, voicePath, } from "./shared.js";
 import { registerWorkflows } from "./workflows.js";
@@ -89,6 +90,7 @@ const sound = t.Object({
 export default function elevenlabs(rl) {
     rl.setName("elevenlabs");
     rl.setVersion("0.1.0");
+    rl.setCredential(elevenlabsCredential);
     registerWorkflows(rl);
     rl.setConnectionSchema(t.Object({
         apiKey: t.String({
@@ -226,7 +228,8 @@ export default function elevenlabs(rl) {
                 if (value !== undefined)
                     form.append(key, String(value));
             }
-            return jsonRequest(ctx, "/v1/speech-to-text", "transcription", { method: "POST", body: form }, p.timeoutMs ?? 300_000);
+            // The audio target carries the long transcription deadline.
+            return jsonRequest(ctx, "/v1/speech-to-text", "transcription", { method: "POST", body: form }, p.timeoutMs ?? 300_000, "audio");
         },
     });
     rl.registerAction("music.create", {

package/dist/plugins/elevenlabs/src/schemas.js

@@ -1,9 +1,10 @@
 import * as t from "typebox";
+import { MAX_TIMEOUT_MS } from "./credentials.js";
 export const STRICT = { additionalProperties: false };
 export const text = t.String({ minLength: 1, pattern: "\\S" });
 export const timeout = t.Integer({
     minimum: 1000,
-    maximum: 3_600_000,
+    maximum: MAX_TIMEOUT_MS,
     default: 300_000,
     description: "Request deadline including the response body; does not cancel provider work.",
 });

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

@@ -1,42 +1,93 @@
-import { constants } from "node:fs";
-import { open } from "node:fs/promises";
 import { basename } from "node:path";
+import { AuthError } from "runline";
 import * as t from "typebox";
 import { Check } from "typebox/value";
-import { authedFetch } from "../../_shared/authedFetch.js";
+import { credentialBroker } from "../../_shared/credentialAdapter.js";
+import { multipartBody, pathSegment, responseFailed, } from "../../_shared/credentials.js";
+import { readLocalFile } from "../../_shared/localFile.js";
 import { SEND_FILE_NOTE, writeMediaFile } from "../../_shared/mediaFile.js";
-import { obj, readBounded, readBoundedBytes, seg, } from "../../_shared/provider.js";
-export const voicePath = (id) => seg(id, "voice id", "elevenlabs");
+import { obj, readBounded, readBoundedBytes } from "../../_shared/provider.js";
+import { elevenlabsCredential } from "./credentials.js";
+export const voicePath = (id) => pathSegment(id);
 const JSON_LIMIT = 8 * 1024 * 1024;
 const AUDIO_LIMIT = 100 * 1024 * 1024;
-/** A fixed origin, no redirects or retries, and one deadline through body consumption. */
-async function request(ctx, path, init, timeoutMs, consume) {
-    const key = ctx.connection.config.apiKey;
-    if (typeof key !== "string" || !key.trim())
-        throw new Error("Missing ELEVENLABS_API_KEY");
+/**
+ * The caller-tunable deadline over a brokered exchange. The transport
+ * buffers the body, so the race bounds the whole exchange; on timeout the
+ * brokered call runs on to the target's own deadline, and its late outcome
+ * is observed so it cannot become an unhandled rejection.
+ */
+async function withDeadline(work, timeoutMs) {
+    let timer;
+    try {
+        return await Promise.race([
+            work,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    work.catch(() => { });
+                    reject(new Error("elevenlabs: request timed out"));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Every credential-bearing request signs through the declared credential. */
+async function request(ctx, target, path, init, timeoutMs, consume) {
     let requestId = null;
     try {
-        const response = await authedFetch(`https://api.elevenlabs.io${path}`, {
-            ...init,
-            headers: {
-                "xi-api-key": key.trim(),
-                ...(typeof init.body === "string"
-                    ? { "content-type": "application/json" }
-                    : {}),
-            },
-            signal: AbortSignal.timeout(timeoutMs),
-        });
+        const headers = {};
+        let body;
+        if (typeof init.body === "string") {
+            body = init.body;
+            headers["content-type"] = "application/json";
+        }
+        else if (init.body !== undefined) {
+            const multipart = await multipartBody(init.body);
+            body = multipart.body;
+            headers["content-type"] = multipart.contentType;
+        }
+        const response = await withDeadline(credentialBroker(ctx, elevenlabsCredential).request({
+            target,
+            path: path.replace(/^\//, ""),
+            method: init.method ?? "GET",
+            headers,
+            ...(body !== undefined ? { body } : {}),
+        }), timeoutMs);
         requestId = response.headers.get("request-id");
         // Both JSON and audio errors use the provider's JSON error envelope.
         if (!response.ok)
-            await json(response);
+            throw await responseFailed("elevenlabs", response, errorEnvelope);
         return await consume(response);
     }
     catch (error) {
+        // The request id and retry guidance join the message; a transport
+        // failure keeps its code, so callers can still tell why it failed.
         const mutation = init.method && init.method !== "GET";
-        throw new Error(`${error instanceof Error ? error.message : String(error)}${requestId ? ` (requestId ${requestId})` : ""}${mutation ? ". Request may have been applied or billed; do not retry automatically." : ""}`, { cause: error });
+        const wrapped = new Error(`${error instanceof Error ? error.message : String(error)}${requestId ? ` (requestId ${requestId})` : ""}${mutation ? ". Request may have been applied or billed; do not retry automatically." : ""}`, { cause: error });
+        if (error instanceof AuthError)
+            wrapped.code = error.code;
+        throw wrapped;
     }
 }
+/**
+ * The error envelope's `detail`: a status code (or a bare code string), or
+ * the validation entries whose `loc` paths name the offending fields.
+ */
+function errorEnvelope(body) {
+    const detail = obj(body).detail;
+    return {
+        code: typeof detail === "string" ? detail : obj(detail).status,
+        param: Array.isArray(detail)
+            ? detail.map((entry) => {
+                const loc = obj(entry).loc;
+                return Array.isArray(loc) ? loc.join(".") : loc;
+            })
+            : undefined,
+    };
+}
 async function json(response, limit = JSON_LIMIT) {
     const text = await readBounded(response, limit, `elevenlabs: JSON exceeds ${limit / (1024 * 1024)} MiB`);
     let body;
@@ -44,23 +95,7 @@ async function json(response, limit = JSON_LIMIT) {
         body = text ? JSON.parse(text) : null;
     }
     catch {
-        throw new Error(`elevenlabs HTTP ${response.status}: non-JSON response`);
-    }
-    if (!response.ok) {
-        const detail = obj(body).detail;
-        const error = obj(detail);
-        // Include provider error messages and locations, not validation input payloads.
-        const message = typeof detail === "string"
-            ? detail
-            : Array.isArray(detail)
-                ? detail
-                    .map((v) => {
-                    const e = obj(v);
-                    return `${Array.isArray(e.loc) ? e.loc.join(".") : "body"}: ${e.msg ?? "invalid"}`;
-                })
-                    .join("; ")
-                : `${error.status ?? "request failed"}: ${error.message ?? ""}`;
-        throw new Error(`elevenlabs HTTP ${response.status}: ${message.slice(0, 1000)}`);
+        throw new Error("elevenlabs: non-JSON response");
     }
     if (body === null || typeof body !== "object")
         throw new Error("elevenlabs: expected a JSON object or array");
@@ -105,8 +140,8 @@ const responses = {
     }),
     dictionary: t.Object({ id, version_id: id }),
 };
-export async function jsonRequest(ctx, path, expected, init = {}, timeoutMs = 60_000) {
-    return request(ctx, path, init, timeoutMs, async (response) => {
+export async function jsonRequest(ctx, path, expected, init = {}, timeoutMs = 60_000, target = "api") {
+    return request(ctx, target, path, init, timeoutMs, async (response) => {
         const body = await json(response);
         if (!Check(responses[expected], body))
             throw new Error(`elevenlabs: invalid ${expected} response`);
@@ -182,7 +217,7 @@ export async function audioRequest(ctx, path, body, options) {
 }
 /** All generated, aligned, isolated, and recovered audio uses the same file writer. */
 export async function binaryRequest(ctx, path, init, options) {
-    return request(ctx, path, init, options.timeoutMs ?? 300_000, async (response) => {
+    return request(ctx, "audio", path, init, options.timeoutMs ?? 300_000, async (response) => {
         let bytes;
         let timestamps = {};
         let mime;
@@ -248,25 +283,15 @@ export async function voiceForm(input) {
         form.append("remove_background_noise", String(input.removeBackgroundNoise));
     return form;
 }
-/** Bound uploads before allocating; read through the same handle to avoid stat/read races. */
+const UPLOAD_RULE = "elevenlabs: each input must be a nonempty regular file of at most 25 MiB";
+/** A local upload as one form part, bounded and read by the shared reader. */
 export async function appendFile(form, field, path) {
-    // Nonblocking open lets fstat reject FIFOs without waiting for a writer.
-    const file = await open(path, constants.O_RDONLY | constants.O_NONBLOCK);
-    try {
-        const stat = await file.stat();
-        if (!stat.isFile() || stat.size === 0 || stat.size > 25 * 1024 * 1024)
-            throw new Error("elevenlabs: each input must be a nonempty regular file of at most 25 MiB");
-        const bytes = Buffer.alloc(stat.size);
-        let offset = 0;
-        while (offset < bytes.length) {
-            const { bytesRead } = await file.read(bytes, offset, bytes.length - offset, offset);
-            if (!bytesRead)
-                throw new Error("elevenlabs: input file changed while reading");
-            offset += bytesRead;
-        }
-        form.append(field, new Blob([bytes]), basename(path));
-    }
-    finally {
-        await file.close();
-    }
+    const bytes = await readLocalFile(path, {
+        subject: `elevenlabs: ${field}`,
+        maxBytes: 25 * 1024 * 1024,
+        oversize: UPLOAD_RULE,
+    });
+    if (!bytes.length)
+        throw new Error(UPLOAD_RULE);
+    form.append(field, new Blob([bytes]), basename(path));
 }

package/dist/plugins/elevenlabs/src/workflows.js

@@ -1,5 +1,5 @@
 import * as t from "typebox";
-import { seg } from "../../_shared/provider.js";
+import { pathSegment } from "../../_shared/credentials.js";
 import { audioOptions, dictionaries, fileOptions, normalization, STRICT, seed, text, voiceSettings, } from "./schemas.js";
 import { appendFile, audioRequest, binaryRequest, jsonRequest, voiceForm, voicePath, } from "./shared.js";
 const dialogue = t.Object({
@@ -65,7 +65,7 @@ const dictionaryCreate = t.Object({
         }, STRICT),
     ]), { minItems: 1 }),
 }, STRICT);
-const historyPath = (id) => `/v1/history/${seg(id, "history item id", "elevenlabs")}`;
+const historyPath = (id) => `/v1/history/${pathSegment(id)}`;
 export function registerWorkflows(rl) {
     rl.registerAction("dialogue.create", {
         access: "write",

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

@@ -0,0 +1,14 @@
+import { staticCredential } from "../../_shared/credentials.js";
+/** An API key, sent raw (no scheme) on the Authorization header to Emelia's
+ *  one GraphQL endpoint. */
+export const emeliaCredential = staticCredential({
+    id: "emelia",
+    auth: { kind: "apiKey", header: "Authorization" },
+    local: { secret: "apiKey" },
+    targets: {
+        gql: {
+            baseUrl: "https://graphql.emelia.io/",
+            methods: ["POST"],
+        },
+    },
+});

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

@@ -1,26 +1,23 @@
-const GQL_URL = "https://graphql.emelia.io/graphql";
-async function gql(apiKey, query, variables) {
+import { credentialJson, graphqlFailed } from "../../_shared/credentials.js";
+import { emeliaCredential } from "./credentials.js";
+async function gql(ctx, query, variables) {
     const body = { query };
     if (variables)
         body.variables = variables;
-    const res = await fetch(GQL_URL, {
+    const data = (await credentialJson(ctx, emeliaCredential, "emelia", {
+        target: "gql",
+        path: "graphql",
         method: "POST",
-        headers: {
-            Authorization: apiKey,
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify(body),
-    });
-    if (!res.ok)
-        throw new Error(`Emelia API error ${res.status}: ${await res.text()}`);
-    const data = (await res.json());
+        json: body,
+    }));
     if (data.errors)
-        throw new Error(`Emelia GraphQL error: ${JSON.stringify(data.errors)}`);
+        throw graphqlFailed("emelia", data.errors);
     return data.data;
 }
 export default function emelia(rl) {
     rl.setName("emelia");
     rl.setVersion("0.1.0");
+    rl.setCredential(emeliaCredential);
     rl.setConnectionSchema({
         apiKey: {
             type: "string",
@@ -29,7 +26,6 @@ export default function emelia(rl) {
             env: "EMELIA_API_KEY",
         },
     });
-    const key = (ctx) => ctx.connection.config.apiKey;
     // ── Campaign ────────────────────────────────────────
     rl.registerAction("campaign.create", {
         access: "write",
@@ -38,7 +34,7 @@ export default function emelia(rl) {
             name: { type: "string", required: true, description: "Campaign name" },
         },
         async execute(input, ctx) {
-            const data = await gql(key(ctx), `
+            const data = await gql(ctx, `
         mutation createCampaign($name: String!) {
           createCampaign(name: $name) { _id name status createdAt provider startAt estimatedEnd }
         }`, { name: input.name });
@@ -56,7 +52,7 @@ export default function emelia(rl) {
             },
         },
         async execute(input, ctx) {
-            const data = await gql(key(ctx), `
+            const data = await gql(ctx, `
         query campaign($id: ID!) {
           campaign(id: $id) {
             _id name status createdAt provider startAt estimatedEnd
@@ -75,7 +71,7 @@ export default function emelia(rl) {
         },
         async execute(input, ctx) {
             const { limit } = (input ?? {});
-            const data = await gql(key(ctx), `
+            const data = await gql(ctx, `
         query all_campaigns {
           all_campaigns {
             _id name status createdAt
@@ -115,7 +111,7 @@ export default function emelia(rl) {
                 contact.lastName = lastName;
             if (customFields)
                 Object.assign(contact, customFields);
-            const data = await gql(key(ctx), `
+            const data = await gql(ctx, `
         mutation AddContactToCampaignHook($id: ID!, $contact: JSON!) {
           addContactToCampaignHook(id: $id, contact: $contact)
         }`, { id: campaignId, contact });
@@ -133,7 +129,7 @@ export default function emelia(rl) {
             },
         },
         async execute(input, ctx) {
-            await gql(key(ctx), `mutation startCampaign($id: ID!) { startCampaign(id: $id) }`, { id: input.campaignId });
+            await gql(ctx, `mutation startCampaign($id: ID!) { startCampaign(id: $id) }`, { id: input.campaignId });
             return { success: true };
         },
     });
@@ -148,7 +144,7 @@ export default function emelia(rl) {
             },
         },
         async execute(input, ctx) {
-            await gql(key(ctx), `mutation pauseCampaign($id: ID!) { pauseCampaign(id: $id) }`, { id: input.campaignId });
+            await gql(ctx, `mutation pauseCampaign($id: ID!) { pauseCampaign(id: $id) }`, { id: input.campaignId });
             return { success: true };
         },
     });
@@ -189,7 +185,7 @@ export default function emelia(rl) {
         },
         async execute(input, ctx) {
             const { campaignId, name, copySettings = true, copyMails = true, copyContacts = false, copyProvider = true, } = input;
-            const data = await gql(key(ctx), `
+            const data = await gql(ctx, `
         mutation duplicateCampaign($fromId: ID!, $name: String!, $copySettings: Boolean!, $copyMails: Boolean!, $copyContacts: Boolean!, $copyProvider: Boolean!) {
           duplicateCampaign(fromId: $fromId, name: $name, copySettings: $copySettings, copyMails: $copyMails, copyContacts: $copyContacts, copyProvider: $copyProvider)
         }`, {
@@ -212,7 +208,7 @@ export default function emelia(rl) {
         },
         async execute(input, ctx) {
             const { limit } = (input ?? {});
-            const data = await gql(key(ctx), `
+            const data = await gql(ctx, `
         query contact_lists {
           contact_lists { _id name contactCount fields usedInCampaign }
         }`);
@@ -249,7 +245,7 @@ export default function emelia(rl) {
                 contact.lastName = lastName;
             if (customFields)
                 Object.assign(contact, customFields);
-            const data = await gql(key(ctx), `
+            const data = await gql(ctx, `
         mutation AddContactsToListHook($id: ID!, $contact: JSON!) {
           addContactsToListHook(id: $id, contact: $contact)
         }`, { id: contactListId, contact });

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

@@ -0,0 +1,27 @@
+import { httpsBase, staticCredential } from "../../_shared/credentials.js";
+/**
+ * The API key and secret joined as `token {apiKey}:{apiSecret}` in the
+ * Authorization header, on the configured instance's own /api/ base. The
+ * host is public config and must be HTTPS.
+ */
+export const erpnextCredential = staticCredential({
+    id: "erpnext",
+    auth: { kind: "apiKey", header: "Authorization", prefix: "token " },
+    local: {
+        secret: {
+            concat: [{ field: "apiKey" }, { value: ":" }, { field: "apiSecret" }],
+        },
+    },
+    targets: (config) => ({
+        api: {
+            baseUrl: httpsBase(config.host, "api/"),
+            methods: ["GET", "POST", "PUT", "DELETE"],
+        },
+    }),
+    probe: {
+        target: "api",
+        path: "method/frappe.auth.get_logged_user",
+        method: "GET",
+        acceptedStatuses: [200],
+    },
+});