@rnsk/toolkits 0.0.6 → 0.0.7

package/dist/toolkits/grafana/tools/index.js

@@ -0,0 +1,93 @@
+// @ts-nocheck
+import { createOtlpV1Logs } from './create-otlp-v1-logs.js';
+import { getDistributorHaTracker } from './get-distributor-ha-tracker.js';
+import { getHealth } from './get-health.js';
+import { getIndexGatewayRing } from './get-index-gateway-ring.js';
+import { getOverridesExporterRing } from './get-overrides-exporter-ring.js';
+import { getRulerRing } from './get-ruler-ring.js';
+import { getStatus } from './get-status.js';
+import { getStoreGatewayTenants } from './get-store-gateway-tenants.js';
+import { postAcs } from './post-acs.js';
+import { queryPublicDashboard } from './query-public-dashboard.js';
+import { retrieveJwks } from './retrieve-jwks.js';
+export { createOtlpV1Logs, getDistributorHaTracker, getHealth, getIndexGatewayRing, getOverridesExporterRing, getRulerRing, getStatus, getStoreGatewayTenants, postAcs, queryPublicDashboard, retrieveJwks, };
+export const grafanaTools = [
+    {
+        name: 'grafanaCreateOtlpV1Logs',
+        description: 'Send OpenTelemetry Protocol (OTLP) v1 logs to Grafana Loki for ingestion and storage.',
+        tool: createOtlpV1Logs,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'write',
+    },
+    {
+        name: 'grafanaGetDistributorHaTracker',
+        description: 'Retrieve distributor HA tracker status showing which replica is elected leader for each Prometheus HA cluster.',
+        tool: getDistributorHaTracker,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaGetHealth',
+        description: 'Check Grafana server health and database connectivity. Returns ok if the web server is running and can access the database.',
+        tool: getHealth,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaGetIndexGatewayRing',
+        description: 'Retrieve index gateway hash ring status including state, health, and last heartbeat of each node.',
+        tool: getIndexGatewayRing,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaGetOverridesExporterRing',
+        description: 'Retrieve overrides-exporter hash ring status including state, health, and last heartbeat of each node.',
+        tool: getOverridesExporterRing,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaGetRulerRing',
+        description: 'Retrieve ruler hash ring status including state, health, and last heartbeat of each ruler node.',
+        tool: getRulerRing,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaGetStatus',
+        description: 'Check if a valid Grafana Enterprise license is available on the instance.',
+        tool: getStatus,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaGetStoreGatewayTenants',
+        description: 'Retrieve store gateway tenants that have blocks stored in the configured storage.',
+        tool: getStoreGatewayTenants,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaPostAcs',
+        description: 'Perform SAML Assertion Consumer Service (ACS) operation when processing authentication responses from an identity provider.',
+        tool: postAcs,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'write',
+    },
+    {
+        name: 'grafanaQueryPublicDashboard',
+        description: 'Query a panel on a public Grafana dashboard to retrieve time-series data and metrics for a specified time range.',
+        tool: queryPublicDashboard,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaRetrieveJwks',
+        description: 'Retrieve JSON Web Key Set (JWKS) with all public keys that can be used to verify JWT tokens.',
+        tool: retrieveJwks,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/grafana/tools/post-acs.d.ts

@@ -0,0 +1,16 @@
+export declare const postAcs: import("ai").Tool<{
+    grafanaCredentials: string;
+    samlResponse: string;
+    relayState?: string | undefined;
+}, {
+    statusCode: number;
+    message: string;
+    location: string;
+    error?: undefined;
+} | {
+    error: string;
+    message: string;
+    statusCode?: undefined;
+    location?: undefined;
+}>;
+//# sourceMappingURL=post-acs.d.ts.map

package/dist/toolkits/grafana/tools/post-acs.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { grafanaRequest } from './utils.js';
+export const postAcs = tool({
+    description: 'Perform SAML Assertion Consumer Service (ACS) operation when processing authentication responses from an identity provider.',
+    inputSchema: z.object({
+        grafanaCredentials: z.string().describe('Grafana credentials JSON with baseUrl'),
+        samlResponse: z
+            .string()
+            .describe('Base64-encoded SAML Response from the Identity Provider'),
+        relayState: z
+            .string()
+            .optional()
+            .describe('Optional relay state parameter for the SAML authentication flow'),
+    }),
+    execute: async ({ grafanaCredentials, samlResponse, relayState }) => {
+        try {
+            const params = new URLSearchParams({ SAMLResponse: samlResponse });
+            if (relayState) {
+                params.set('RelayState', relayState);
+            }
+            const result = await grafanaRequest(grafanaCredentials, '/login/saml/acs', {
+                method: 'POST',
+                body: params.toString(),
+                contentType: 'application/x-www-form-urlencoded',
+            });
+            return {
+                statusCode: result.status,
+                message: result.status === 302
+                    ? 'SAML ACS processed successfully with redirect'
+                    : 'SAML ACS request completed',
+                location: result.headers?.location ?? result.headers?.Location,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error performing SAML ACS operation',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=post-acs.js.map

package/dist/toolkits/grafana/tools/query-public-dashboard.d.ts

@@ -0,0 +1,29 @@
+export declare const queryPublicDashboard: import("ai").Tool<{
+    from: string;
+    to: string;
+    grafanaCredentials: string;
+    accessToken: string;
+    panelId: number;
+    intervalMs?: number | undefined;
+    maxDataPoints?: number | undefined;
+    baseUrlOverride?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    statusCode: number;
+    results?: undefined;
+    message?: undefined;
+} | {
+    statusCode: number;
+    results: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+    results?: undefined;
+}>;
+//# sourceMappingURL=query-public-dashboard.d.ts.map

package/dist/toolkits/grafana/tools/query-public-dashboard.js

@@ -0,0 +1,70 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { grafanaRequest } from './utils.js';
+export const queryPublicDashboard = tool({
+    description: 'Query a panel on a public Grafana dashboard to retrieve time-series data and metrics for a specified time range.',
+    inputSchema: z.object({
+        grafanaCredentials: z.string().describe('Grafana credentials JSON with baseUrl'),
+        accessToken: z.string().describe('Public dashboard access token'),
+        panelId: z.number().int().min(1).describe('Panel ID to query within the dashboard'),
+        from: z
+            .string()
+            .describe("Start time for the query, e.g. 'now-6h' or an epoch millisecond timestamp"),
+        to: z
+            .string()
+            .describe("End time for the query, e.g. 'now' or an epoch millisecond timestamp"),
+        intervalMs: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe('Time interval between data points in milliseconds'),
+        maxDataPoints: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe('Maximum number of data points to return'),
+        baseUrlOverride: z
+            .string()
+            .optional()
+            .describe('Optional base URL override for the Grafana instance hosting the public dashboard'),
+    }),
+    execute: async ({ grafanaCredentials, accessToken, panelId, from, to, intervalMs, maxDataPoints, baseUrlOverride, }) => {
+        try {
+            const body = {
+                timeRange: { from, to },
+            };
+            if (intervalMs !== undefined)
+                body.intervalMs = intervalMs;
+            if (maxDataPoints !== undefined)
+                body.maxDataPoints = maxDataPoints;
+            const result = await grafanaRequest(grafanaCredentials, `/api/public/dashboards/${accessToken}/panels/${panelId}/query`, {
+                method: 'POST',
+                body,
+                contentType: 'application/json',
+                acceptJson: true,
+                baseUrlOverride,
+            });
+            if (!result.ok) {
+                return {
+                    error: 'Failed to query public dashboard panel',
+                    details: result.data,
+                    statusCode: result.status,
+                };
+            }
+            return {
+                statusCode: result.status,
+                results: result.data?.results ?? result.data,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error querying public dashboard panel',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=query-public-dashboard.js.map

package/dist/toolkits/grafana/tools/retrieve-jwks.d.ts

@@ -0,0 +1,4 @@
+export declare const retrieveJwks: import("ai").Tool<{
+    grafanaCredentials: string;
+}, any>;
+//# sourceMappingURL=retrieve-jwks.d.ts.map

package/dist/toolkits/grafana/tools/retrieve-jwks.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { grafanaRequest } from './utils.js';
+export const retrieveJwks = tool({
+    description: 'Retrieve JSON Web Key Set (JWKS) with all public keys that can be used to verify JWT tokens.',
+    inputSchema: z.object({
+        grafanaCredentials: z.string().describe('Grafana credentials JSON with baseUrl'),
+    }),
+    execute: async ({ grafanaCredentials }) => {
+        try {
+            const result = await grafanaRequest(grafanaCredentials, '/api/signing-keys/keys', {
+                acceptJson: true,
+            });
+            if (!result.ok) {
+                return {
+                    error: 'Failed to retrieve JWKS',
+                    details: result.data,
+                    statusCode: result.status,
+                };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error retrieving JWKS',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=retrieve-jwks.js.map

package/dist/toolkits/grafana/tools/utils.d.ts

@@ -0,0 +1,21 @@
+export interface GrafanaCredentials {
+    baseUrl: string;
+    apiToken?: string;
+}
+export declare function parseGrafanaCredentials(grafanaCredentials: string): GrafanaCredentials;
+export declare function grafanaRequest(grafanaCredentials: string, path: string, options?: {
+    method?: string;
+    body?: unknown;
+    contentType?: string;
+    acceptJson?: boolean;
+    baseUrlOverride?: string;
+}): Promise<{
+    ok: boolean;
+    status: number;
+    data: any;
+    contentType: string;
+    headers: {
+        [k: string]: string;
+    };
+}>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/toolkits/grafana/tools/utils.js

@@ -0,0 +1,48 @@
+// @ts-nocheck
+export function parseGrafanaCredentials(grafanaCredentials) {
+    const parsed = JSON.parse(grafanaCredentials);
+    if (!parsed.baseUrl) {
+        throw new Error('Grafana credentials must include baseUrl');
+    }
+    return {
+        baseUrl: parsed.baseUrl.replace(/\/+$/, ''),
+        apiToken: parsed.apiToken,
+    };
+}
+function buildHeaders(credentials, options) {
+    const headers = {};
+    if (options?.contentType) {
+        headers['Content-Type'] = options.contentType;
+    }
+    if (options?.acceptJson) {
+        headers.Accept = 'application/json';
+    }
+    if (credentials.apiToken) {
+        headers.Authorization = `Bearer ${credentials.apiToken}`;
+    }
+    return headers;
+}
+export async function grafanaRequest(grafanaCredentials, path, options) {
+    const credentials = parseGrafanaCredentials(grafanaCredentials);
+    const baseUrl = (options?.baseUrlOverride ?? credentials.baseUrl).replace(/\/+$/, '');
+    const url = `${baseUrl}${path.startsWith('/') ? path : `/${path}`}`;
+    const fetchOptions = {
+        method: options?.method ?? 'GET',
+        headers: buildHeaders(credentials, options),
+        redirect: 'manual',
+    };
+    if (options?.body !== undefined) {
+        fetchOptions.body =
+            typeof options.body === 'string' ? options.body : JSON.stringify(options.body);
+    }
+    const response = await fetch(url, fetchOptions);
+    const contentType = response.headers.get('content-type') ?? '';
+    const headers = Object.fromEntries(response.headers.entries());
+    if (contentType.includes('application/json')) {
+        const data = await response.json().catch(() => null);
+        return { ok: response.ok, status: response.status, data, contentType, headers };
+    }
+    const text = await response.text();
+    return { ok: response.ok, status: response.status, data: text, contentType, headers };
+}
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rnsk/toolkits",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Runstack toolkit registry — manifest-driven tool definitions for AI agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -53,6 +53,7 @@
     "type": "git",
     "url": "https://github.com/deepraj21/rnsk-toolkits"
   },
+  "license": "MIT",
   "homepage": "https://runstack.engineer",
   "keywords": [
     "runstack",