@rnsk/toolkits 0.0.10 → 0.0.12

package/dist/toolkits/postman/tools/webhooks.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { postmanRequest, toPostmanError } from './client.js';
+const authField = {
+    postmanApiKey: z.string().optional().describe('Injected by system; do not provide'),
+};
+function missingKey() {
+    return { error: 'Postman API key is required. Connect Postman first.' };
+}
+export const postmanCreateAWebhook = tool({
+    description: 'Create a webhook that triggers a collection with a custom payload. Use when you need to set up a webhook endpoint that can trigger a Postman collection run. The webhook URL is available in the webhookUrl property of the response.',
+    inputSchema: z.object({
+        ...authField,
+        workspaceId: z.string().describe('The workspace ID where the webhook will be created'),
+        name: z.string().describe('Name of the webhook to be created'),
+        collectionId: z.string().describe('Collection UID (owner-collectionId format) that will be triggered by the webhook'),
+        environmentId: z.string().optional().describe('Optional environment UID to use when the webhook triggers the collection'),
+    }),
+    execute: async ({ postmanApiKey, workspaceId, name, collectionId, environmentId }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'POST', '/webhooks', {
+                query: { workspace: workspaceId },
+                body: {
+                    webhook: {
+                        name,
+                        collection: collectionId,
+                        ...(environmentId !== undefined ? { environment: environmentId } : {}),
+                    },
+                },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to create webhook');
+        }
+    },
+});
+//# sourceMappingURL=webhooks.js.map

package/dist/toolkits/postman/tools/workspaces.d.ts

