@blogic-cz/agent-tools 0.10.0 → 0.11.0

package/src/grafana-tool/datasources.ts

@@ -0,0 +1,72 @@
+import { Console, Effect } from "effect";
+import { Command } from "effect/unstable/cli";
+
+import { formatOption, formatOutput } from "#shared";
+
+import {
+  envOption,
+  formatGrafanaError,
+  grafanaFetch,
+  profileOption,
+  resolveConfig,
+} from "./shared";
+
+type Datasource = {
+  id: number;
+  uid: string;
+  name: string;
+  type: string;
+  url: string;
+  isDefault: boolean;
+};
+
+const listCommand = Command.make(
+  "list",
+  { format: formatOption, env: envOption, profile: profileOption },
+  ({ format, env, profile }) => {
+    const start = Date.now();
+
+    return Effect.gen(function* () {
+      const config = yield* resolveConfig(env, profile);
+
+      const items = yield* grafanaFetch<Datasource[]>(config, "/api/datasources");
+
+      const result = {
+        success: true,
+        message: `Found ${items.length} datasource(s)`,
+        data: {
+          datasources: items.map((item) => ({
+            uid: item.uid,
+            name: item.name,
+            type: item.type,
+            url: item.url,
+            isDefault: item.isDefault,
+          })),
+          count: items.length,
+        },
+        executionTimeMs: Date.now() - start,
+      };
+
+      yield* Console.log(formatOutput(result, format));
+    }).pipe(
+      Effect.catch((error) =>
+        Effect.gen(function* () {
+          const result = {
+            success: false,
+            message: "Failed to list datasources",
+            error: formatGrafanaError(error),
+            hint: "Check Grafana is running and accessible",
+            executionTimeMs: Date.now() - start,
+          };
+
+          yield* Console.log(formatOutput(result, format));
+        }),
+      ),
+    );
+  },
+).pipe(Command.withDescription("List configured datasources"));
+
+export const datasourcesCommand = Command.make("datasources", {}).pipe(
+  Command.withDescription("Datasource operations"),
+  Command.withSubcommands([listCommand]),
+);

package/src/grafana-tool/errors.ts

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+
+export class GrafanaToolError extends Schema.TaggedErrorClass<GrafanaToolError>()(
+  "GrafanaToolError",
+  {
+    cause: Schema.Unknown,
+  },
+) {}

package/src/grafana-tool/health.ts

@@ -0,0 +1,57 @@
+import { Console, Effect } from "effect";
+import { Command } from "effect/unstable/cli";
+
+import { formatOption, formatOutput } from "#shared";
+
+import {
+  envOption,
+  formatGrafanaError,
+  grafanaFetch,
+  profileOption,
+  resolveConfig,
+} from "./shared";
+
+export const healthCommand = Command.make(
+  "health",
+  { format: formatOption, env: envOption, profile: profileOption },
+  ({ format, env, profile }) => {
+    const start = Date.now();
+
+    return Effect.gen(function* () {
+      const config = yield* resolveConfig(env, profile);
+
+      const body = yield* grafanaFetch<{ database?: string; version?: string; commit?: string }>(
+        config,
+        "/api/health",
+      );
+
+      const result = {
+        success: true,
+        message: `Grafana is healthy (${config.url})`,
+        data: {
+          url: config.url,
+          httpStatus: 200,
+          response: body,
+          env,
+        },
+        executionTimeMs: Date.now() - start,
+      };
+
+      yield* Console.log(formatOutput(result, format));
+    }).pipe(
+      Effect.catch((error) =>
+        Effect.gen(function* () {
+          const result = {
+            success: false,
+            message: "Grafana is unreachable",
+            error: formatGrafanaError(error),
+            hint: "Check Grafana is running and accessible",
+            executionTimeMs: Date.now() - start,
+          };
+
+          yield* Console.log(formatOutput(result, format));
+        }),
+      ),
+    );
+  },
+).pipe(Command.withDescription("Check Grafana health and connectivity"));

package/src/grafana-tool/index.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env bun
+
+import { BunRuntime, BunServices } from "@effect/platform-bun";
+import { Console, Effect, Layer } from "effect";
+import type { Cause } from "effect";
+import { Command } from "effect/unstable/cli";
+
+import { ConfigServiceLayer } from "#config";
+import { AuditServiceLayer, withAudit } from "#shared/audit";
+import { VERSION } from "#shared";
+
+import { alertsCommand } from "./alerts";
+import { dashboardsCommand } from "./dashboards";
+import { datasourcesCommand } from "./datasources";
+import { healthCommand } from "./health";
+import { logsCommand } from "./logs";
+import { metricsCommand } from "./metrics";
+
+const renderCauseToStderr = (cause: Cause.Cause<unknown>) => Console.error(cause.toString());
+
+const mainCommand = Command.make("grafana-tool", {}).pipe(
+  Command.withDescription("Grafana queries — dashboards, alerts, Prometheus metrics, Loki logs"),
+  Command.withSubcommands([
+    healthCommand,
+    dashboardsCommand,
+    alertsCommand,
+    datasourcesCommand,
+    metricsCommand,
+    logsCommand,
+  ]),
+);
+
+const cli = Command.run(mainCommand, { version: VERSION });
+
+const MainLayer = Layer.mergeAll(BunServices.layer, ConfigServiceLayer, AuditServiceLayer);
+
+const program = withAudit("grafana", cli).pipe(
+  Effect.provide(MainLayer),
+  Effect.tapCause(renderCauseToStderr),
+);
+
+BunRuntime.runMain(program, { disableErrorReporting: true });

package/src/grafana-tool/logs.ts

@@ -0,0 +1,124 @@
+import { Console, Effect } from "effect";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import { formatOption, formatOutput } from "#shared";
+
+import { GrafanaToolError } from "./errors";
+import {
+  envOption,
+  formatGrafanaError,
+  grafanaDsQuery,
+  profileOption,
+  resolveConfig,
+} from "./shared";
+
+function parseLabel(value: string | Record<string, string>): Record<string, string> {
+  if (typeof value === "object" && value !== null) {
+    return value;
+  }
+
+  try {
+    return JSON.parse(value) as Record<string, string>;
+  } catch {
+    return {};
+  }
+}
+
+const queryCommand = Command.make(
+  "query",
+  {
+    logql: Argument.string("logql"),
+    format: formatOption,
+    env: envOption,
+    profile: profileOption,
+    limit: Flag.integer("limit").pipe(
+      Flag.withDescription("Max log lines (default: 100)"),
+      Flag.withDefault(100),
+    ),
+    start: Flag.string("start").pipe(
+      Flag.withDescription("Start time (default: now-1h)"),
+      Flag.withDefault("now-1h"),
+    ),
+    end: Flag.string("end").pipe(
+      Flag.withDescription("End time (default: now)"),
+      Flag.withDefault("now"),
+    ),
+  },
+  ({ logql, format, env, profile, limit, start, end }) => {
+    const startedAt = Date.now();
+
+    return Effect.gen(function* () {
+      const config = yield* resolveConfig(env, profile);
+      const response = yield* grafanaDsQuery(config, config.lokiUid, "loki", logql, {
+        from: start,
+        to: end,
+        maxLines: limit,
+      });
+
+      if (response.results.A.error) {
+        return yield* new GrafanaToolError({
+          cause: new Error(response.results.A.error),
+        });
+      }
+
+      const logs: Array<{ timestamp: string; line: string; labels: Record<string, string> }> = [];
+      for (const frame of response.results.A.frames ?? []) {
+        const fields = frame.schema.fields;
+        const values = frame.data.values;
+        const timeIndex = fields.findIndex(
+          (field) => field.name === "timestamp" || field.type === "time",
+        );
+        const lineIndex = fields.findIndex(
+          (field) => field.name === "body" || field.name === "Line" || field.name === "line",
+        );
+        const labelsIndex = fields.findIndex(
+          (field) => field.name === "labels" || field.name === "labelTypes",
+        );
+
+        const timestamps = (timeIndex >= 0 ? values[timeIndex] : []) as Array<string | number>;
+        const lines = (lineIndex >= 0 ? values[lineIndex] : []) as string[];
+        const labelValues = (labelsIndex >= 0 ? values[labelsIndex] : []) as Array<
+          string | Record<string, string>
+        >;
+
+        for (const [index, line] of lines.entries()) {
+          logs.push({
+            timestamp: String(timestamps[index] ?? ""),
+            line,
+            labels: labelValues[index] ? parseLabel(labelValues[index]) : {},
+          });
+        }
+      }
+
+      logs.sort((left, right) => (left.timestamp > right.timestamp ? -1 : 1));
+
+      const result = {
+        success: true,
+        message: `LogQL query returned ${logs.length} log line(s)`,
+        data: { logs, query: logql, logCount: logs.length },
+        executionTimeMs: Date.now() - startedAt,
+      };
+
+      yield* Console.log(formatOutput(result, format));
+    }).pipe(
+      Effect.catch((error) =>
+        Effect.gen(function* () {
+          const result = {
+            success: false,
+            message: "Failed to execute LogQL query",
+            error: formatGrafanaError(error),
+            hint: "Check LogQL syntax and Grafana/Loki connectivity",
+            executionTimeMs: Date.now() - startedAt,
+          };
+
+          yield* Console.log(formatOutput(result, format));
+        }),
+      ),
+    );
+  },
+).pipe(Command.withDescription("Query logs via Grafana/Loki"));
+
+export const logsCommand = Command.make("logs", {}).pipe(
+  Command.withDescription("Loki log operations"),
+  Command.withSubcommands([queryCommand]),
+);