@@ -0,0 +1,50 @@
+export declare const postmanCreateAWorkspace: import("ai").Tool<{
+    type: "private" | "team" | "public" | "personal";
+    name: string;
+    description?: string | undefined;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanGetAllWorkspaces: import("ai").Tool<{
+    type?: "team" | "public" | "personal" | undefined;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanGetWorkspaceDetails: import("ai").Tool<{
+    workspaceId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanUpdateAWorkspace: import("ai").Tool<{
+    type: "private" | "team" | "public" | "personal";
+    workspaceId: string;
+    description?: string | undefined;
+    name?: string | undefined;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanDeleteAWorkspace: import("ai").Tool<{
+    workspaceId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanGetWorkspaceActivityFeed: import("ai").Tool<{
+    workspaceId: string;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanGetWorkspaceRoles: import("ai").Tool<{
+    workspaceId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanGetWorkspaceGlobalVariables: import("ai").Tool<{
+    workspaceId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+export declare const postmanUpdateWorkspaceGlobalVariables: import("ai").Tool<{
+    values: {
+        value: string;
+        key: string;
+        type?: string | undefined;
+        enabled?: boolean | undefined;
+    }[];
+    workspaceId: string;
+    postmanApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=workspaces.d.ts.map

package/dist/toolkits/postman/tools/workspaces.js

@@ -0,0 +1,198 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { postmanRequest, toPostmanError } from './client.js';
+const authField = {
+    postmanApiKey: z.string().optional().describe('Injected by system; do not provide'),
+};
+function missingKey() {
+    return { error: 'Postman API key is required. Connect Postman first.' };
+}
+const workspaceType = z.enum(['personal', 'team', 'private', 'public']).describe('The type of workspace');
+export const postmanCreateAWorkspace = tool({
+    description: 'Create a new workspace in Postman. Use when you need to create a workspace with a specified name, type (personal, team, private, or public), and optional description. Returns the created workspace ID, name, and type.',
+    inputSchema: z.object({
+        ...authField,
+        name: z.string().describe('The name of the workspace to create'),
+        type: workspaceType,
+        description: z.string().optional().describe('A detailed description of the workspace'),
+    }),
+    execute: async ({ postmanApiKey, name, type, description }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'POST', '/workspaces', {
+                body: { workspace: { name, type, ...(description !== undefined ? { description } : {}) } },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to create workspace');
+        }
+    },
+});
+export const postmanGetAllWorkspaces = tool({
+    description: 'Get all workspaces accessible to the authenticated user with optional type filtering. Use when you need to list or retrieve workspaces from Postman. Returns an array of workspace objects with their IDs, names, and types.',
+    inputSchema: z.object({
+        ...authField,
+        type: z.enum(['personal', 'team', 'public']).optional().describe("Filter by workspace type. If not provided, returns all workspaces accessible to the user"),
+    }),
+    execute: async ({ postmanApiKey, type }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', '/workspaces', {
+                query: { type },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get workspaces');
+        }
+    },
+});
+export const postmanGetWorkspaceDetails = tool({
+    description: 'Get detailed information about a specific workspace by its ID. Use when you need to retrieve the complete structure of a workspace including all collections, environments, APIs, mocks, and monitors.',
+    inputSchema: z.object({
+        ...authField,
+        workspaceId: z.string().describe('The unique identifier of the workspace to retrieve'),
+    }),
+    execute: async ({ postmanApiKey, workspaceId }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', `/workspaces/${encodeURIComponent(workspaceId)}`);
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get workspace');
+        }
+    },
+});
+export const postmanUpdateAWorkspace = tool({
+    description: "Update an existing workspace in Postman. Use when you need to modify the name, type, or description of a workspace. The 'type' field is required for all updates.",
+    inputSchema: z.object({
+        ...authField,
+        workspaceId: z.string().describe('The unique identifier of the workspace to update'),
+        name: z.string().optional().describe('The new name of the workspace'),
+        type: workspaceType.describe('The type of the workspace. Required field for updates'),
+        description: z.string().optional().describe('The new description of the workspace'),
+    }),
+    execute: async ({ postmanApiKey, workspaceId, name, type, description }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'PUT', `/workspaces/${encodeURIComponent(workspaceId)}`, {
+                body: {
+                    workspace: {
+                        type,
+                        ...(name !== undefined ? { name } : {}),
+                        ...(description !== undefined ? { description } : {}),
+                    },
+                },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to update workspace');
+        }
+    },
+});
+export const postmanDeleteAWorkspace = tool({
+    description: 'Delete a Postman workspace permanently. Use when you need to remove a workspace and all its contents. Deletion is permanent and cannot be undone.',
+    inputSchema: z.object({
+        ...authField,
+        workspaceId: z.string().describe('The ID of the workspace to delete'),
+    }),
+    execute: async ({ postmanApiKey, workspaceId }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'DELETE', `/workspaces/${encodeURIComponent(workspaceId)}`);
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to delete workspace');
+        }
+    },
+});
+export const postmanGetWorkspaceActivityFeed = tool({
+    description: "Get a workspace's activity feed showing who added or removed collections, environments, or elements, and users joining or leaving. Use when you need to track workspace changes and user activity.",
+    inputSchema: z.object({
+        ...authField,
+        workspaceId: z.string().describe('The ID of the workspace to get the activity feed for'),
+        limit: z.number().int().min(1).optional().describe('The maximum number of activities to return for pagination'),
+        cursor: z.string().optional().describe('Cursor for pagination. Use the nextCursor value from the previous response'),
+    }),
+    execute: async ({ postmanApiKey, workspaceId, limit, cursor }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', `/workspaces/${encodeURIComponent(workspaceId)}/activities`, {
+                query: { limit, cursor },
+            });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get workspace activity feed');
+        }
+    },
+});
+export const postmanGetWorkspaceRoles = tool({
+    description: 'Get the roles of users, user groups, and partners in a workspace. Use when you need to retrieve role assignments and understand who has what level of access to a specific workspace.',
+    inputSchema: z.object({
+        ...authField,
+        workspaceId: z.string().describe('The unique identifier of the workspace to retrieve roles for'),
+    }),
+    execute: async ({ postmanApiKey, workspaceId }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', `/workspaces/${encodeURIComponent(workspaceId)}/roles`);
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get workspace roles');
+        }
+    },
+});
+const globalVariable = z
+    .object({
+    key: z.string().describe('The name/key of the global variable'),
+    value: z.string().describe('The value of the global variable'),
+    type: z.string().optional().describe("The type of the global variable, typically 'default' or 'secret'"),
+    enabled: z.boolean().optional().describe('Whether the global variable is enabled or not'),
+})
+    .describe('Individual global variable');
+export const postmanGetWorkspaceGlobalVariables = tool({
+    description: "Get a workspace's global variables. Use when you need to retrieve global variables that are available throughout a workspace for access between collections, requests, scripts, and environments. Note that this endpoint only works with personal or team workspaces, not public workspaces.",
+    inputSchema: z.object({
+        ...authField,
+        workspaceId: z.string().describe('The unique identifier of the workspace to retrieve global variables from'),
+    }),
+    execute: async ({ postmanApiKey, workspaceId }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'GET', `/workspaces/${encodeURIComponent(workspaceId)}/global-variables`);
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to get workspace global variables');
+        }
+    },
+});
+export const postmanUpdateWorkspaceGlobalVariables = tool({
+    description: "Update and replace a workspace's global variables. Use when you need to set or replace all global variables in a workspace. Note: This endpoint replaces all existing global variables with the provided list.",
+    inputSchema: z.object({
+        ...authField,
+        workspaceId: z.string().describe('The unique identifier of the workspace to update global variables for'),
+        values: z
+            .array(globalVariable)
+            .min(1)
+            .describe('Array of global variable objects to set. This replaces all existing global variables in the workspace'),
+    }),
+    execute: async ({ postmanApiKey, workspaceId, values }) => {
+        try {
+            if (!postmanApiKey)
+                return missingKey();
+            return await postmanRequest(postmanApiKey, 'PUT', `/workspaces/${encodeURIComponent(workspaceId)}/global-variables`, { body: { values } });
+        }
+        catch (error) {
+            return toPostmanError(error, 'Failed to update workspace global variables');
+        }
+    },
+});
+//# sourceMappingURL=workspaces.js.map