package/src/grafana-tool/metrics.ts

@@ -0,0 +1,217 @@
+import { Console, Effect } from "effect";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+
+import { formatOption, formatOutput } from "#shared";
+
+import { GrafanaToolError } from "./errors";
+import {
+  envOption,
+  formatGrafanaError,
+  grafanaDsQuery,
+  profileOption,
+  resolveConfig,
+} from "./shared";
+import type { DsQueryResponse } from "./types";
+
+function parsePrometheusFrames(frames: DsQueryResponse["results"]["A"]["frames"]) {
+  if (!frames || frames.length === 0) {
+    return [] as Array<{ metric: Record<string, string>; value: number; timestamp: number }>;
+  }
+
+  const results: Array<{ metric: Record<string, string>; value: number; timestamp: number }> = [];
+
+  for (const frame of frames) {
+    const fields = frame.schema.fields;
+    const values = frame.data.values;
+    const timeIndex = fields.findIndex((field) => field.type === "time");
+    const valueIndex = fields.findIndex((field) => field.type === "number");
+
+    if (timeIndex < 0 || valueIndex < 0) {
+      continue;
+    }
+
+    const labelFields = fields.filter((field) => field.type === "string");
+    const timestamps = values[timeIndex] as number[];
+    const seriesValues = values[valueIndex] as number[];
+
+    for (const [index, timestamp] of timestamps.entries()) {
+      const metric: Record<string, string> = {};
+      for (const labelField of labelFields) {
+        const labelIndex = fields.indexOf(labelField);
+        const labels = values[labelIndex] as string[];
+        if (labels[index]) {
+          metric[labelField.name] = labels[index];
+        }
+      }
+
+      results.push({
+        metric,
+        value: seriesValues[index] ?? 0,
+        timestamp,
+      });
+    }
+  }
+
+  return results;
+}
+
+function extractLabelsFromFrame(
+  frame: NonNullable<DsQueryResponse["results"]["A"]["frames"]>[number],
+) {
+  const labels: Record<string, string> = {};
+  for (const [index, field] of frame.schema.fields.entries()) {
+    if (field.type !== "string") {
+      continue;
+    }
+
+    const values = frame.data.values[index] as string[];
+    if (values[0]) {
+      labels[field.name] = values[0];
+    }
+  }
+  return labels;
+}
+
+const queryCommand = Command.make(
+  "query",
+  {
+    promql: Argument.string("promql"),
+    format: formatOption,
+    env: envOption,
+    profile: profileOption,
+  },
+  ({ promql, format, env, profile }) => {
+    const startedAt = Date.now();
+
+    return Effect.gen(function* () {
+      const config = yield* resolveConfig(env, profile);
+      const response = yield* grafanaDsQuery(config, config.prometheusUid, "prometheus", promql, {
+        instant: true,
+        maxDataPoints: 1,
+      });
+
+      if (response.results.A.error) {
+        return yield* new GrafanaToolError({
+          cause: new Error(response.results.A.error),
+        });
+      }
+
+      const parsed = parsePrometheusFrames(response.results.A.frames);
+      const result = {
+        success: true,
+        message: `PromQL query returned ${parsed.length} result(s)`,
+        data: {
+          results: parsed,
+          query: promql,
+          resultCount: parsed.length,
+        },
+        executionTimeMs: Date.now() - startedAt,
+      };
+
+      yield* Console.log(formatOutput(result, format));
+    }).pipe(
+      Effect.catch((error) =>
+        Effect.gen(function* () {
+          const result = {
+            success: false,
+            message: "Failed to execute PromQL query",
+            error: formatGrafanaError(error),
+            hint: "Check PromQL syntax and Grafana/Prometheus connectivity",
+            executionTimeMs: Date.now() - startedAt,
+          };
+          yield* Console.log(formatOutput(result, format));
+        }),
+      ),
+    );
+  },
+).pipe(Command.withDescription("Execute instant PromQL query via Grafana"));
+
+const rangeCommand = Command.make(
+  "range",
+  {
+    promql: Argument.string("promql"),
+    format: formatOption,
+    env: envOption,
+    profile: profileOption,
+    start: Flag.string("start").pipe(
+      Flag.withDescription("Start time (ISO 8601 or relative, e.g. now-1h)"),
+      Flag.withDefault("now-1h"),
+    ),
+    end: Flag.string("end").pipe(
+      Flag.withDescription("End time (ISO 8601 or relative, e.g. now)"),
+      Flag.withDefault("now"),
+    ),
+    step: Flag.integer("step").pipe(
+      Flag.withDescription("Step in seconds (default: 60)"),
+      Flag.withDefault(60),
+    ),
+  },
+  ({ promql, format, env, profile, start, end, step }) => {
+    const startedAt = Date.now();
+
+    return Effect.gen(function* () {
+      const config = yield* resolveConfig(env, profile);
+      const response = yield* grafanaDsQuery(config, config.prometheusUid, "prometheus", promql, {
+        instant: false,
+        from: start,
+        to: end,
+        step,
+      });
+
+      if (response.results.A.error) {
+        return yield* new GrafanaToolError({
+          cause: new Error(response.results.A.error),
+        });
+      }
+
+      const series = (response.results.A.frames ?? []).map((frame) => {
+        const timeIndex = frame.schema.fields.findIndex((field) => field.type === "time");
+        const valueIndex = frame.schema.fields.findIndex((field) => field.type === "number");
+        const timestamps = (timeIndex >= 0 ? frame.data.values[timeIndex] : []) as number[];
+        const values = (valueIndex >= 0 ? frame.data.values[valueIndex] : []) as number[];
+
+        return {
+          labels: extractLabelsFromFrame(frame),
+          values: timestamps.map((timestamp, index) => ({
+            timestamp,
+            value: values[index] ?? 0,
+          })),
+        };
+      });
+
+      const result = {
+        success: true,
+        message: `PromQL range query returned ${series.length} series`,
+        data: {
+          series,
+          query: promql,
+          start,
+          end,
+          step,
+          seriesCount: series.length,
+        },
+        executionTimeMs: Date.now() - startedAt,
+      };
+
+      yield* Console.log(formatOutput(result, format));
+    }).pipe(
+      Effect.catch((error) =>
+        Effect.gen(function* () {
+          const result = {
+            success: false,
+            message: "Failed to execute PromQL range query",
+            error: formatGrafanaError(error),
+            hint: "Check PromQL syntax and Grafana/Prometheus connectivity",
+            executionTimeMs: Date.now() - startedAt,
+          };
+          yield* Console.log(formatOutput(result, format));
+        }),
+      ),
+    );
+  },
+).pipe(Command.withDescription("Execute range PromQL query via Grafana"));
+
+export const metricsCommand = Command.make("metrics", {}).pipe(
+  Command.withDescription("Prometheus metric operations via Grafana"),
+  Command.withSubcommands([queryCommand, rangeCommand]),
+);