package/dist/toolkits/prometheus/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const PROMETHEUS_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map

package/dist/toolkits/prometheus/icon.js

@@ -0,0 +1,52 @@
+const SVG = `<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   version="1.1"
+   id="Layer_1"
+   x="0px"
+   y="0px"
+   width="115.333px"
+   height="114px"
+   viewBox="0 0 115.333 114"
+   enable-background="new 0 0 115.333 114"
+   xml:space="preserve"
+   sodipodi:docname="prometheus_logo_orange.svg"
+   inkscape:version="0.92.1 r15371"><metadata
+     id="metadata4495"><rdf:RDF><cc:Work
+         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
+     id="defs4493" /><sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1484"
+     inkscape:window-height="886"
+     id="namedview4491"
+     showgrid="false"
+     inkscape:zoom="5.2784901"
+     inkscape:cx="60.603667"
+     inkscape:cy="60.329656"
+     inkscape:window-x="54"
+     inkscape:window-y="7"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="Layer_1" /><g
+     id="Layer_2" /><path
+     style="fill:#e6522c;fill-opacity:1"
+     inkscape:connector-curvature="0"
+     id="path4486"
+     d="M 56.667,0.667 C 25.372,0.667 0,26.036 0,57.332 c 0,31.295 25.372,56.666 56.667,56.666 31.295,0 56.666,-25.371 56.666,-56.666 0,-31.296 -25.372,-56.665 -56.666,-56.665 z m 0,106.055 c -8.904,0 -16.123,-5.948 -16.123,-13.283 H 72.79 c 0,7.334 -7.219,13.283 -16.123,13.283 z M 83.297,89.04 H 30.034 V 79.382 H 83.298 V 89.04 Z M 83.106,74.411 H 30.186 C 30.01,74.208 29.83,74.008 29.66,73.802 24.208,67.182 22.924,63.726 21.677,60.204 c -0.021,-0.116 6.611,1.355 11.314,2.413 0,0 2.42,0.56 5.958,1.205 -3.397,-3.982 -5.414,-9.044 -5.414,-14.218 0,-11.359 8.712,-21.285 5.569,-29.308 3.059,0.249 6.331,6.456 6.552,16.161 3.252,-4.494 4.613,-12.701 4.613,-17.733 0,-5.21 3.433,-11.262 6.867,-11.469 -3.061,5.045 0.793,9.37 4.219,20.099 1.285,4.03 1.121,10.812 2.113,15.113 C 63.797,33.534 65.333,20.5 71,16 c -2.5,5.667 0.37,12.758 2.333,16.167 3.167,5.5 5.087,9.667 5.087,17.548 0,5.284 -1.951,10.259 -5.242,14.148 3.742,-0.702 6.326,-1.335 6.326,-1.335 l 12.152,-2.371 c 10e-4,-10e-4 -1.765,7.261 -8.55,14.254 z" /></svg>`;
+export const PROMETHEUS_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/prometheus/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/prometheus/manifest.js

@@ -0,0 +1,32 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { PROMETHEUS_ICON } from './icon.js';
+import { prometheusTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'prometheus',
+    displayName: 'Prometheus',
+    shortDescription: 'Query metrics with PromQL, explore targets and rules, and manage TSDB.',
+    category: 'Developer Tools & DevOps',
+    icon: PROMETHEUS_ICON,
+    auth: {
+        type: 'service_account',
+        tokenField: 'prometheusCredentials',
+        provider: {
+            fields: ['baseUrl', 'username', 'password', 'bearerToken'],
+            connectDescription: 'Connect your Prometheus server with its base URL (e.g. http://localhost:9090). Prometheus has no built-in auth: if your server sits behind a reverse proxy or uses web.config basic_auth_users, also supply username/password (sent as Basic auth); hosted offerings (e.g. Grafana Cloud) use a bearerToken (sent as Authorization: Bearer). Leave auth fields empty for open servers.',
+        },
+    },
+    tools: prometheusTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: {
+        since: '0.0.11',
+        homepage: 'https://prometheus.io',
+        docsUrl: 'https://prometheus.io/docs/prometheus/latest/querying/api/',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/prometheus/tools/admin.d.ts

@@ -0,0 +1,19 @@
+export declare const deleteSeries: import("ai").Tool<{
+    match: string[];
+    prometheusCredentials: string;
+    start?: string | undefined;
+    end?: string | undefined;
+}, any>;
+export declare const cleanTombstones: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+export declare const snapshot: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+export declare const reloadConfig: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+export declare const shutdownServer: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+//# sourceMappingURL=admin.d.ts.map

package/dist/toolkits/prometheus/tools/admin.js

@@ -0,0 +1,90 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { promRequest, toPromError } from './client.js';
+const credsField = z.string().describe('Prometheus credentials JSON with baseUrl and optional username/password or bearerToken');
+export const deleteSeries = tool({
+    description: 'Deletes series matching selectors in a time range (marks tombstones). Requires --enable-feature=admin-api (or web.enable-admin-api). Data is only physically removed after compaction/cleanup.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        match: z.array(z.string()).min(1).describe('Series selectors to delete (at least one required)'),
+        start: z.string().optional().describe('Range start, RFC3339 or unix timestamp'),
+        end: z.string().optional().describe('Range end, RFC3339 or unix timestamp'),
+    }),
+    execute: async ({ prometheusCredentials, match, start, end }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/admin/tsdb/delete_series', {
+                method: 'PUT',
+                query: { 'match[]': match, start, end },
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to delete series');
+        }
+    },
+});
+export const cleanTombstones = tool({
+    description: 'Removes deleted data (tombstones) from disk and cleans up. Requires the admin API flag.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/admin/tsdb/clean_tombstones', {
+                method: 'POST',
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to clean tombstones');
+        }
+    },
+});
+export const snapshot = tool({
+    description: 'Creates a TSDB snapshot for backups. Returns the snapshot directory name. Requires the admin API flag.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/admin/tsdb/snapshot', {
+                method: 'POST',
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to create snapshot');
+        }
+    },
+});
+export const reloadConfig = tool({
+    description: 'Reloads Prometheus configuration and rule files (like SIGHUP). Disabled by default; requires --web.enable-lifecycle.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/-/reload', {
+                method: 'POST',
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to reload config');
+        }
+    },
+});
+export const shutdownServer = tool({
+    description: 'Triggers a graceful shutdown of Prometheus (like SIGTERM). Disabled by default; requires --web.enable-lifecycle. The server stops serving after this call.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/-/quit', {
+                method: 'POST',
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to shut down server');
+        }
+    },
+});
+//# sourceMappingURL=admin.js.map

package/dist/toolkits/prometheus/tools/client.d.ts

@@ -0,0 +1,22 @@
+export interface PrometheusCredentials {
+    baseUrl: string;
+    username?: string;
+    password?: string;
+    bearerToken?: string;
+}
+export declare function parsePrometheusCredentials(prometheusCredentials: string): PrometheusCredentials;
+export declare function promRequest(prometheusCredentials: string, path: string, options?: {
+    method?: string;
+    query?: Record<string, string | number | boolean | string[] | undefined>;
+    acceptNdjson?: boolean;
+}): Promise<any>;
+export declare function toPromError(error: unknown, label: string): {
+    error: string;
+    details: any;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/toolkits/prometheus/tools/client.js

@@ -0,0 +1,91 @@
+// @ts-nocheck
+export function parsePrometheusCredentials(prometheusCredentials) {
+    let parsed;
+    try {
+        parsed = JSON.parse(prometheusCredentials);
+    }
+    catch {
+        throw new Error('Prometheus credentials must be valid JSON with baseUrl and optional auth fields');
+    }
+    if (!parsed.baseUrl) {
+        throw new Error('Prometheus credentials must include baseUrl, e.g. {"baseUrl":"http://localhost:9090"}');
+    }
+    return {
+        baseUrl: parsed.baseUrl.replace(/\/+$/, ''),
+        username: parsed.username,
+        password: parsed.password,
+        bearerToken: parsed.bearerToken,
+    };
+}
+function buildHeaders(credentials) {
+    const headers = { Accept: 'application/json' };
+    if (credentials.bearerToken) {
+        headers.Authorization = `Bearer ${credentials.bearerToken}`;
+    }
+    else if (credentials.username) {
+        headers.Authorization = `Basic ${Buffer.from(`${credentials.username}:${credentials.password ?? ''}`).toString('base64')}`;
+    }
+    return headers;
+}
+function appendQuery(url, query) {
+    if (!query)
+        return;
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            for (const v of value)
+                url.searchParams.append(key, String(v));
+        }
+        else {
+            url.searchParams.set(key, String(value));
+        }
+    }
+}
+export async function promRequest(prometheusCredentials, path, options) {
+    const credentials = parsePrometheusCredentials(prometheusCredentials);
+    const url = new URL(`${credentials.baseUrl}${path.startsWith('/') ? path : `/${path}`}`);
+    appendQuery(url, options?.query);
+    const headers = buildHeaders(credentials);
+    if (options?.acceptNdjson)
+        headers.Accept = 'application/x-ndjson';
+    const response = await fetch(url.toString(), {
+        method: options?.method ?? 'GET',
+        headers,
+    });
+    const contentType = response.headers.get('content-type') ?? '';
+    if (options?.acceptNdjson || contentType.includes('x-ndjson')) {
+        const text = await response.text();
+        if (!response.ok)
+            return { error: 'Prometheus request failed', status: response.status, details: text };
+        return { ndjson: text.split('\n').filter(Boolean).map((line) => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch {
+                    return { raw: line };
+                }
+            }) };
+    }
+    if (!contentType.includes('json')) {
+        const text = await response.text();
+        if (!response.ok)
+            return { error: 'Prometheus request failed', status: response.status, details: text };
+        return { text, contentType };
+    }
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok || data?.status === 'error') {
+        return { error: 'Prometheus request failed', status: response.status, details: data };
+    }
+    return data;
+}
+export function toPromError(error, label) {
+    if (error?.details !== undefined) {
+        return { error: label, details: error.details };
+    }
+    return {
+        error: label.replace('Failed', 'Error').replace('failed', 'error'),
+        message: error instanceof Error ? error.message : 'Unknown error',
+    };
+}
+//# sourceMappingURL=client.js.map