@pagopa/opex-dashboard 0.0.1 → 0.0.2

package/bin/index.js

@@ -0,0 +1,1451 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/cli/index.ts
+import { Command as Command2 } from "commander";
+
+// src/cli/commands/generate.ts
+import { Command } from "commander";
+
+// src/utils/merge.ts
+function overrideWith(source, overrides) {
+  const result = { ...source };
+  for (const [key, value] of Object.entries(overrides)) {
+    if (isPlainObject(value)) {
+      const sourceValue = result[key];
+      result[key] = overrideWith(
+        isPlainObject(sourceValue) ? sourceValue : {},
+        value
+      );
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+
+// src/utils/normalize-endpoints.ts
+function normalizeEndpointKeys(endpoints) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(endpoints)) {
+    const spaceIndex = key.indexOf(" ");
+    if (spaceIndex > 0) {
+      const method = key.substring(0, spaceIndex);
+      const path4 = key.substring(spaceIndex + 1);
+      normalized[path4] = {
+        ...value,
+        method
+      };
+    } else {
+      normalized[key] = value;
+    }
+  }
+  return normalized;
+}
+
+// src/utils/parse-endpoint-key.ts
+function parseEndpointKey(endpoint) {
+  const spaceIndex = endpoint.indexOf(" ");
+  const hasMethod = spaceIndex > 0;
+  if (hasMethod) {
+    return {
+      hasMethod: true,
+      method: endpoint.substring(0, spaceIndex),
+      path: endpoint.substring(spaceIndex + 1)
+    };
+  }
+  return {
+    hasMethod: false,
+    method: "",
+    path: endpoint
+  };
+}
+
+// src/builders/base.ts
+var Builder = class {
+  properties;
+  templateFn;
+  constructor(templateFn, baseProperties) {
+    this.templateFn = templateFn;
+    this.properties = baseProperties;
+  }
+  /**
+   * Package the output into a directory with additional assets.
+   * Default implementation throws error - override in subclasses that support packaging.
+   */
+  package(outputPath, values = {}) {
+    throw new Error(
+      `Packaging not supported for ${this.constructor.name}. Only azure-dashboard template type supports packaging.`
+    );
+  }
+  /**
+   * Render the template by merging base properties and given values.
+   */
+  produce(values = {}) {
+    const context = overrideWith(this.properties, values);
+    return this.templateFn(context);
+  }
+  /**
+   * Get all base properties.
+   */
+  props() {
+    return this.properties;
+  }
+};
+
+// src/builders/azure-dashboard-raw/builder.schema.ts
+import { z as z2 } from "zod";
+
+// src/constants/index.ts
+var DEFAULT_AVAILABILITY_THRESHOLD = 0.99;
+var DEFAULT_RESPONSE_TIME_THRESHOLD = 1;
+var EVALUATION_FREQUENCY_MINUTES = 10;
+var TIME_WINDOW_MINUTES = 20;
+var EVENT_OCCURRENCES = 1;
+
+// src/core/shared/endpoint-properties.schema.ts
+import { z } from "zod";
+var BaseEndpointEvaluationPropertiesSchema = z.object({
+  // Availability monitoring properties
+  availability_evaluation_frequency: z.number(),
+  availability_evaluation_time_window: z.number(),
+  availability_event_occurrences: z.number(),
+  availability_threshold: z.number(),
+  // Response time monitoring properties
+  response_time_evaluation_frequency: z.number(),
+  response_time_evaluation_time_window: z.number(),
+  response_time_event_occurrences: z.number(),
+  response_time_threshold: z.number()
+});
+var EndpointOverridePropertiesSchema = BaseEndpointEvaluationPropertiesSchema.partial().describe(
+  "Optional overrides for endpoint-specific alarm thresholds and evaluation settings"
+);
+var createEndpointConfigPropertiesSchema = (defaults) => z.object({
+  availability_evaluation_frequency: z.number().default(defaults.evaluationFrequency),
+  availability_evaluation_time_window: z.number().default(defaults.evaluationTimeWindow),
+  availability_event_occurrences: z.number().default(defaults.eventOccurrences),
+  availability_threshold: z.number().default(defaults.availabilityThreshold),
+  response_time_evaluation_frequency: z.number().default(defaults.evaluationFrequency),
+  response_time_evaluation_time_window: z.number().default(defaults.evaluationTimeWindow),
+  response_time_event_occurrences: z.number().default(defaults.eventOccurrences),
+  response_time_threshold: z.number().default(defaults.responseTimeThreshold)
+});
+var EndpointContextPropertiesSchema = BaseEndpointEvaluationPropertiesSchema.partial().extend({
+  method: z.string().optional(),
+  path: z.string().optional()
+}).describe("Template context for endpoint-specific properties");
+
+// src/builders/azure-dashboard-raw/builder.schema.ts
+var EndpointConfigSchema = createEndpointConfigPropertiesSchema({
+  availabilityThreshold: DEFAULT_AVAILABILITY_THRESHOLD,
+  evaluationFrequency: EVALUATION_FREQUENCY_MINUTES,
+  evaluationTimeWindow: TIME_WINDOW_MINUTES,
+  eventOccurrences: EVENT_OCCURRENCES,
+  responseTimeThreshold: DEFAULT_RESPONSE_TIME_THRESHOLD
+}).extend({
+  method: z2.string().optional(),
+  path: z2.string().optional()
+});
+var BuilderPropertiesSchema = z2.object({
+  endpoints: z2.record(z2.string(), EndpointConfigSchema).optional(),
+  evaluation_frequency: z2.number(),
+  evaluation_time_window: z2.number(),
+  event_occurrences: z2.number(),
+  hosts: z2.array(z2.string()).optional(),
+  location: z2.string(),
+  name: z2.string(),
+  resource_ids: z2.array(z2.string()),
+  resource_type: z2.enum(["app-gateway", "api-management"]),
+  timespan: z2.string()
+});
+var OA3ServerSchema = z2.object({
+  description: z2.string().optional(),
+  url: z2.string()
+});
+var OA3SpecSchema = z2.object({
+  basePath: z2.string().optional(),
+  // OA2
+  host: z2.string().optional(),
+  // OA2
+  openapi: z2.string().optional(),
+  // OA3
+  paths: z2.record(z2.string(), z2.unknown()),
+  servers: z2.array(OA3ServerSchema).optional(),
+  // OA3
+  swagger: z2.string().optional()
+  // OA2
+});
+
+// src/builders/azure-dashboard-raw/endpoints-extractor.ts
+import * as path from "path";
+
+// src/core/errors/config-error.ts
+var ConfigError = class _ConfigError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+    Object.setPrototypeOf(this, _ConfigError.prototype);
+  }
+};
+
+// src/core/errors/file-error.ts
+var FileError = class _FileError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FileError";
+    Object.setPrototypeOf(this, _FileError.prototype);
+  }
+};
+
+// src/core/errors/invalid-builder-error.ts
+var InvalidBuilderError = class _InvalidBuilderError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidBuilderError";
+    Object.setPrototypeOf(this, _InvalidBuilderError.prototype);
+  }
+};
+
+// src/core/errors/parse-error.ts
+var ParseError = class _ParseError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ParseError";
+    Object.setPrototypeOf(this, _ParseError.prototype);
+  }
+};
+
+// src/builders/azure-dashboard-raw/endpoints-extractor.ts
+var VALID_HTTP_METHODS = /* @__PURE__ */ new Set([
+  "delete",
+  "get",
+  "head",
+  "options",
+  "patch",
+  "post",
+  "put",
+  "trace"
+]);
+function extractEndpoints(oa3Spec, evaluationFrequency, evaluationTimeWindow, eventOccurrences, availabilityThreshold, responseTimeThreshold) {
+  const hosts = [];
+  const endpoints = {};
+  const endpointDefaults = {
+    availability_evaluation_frequency: evaluationFrequency,
+    availability_evaluation_time_window: evaluationTimeWindow,
+    availability_event_occurrences: eventOccurrences,
+    availability_threshold: availabilityThreshold ?? DEFAULT_AVAILABILITY_THRESHOLD,
+    response_time_evaluation_frequency: evaluationFrequency,
+    response_time_evaluation_time_window: evaluationTimeWindow,
+    response_time_event_occurrences: eventOccurrences,
+    response_time_threshold: responseTimeThreshold ?? DEFAULT_RESPONSE_TIME_THRESHOLD
+  };
+  const serverUrls = (() => {
+    if (oa3Spec.servers && oa3Spec.servers.length > 0) {
+      return oa3Spec.servers.map((s) => s.url);
+    }
+    if (oa3Spec.host) {
+      const basePath = oa3Spec.basePath || "";
+      return [`${oa3Spec.host}${basePath}`];
+    }
+    throw new ConfigError(
+      'OpenAPI spec must have either "servers" (OA3) or "host" (OA2) defined'
+    );
+  })();
+  if (!oa3Spec.paths || Object.keys(oa3Spec.paths).length === 0) {
+    throw new ConfigError(
+      "OpenAPI spec has no paths defined. Cannot generate dashboard for empty specification."
+    );
+  }
+  const endpointPaths = Object.keys(oa3Spec.paths);
+  const orderedPaths = [];
+  for (const serverUrl of serverUrls) {
+    const parsedUrl = new URL(
+      serverUrl.startsWith("http") ? serverUrl : `https://${serverUrl}`
+    );
+    const host = parseHost(serverUrl);
+    hosts.push(host);
+    for (const endpointPath of endpointPaths) {
+      const normalizedPath = normalizePath(parsedUrl.pathname, endpointPath);
+      const pathItem = oa3Spec.paths[endpointPath];
+      const hasValidMethods = pathItem && typeof pathItem === "object" && Object.keys(pathItem).some(
+        (method) => VALID_HTTP_METHODS.has(method.toLowerCase())
+      );
+      if (hasValidMethods && !endpoints[normalizedPath]) {
+        endpoints[normalizedPath] = {
+          ...endpointDefaults
+        };
+        orderedPaths.push(normalizedPath);
+      }
+    }
+  }
+  const orderedEndpoints = {};
+  for (const path4 of orderedPaths) {
+    orderedEndpoints[path4] = endpoints[path4];
+  }
+  return { endpoints: orderedEndpoints, hosts };
+}
+function normalizePath(urlPath, endpointPath) {
+  const cleanEndpointPath = endpointPath.startsWith("/") ? endpointPath.slice(1) : endpointPath;
+  const combined = path.posix.join(urlPath || "/", cleanEndpointPath);
+  return combined.startsWith("/") ? combined : `/${combined}`;
+}
+function parseHost(hostUrl) {
+  try {
+    const urlString = hostUrl.startsWith("http") ? hostUrl : `//${hostUrl}`;
+    const url = new URL(urlString);
+    return url.host;
+  } catch {
+    return hostUrl.replace(/^\/\//, "").split("/")[0] || hostUrl;
+  }
+}
+
+// src/builders/queries/api-management.ts
+var api_management_exports = {};
+__export(api_management_exports, {
+  availabilityQuery: () => availabilityQuery,
+  responseCodesQuery: () => responseCodesQuery,
+  responseTimeQuery: () => responseTimeQuery
+});
+
+// src/core/template/helpers.ts
+function uriToRegex(uri) {
+  return uri.replace(/\{[^/]+\}/g, "[^/]+") + "$";
+}
+
+// src/builders/queries/api-management.ts
+function availabilityQuery(ctx) {
+  const endpoint = ctx.endpoint;
+  const basePath = ctx.base_path ?? "";
+  const threshold = ctx.threshold ?? 0.99;
+  const props = ctx.endpoints?.[endpoint];
+  const method = props?.method;
+  const path4 = props?.path ?? endpoint;
+  const uriPattern = uriToRegex(basePath + path4);
+  const timespan = ctx.timespan || "5m";
+  const isAlarm = ctx.is_alarm ?? false;
+  const displayThreshold = threshold;
+  return `${isAlarm ? "" : "\n"}let threshold = ${displayThreshold};
+AzureDiagnostics
+| where url_s matches regex "${uriPattern}"${method ? `
+| where method_s == "${method}"` : ""}
+| summarize
+  Total=count(),
+  Success=count(responseCode_d < 500 and responseCode_d != 0) by bin(TimeGenerated, ${timespan})
+| extend availability=toreal(Success) / Total
+${isAlarm ? `| where availability < threshold` : `| project TimeGenerated, availability, watermark=threshold
+| render timechart with (xtitle = "time", ytitle= "availability(%)")`}
+`;
+}
+function responseCodesQuery(ctx) {
+  const endpoint = ctx.endpoint;
+  const basePath = ctx.base_path ?? "";
+  const props = ctx.endpoints?.[endpoint];
+  const method = props?.method;
+  const path4 = props?.path ?? endpoint;
+  const uriPattern = uriToRegex(basePath + path4);
+  const timespan = ctx.timespan || "5m";
+  return `
+let api_url = "${uriPattern}";
+AzureDiagnostics
+| where url_s matches regex api_url${method ? `
+| where method_s == "${method}"` : ""}
+| extend HTTPStatus = case(
+  responseCode_d between (100 .. 199), "1XX",
+  responseCode_d between (200 .. 299), "2XX",
+  responseCode_d between (300 .. 399), "3XX",
+  responseCode_d between (400 .. 499), "4XX",
+  "5XX")
+| summarize count() by HTTPStatus, bin(TimeGenerated, ${timespan})
+| render areachart with (xtitle = "time", ytitle= "count")
+`;
+}
+function responseTimeQuery(ctx) {
+  const endpoint = ctx.endpoint;
+  const basePath = ctx.base_path ?? "";
+  const threshold = ctx.threshold ?? 1;
+  const props = ctx.endpoints?.[endpoint];
+  const method = props?.method;
+  const path4 = props?.path ?? endpoint;
+  const uriPattern = uriToRegex(basePath + path4);
+  const timespan = ctx.timespan || "5m";
+  const isAlarm = ctx.is_alarm ?? false;
+  const percentile = ctx.queries?.response_time_percentile ?? 95;
+  return `${isAlarm ? "" : "\n"}let threshold = ${threshold};
+AzureDiagnostics
+| where url_s matches regex "${uriPattern}"${method ? `
+| where method_s == "${method}"` : ""}
+| summarize
+    watermark=threshold,
+    duration_percentile_${percentile}=percentiles(todouble(DurationMs)/1000, ${percentile}) by bin(TimeGenerated, ${timespan})
+${isAlarm ? `| where duration_percentile_${percentile} > threshold` : `| render timechart with (xtitle = "time", ytitle= "response time(s)")`}
+`;
+}
+
+// src/builders/queries/app-gateway.ts
+var app_gateway_exports = {};
+__export(app_gateway_exports, {
+  availabilityQuery: () => availabilityQuery2,
+  responseCodesQuery: () => responseCodesQuery2,
+  responseTimeQuery: () => responseTimeQuery2
+});
+function availabilityQuery2(ctx) {
+  const endpoint = ctx.endpoint;
+  const basePath = ctx.base_path ?? "";
+  const threshold = ctx.threshold ?? 0.99;
+  const props = ctx.endpoints?.[endpoint];
+  const method = props?.method;
+  const path4 = props?.path ?? endpoint;
+  const uriPattern = uriToRegex(basePath + path4);
+  const hostsJson = JSON.stringify(ctx.hosts ?? []).replace(/,/g, ", ");
+  const timespan = ctx.timespan || "5m";
+  const isAlarm = ctx.is_alarm ?? false;
+  const displayThreshold = threshold;
+  return `${isAlarm ? "" : "\n"}let api_hosts = datatable (name: string) ${hostsJson};
+let threshold = ${displayThreshold};
+AzureDiagnostics
+| where originalHost_s in (api_hosts)
+| where requestUri_s matches regex "${uriPattern}"${method ? `
+| where httpMethod_s == "${method}"` : ""}
+| summarize
+  Total=count(),
+  Success=count(httpStatus_d < 500) by bin(TimeGenerated, ${timespan})
+| extend availability=toreal(Success) / Total
+${isAlarm ? "| where availability < threshold" : `| project TimeGenerated, availability, watermark=threshold
+| render timechart with (xtitle = "time", ytitle= "availability(%)")`}
+`;
+}
+function responseCodesQuery2(ctx) {
+  const endpoint = ctx.endpoint;
+  const basePath = ctx.base_path ?? "";
+  const props = ctx.endpoints?.[endpoint];
+  const method = props?.method;
+  const path4 = props?.path ?? endpoint;
+  const uriPattern = uriToRegex(basePath + path4);
+  const hostsJson = JSON.stringify(ctx.hosts ?? []).replace(/,/g, ", ");
+  const timespan = ctx.timespan || "5m";
+  return `
+let api_url = "${uriPattern}";
+let api_hosts = datatable (name: string) ${hostsJson};
+AzureDiagnostics
+| where originalHost_s in (api_hosts)
+| where requestUri_s matches regex api_url${method ? `
+| where httpMethod_s == "${method}"` : ""}
+| extend HTTPStatus = case(
+  httpStatus_d between (100 .. 199), "1XX",
+  httpStatus_d between (200 .. 299), "2XX",
+  httpStatus_d between (300 .. 399), "3XX",
+  httpStatus_d between (400 .. 499), "4XX",
+  "5XX")
+| summarize count() by HTTPStatus, bin(TimeGenerated, ${timespan})
+| render areachart with (xtitle = "time", ytitle= "count")
+`;
+}
+function responseTimeQuery2(ctx) {
+  const endpoint = ctx.endpoint;
+  const basePath = ctx.base_path ?? "";
+  const threshold = ctx.threshold ?? 1;
+  const props = ctx.endpoints?.[endpoint];
+  const method = props?.method;
+  const path4 = props?.path ?? endpoint;
+  const uriPattern = uriToRegex(basePath + path4);
+  const hostsJson = JSON.stringify(ctx.hosts ?? []).replace(/,/g, ", ");
+  const timespan = ctx.timespan || "5m";
+  const isAlarm = ctx.is_alarm ?? false;
+  const percentile = ctx.queries?.response_time_percentile ?? 95;
+  return `${isAlarm ? "" : "\n"}let api_hosts = datatable (name: string) ${hostsJson};
+let threshold = ${threshold};
+AzureDiagnostics
+| where originalHost_s in (api_hosts)
+| where requestUri_s matches regex "${uriPattern}"${method ? `
+| where httpMethod_s == "${method}"` : ""}
+| summarize
+    watermark=threshold,
+    duration_percentile_${percentile}=percentiles(timeTaken_d, ${percentile}) by bin(TimeGenerated, ${timespan})
+${isAlarm ? `| where duration_percentile_${percentile} > threshold` : `| render timechart with (xtitle = "time", ytitle= "response time(s)")`}
+`;
+}
+
+// src/builders/azure-dashboard-raw/template.ts
+function createMetadataInputs(resourceIds, queryValue, partTitle, partSubTitle, specificChart, dimensions) {
+  return [
+    { name: "resourceTypeMode", isOptional: true },
+    { name: "ComponentId", isOptional: true },
+    { name: "Scope", value: { resourceIds }, isOptional: true },
+    { name: "PartId", isOptional: true },
+    { name: "Version", value: "2.0", isOptional: true },
+    { name: "TimeRange", value: "PT4H", isOptional: true },
+    { name: "DashboardId", isOptional: true },
+    {
+      name: "DraftRequestParameters",
+      value: { scope: "hierarchy" },
+      isOptional: true
+    },
+    { name: "Query", value: queryValue, isOptional: true },
+    { name: "ControlType", value: "FrameControlChart", isOptional: true },
+    { name: "SpecificChart", value: specificChart, isOptional: true },
+    { name: "PartTitle", value: partTitle, isOptional: true },
+    { name: "PartSubTitle", value: partSubTitle, isOptional: true },
+    { name: "Dimensions", value: dimensions, isOptional: true },
+    {
+      name: "LegendOptions",
+      value: { isEnabled: true, position: "Bottom" },
+      isOptional: true
+    },
+    { name: "IsQueryContainTimeRange", value: false, isOptional: true }
+  ];
+}
+function createAvailabilityPart(ctx, endpoint, props, resourceIds, timespan, fullPath, partIndex, yPosition, queryFns) {
+  const availabilityQuery3 = queryFns.availabilityQuery({
+    ...ctx,
+    endpoint,
+    is_alarm: false,
+    threshold: props.availability_threshold,
+    ...props
+    // Include method and path from queryProps
+  });
+  return {
+    [`${partIndex}`]: {
+      position: { x: 0, y: yPosition, colSpan: 6, rowSpan: 4 },
+      metadata: {
+        inputs: createMetadataInputs(
+          resourceIds,
+          availabilityQuery3,
+          `Availability (${timespan})`,
+          fullPath,
+          "Line",
+          {
+            xAxis: { name: "TimeGenerated", type: "datetime" },
+            yAxis: [
+              { name: "availability", type: "real" },
+              { name: "watermark", type: "real" }
+            ],
+            splitBy: [],
+            aggregation: "Sum"
+          }
+        ),
+        type: "Extension/Microsoft_OperationsManagementSuite_Workspace/PartType/LogsDashboardPart",
+        settings: {
+          content: {
+            Query: availabilityQuery3,
+            PartTitle: `Availability (${timespan})`
+          }
+        }
+      }
+    }
+  };
+}
+function createResponseCodesPart(ctx, endpoint, queryProps, resourceIds, timespan, fullPath, partIndex, yPosition, queryFns) {
+  const responseCodesQuery3 = queryFns.responseCodesQuery({
+    ...ctx,
+    endpoint,
+    ...queryProps
+    // Include method and path
+  });
+  return {
+    [`${partIndex}`]: {
+      position: { x: 6, y: yPosition, colSpan: 6, rowSpan: 4 },
+      metadata: {
+        inputs: createMetadataInputs(
+          resourceIds,
+          responseCodesQuery3,
+          `Response Codes (${timespan})`,
+          fullPath,
+          "Pie",
+          {
+            xAxis: { name: "httpStatus_d", type: "string" },
+            yAxis: [{ name: "count_", type: "long" }],
+            splitBy: [],
+            aggregation: "Sum"
+          }
+        ),
+        type: "Extension/Microsoft_OperationsManagementSuite_Workspace/PartType/LogsDashboardPart",
+        settings: {
+          content: {
+            Query: responseCodesQuery3,
+            SpecificChart: "StackedArea",
+            PartTitle: `Response Codes (${timespan})`,
+            Dimensions: {
+              xAxis: { name: "TimeGenerated", type: "datetime" },
+              yAxis: [{ name: "count_", type: "long" }],
+              splitBy: [{ name: "HTTPStatus", type: "string" }],
+              aggregation: "Sum"
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function createResponseTimePart(ctx, endpoint, props, resourceIds, timespan, fullPath, partIndex, yPosition, queryFns) {
+  const responseTimeQuery3 = queryFns.responseTimeQuery({
+    ...ctx,
+    endpoint,
+    is_alarm: false,
+    threshold: props.response_time_threshold,
+    ...props
+    // Include method and path from queryProps
+  });
+  return {
+    [`${partIndex}`]: {
+      position: { x: 12, y: yPosition, colSpan: 6, rowSpan: 4 },
+      metadata: {
+        inputs: createMetadataInputs(
+          resourceIds,
+          responseTimeQuery3,
+          `Percentile Response Time (${timespan})`,
+          fullPath,
+          "StackedColumn",
+          {
+            xAxis: { name: "TimeGenerated", type: "datetime" },
+            yAxis: [{ name: "duration_percentile_95", type: "real" }],
+            splitBy: [],
+            aggregation: "Sum"
+          }
+        ),
+        type: "Extension/Microsoft_OperationsManagementSuite_Workspace/PartType/LogsDashboardPart",
+        settings: {
+          content: {
+            Query: responseTimeQuery3,
+            SpecificChart: "Line",
+            PartTitle: `Percentile Response Time (${timespan})`,
+            Dimensions: {
+              xAxis: { name: "TimeGenerated", type: "datetime" },
+              yAxis: [
+                { name: "watermark", type: "long" },
+                { name: "duration_percentile_95", type: "real" }
+              ],
+              splitBy: [],
+              aggregation: "Sum"
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function azureDashboardRawTemplate(context) {
+  const basePath = context.base_path ?? "";
+  const resourceIds = [context.data_source_id];
+  const timespan = context.timespan || "5m";
+  const queryFns = context.resource_type === "api-management" ? api_management_exports : app_gateway_exports;
+  const endpointEntries = Object.entries(context.endpoints);
+  const parts = endpointEntries.flatMap(([endpoint, props], i) => {
+    const parsed = parseEndpointKey(endpoint);
+    const fullPath = basePath + endpoint;
+    const queryProps = {
+      ...props,
+      method: parsed.method || props.method,
+      path: parsed.path || props.path || endpoint
+    };
+    const partIndex = i * 3;
+    const yPosition = i * 4;
+    return [
+      createAvailabilityPart(
+        context,
+        endpoint,
+        queryProps,
+        resourceIds,
+        timespan,
+        fullPath,
+        partIndex + 0,
+        yPosition,
+        queryFns
+      ),
+      createResponseCodesPart(
+        context,
+        endpoint,
+        queryProps,
+        resourceIds,
+        timespan,
+        fullPath,
+        partIndex + 1,
+        yPosition,
+        queryFns
+      ),
+      createResponseTimePart(
+        context,
+        endpoint,
+        queryProps,
+        resourceIds,
+        timespan,
+        fullPath,
+        partIndex + 2,
+        yPosition,
+        queryFns
+      )
+    ];
+  });
+  const mergedParts = Object.assign({}, ...parts);
+  const baseUuid = "9badbd78-7607-4131-8fa1-8b85191432";
+  const maxFilteredParts = 9;
+  const filteredPartIds = Array.from({ length: maxFilteredParts }, (_, i) => {
+    const hex = (237 + i * 2).toString(16);
+    return `StartboardPart-LogsDashboardPart-${baseUuid}${hex}`;
+  });
+  const dashboard = {
+    properties: {
+      lenses: {
+        "0": {
+          order: 0,
+          parts: mergedParts
+        }
+      },
+      metadata: {
+        model: {
+          timeRange: {
+            value: {
+              relative: {
+                duration: 24,
+                timeUnit: 1
+              }
+            },
+            type: "MsPortalFx.Composition.Configuration.ValueTypes.TimeRange"
+          },
+          filterLocale: {
+            value: "en-us"
+          },
+          filters: {
+            value: {
+              MsPortalFx_TimeRange: {
+                model: {
+                  format: "local",
+                  granularity: "auto",
+                  relative: "48h"
+                },
+                displayCache: {
+                  name: "Local Time",
+                  value: "Past 48 hours"
+                },
+                filteredPartIds
+              }
+            }
+          }
+        }
+      }
+    },
+    name: context.name,
+    type: "Microsoft.Portal/dashboards",
+    location: context.location,
+    tags: {
+      "hidden-title": context.name
+    },
+    apiVersion: "2015-08-01-preview"
+  };
+  return JSON.stringify(dashboard, null, 2);
+}
+
+// src/builders/azure-dashboard-raw/builder.ts
+var AzDashboardRawBuilder = class extends Builder {
+  evaluationFrequency;
+  evaluationTimeWindow;
+  eventOccurrences;
+  oa3Spec;
+  constructor(options) {
+    super(azureDashboardRawTemplate, {
+      action_groups_ids: [],
+      availability_threshold: options.availabilityThreshold,
+      data_source_id: options.resources[0],
+      endpoints: {},
+      evaluation_frequency: options.evaluationFrequency,
+      event_occurrences: options.eventOccurrences,
+      hosts: [],
+      location: options.location,
+      name: options.name,
+      queries: options.queries,
+      resource_type: options.resourceType,
+      response_time_threshold: options.responseTimeThreshold,
+      time_window: options.evaluationTimeWindow,
+      timespan: options.timespan
+    });
+    this.oa3Spec = OA3SpecSchema.parse(options.oa3Spec);
+    this.evaluationFrequency = options.evaluationFrequency;
+    this.evaluationTimeWindow = options.evaluationTimeWindow;
+    this.eventOccurrences = options.eventOccurrences;
+  }
+  /**
+   * Render the template by extracting endpoints from OA3 spec and merging with overrides.
+   */
+  produce(values = {}) {
+    const { endpoints, hosts } = extractEndpoints(
+      this.oa3Spec,
+      this.evaluationFrequency,
+      this.evaluationTimeWindow,
+      this.eventOccurrences,
+      this.properties.availability_threshold,
+      this.properties.response_time_threshold
+    );
+    this.properties.hosts = hosts;
+    this.properties.endpoints = endpoints;
+    const mergedValues = values.endpoints ? { ...values, endpoints: normalizeEndpointKeys(values.endpoints) } : values;
+    return super.produce(mergedValues);
+  }
+};
+
+// src/builders/azure-dashboard/builder.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import * as path3 from "path";
+
+// src/builders/azure-dashboard/packager.ts
+import { mkdir, writeFile } from "fs/promises";
+import * as path2 from "path";
+
+// src/builders/azure-dashboard/terraform-assets.ts
+function generateBackendTfvars(backend) {
+  return `resource_group_name  = ${backend?.resource_group_name ? `"${backend.resource_group_name}"` : ""}
+storage_account_name = ${backend?.storage_account_name ? `"${backend.storage_account_name}"` : ""}
+container_name       = ${backend?.container_name ? `"${backend.container_name}"` : ""}
+key                  = ${backend?.key ? `"${backend.key}"` : ""}
+use_azuread_auth    = "true"
+`;
+}
+function generateMainTf() {
+  const terraformVersion = ">=1.1.5";
+  const azurermVersion = ">= 3.86.0, <=3.116.0";
+  return `terraform {
+  required_version = "${terraformVersion}"
+
+  required_providers {
+    azurerm = {
+      source  = "hashicorp/azurerm"
+      version = "${azurermVersion}"
+    }
+  }
+
+  backend "azurerm" {}
+}
+
+provider "azurerm" {
+  features {}
+}
+`;
+}
+function generateTerraformTfvars(envConfig) {
+  return `prefix    = ${envConfig?.prefix ? `"${envConfig.prefix}"` : ""}
+env_short = ${envConfig?.env_short ? `"${envConfig.env_short}"` : ""}
+`;
+}
+function generateVariablesTf() {
+  return `variable "prefix" {
+  type    = string
+  validation {
+    condition = (
+      length(var.prefix) <= 6
+    )
+    error_message = "Max length is 6 chars."
+  }
+}
+
+variable "env_short" {
+  type = string
+  validation {
+    condition = (
+      length(var.env_short) <= 1
+    )
+    error_message = "Max length is 1 chars."
+  }
+}
+
+variable "tags" {
+  type = map(any)
+  default = {
+    CreatedBy = "Terraform"
+  }
+}
+`;
+}
+
+// src/builders/azure-dashboard/packager.ts
+async function generateTerraformAssets(outputPath, terraformConfig) {
+  try {
+    const mainTfContent = generateMainTf();
+    const variablesTfContent = generateVariablesTf();
+    await Promise.all([
+      writeFile(path2.join(outputPath, "main.tf"), mainTfContent, "utf-8"),
+      writeFile(
+        path2.join(outputPath, "variables.tf"),
+        variablesTfContent,
+        "utf-8"
+      )
+    ]);
+    if (terraformConfig?.environments) {
+      const envPromises = [];
+      for (const [env, envConfig] of Object.entries(
+        terraformConfig.environments
+      )) {
+        if (envConfig) {
+          const envPath = path2.join(outputPath, "env", env);
+          const envPromise = (async () => {
+            await mkdir(envPath, { recursive: true });
+            const backendTfvarsContent = generateBackendTfvars(
+              envConfig.backend
+            );
+            const terraformTfvarsContent = generateTerraformTfvars(envConfig);
+            await Promise.all([
+              writeFile(
+                path2.join(envPath, "backend.tfvars"),
+                backendTfvarsContent,
+                "utf-8"
+              ),
+              writeFile(
+                path2.join(envPath, "terraform.tfvars"),
+                terraformTfvarsContent,
+                "utf-8"
+              )
+            ]);
+          })();
+          envPromises.push(envPromise);
+        }
+      }
+      await Promise.all(envPromises);
+    }
+  } catch (error) {
+    throw new FileError(
+      `Failed to generate Terraform assets in ${outputPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// src/builders/azure-dashboard/template.ts
+function azureDashboardTerraformTemplate(context) {
+  const name = context.name;
+  const dashboardProperties = context.dashboard_properties || "";
+  const basePath = context.base_path ?? "";
+  const actionGroupsJson = JSON.stringify(context.action_groups_ids).replace(
+    /,/g,
+    ", "
+  );
+  const dataSourceId = context.data_source_id;
+  const queryFns = context.resource_type === "api-management" ? api_management_exports : app_gateway_exports;
+  return `
+locals {
+  name                = "\${var.prefix}-\${var.env_short}-${name}"
+  dashboard_base_addr = "https://portal.azure.com/#@pagopait.onmicrosoft.com/dashboard/arm"
+}
+
+data "azurerm_resource_group" "this" {
+  name     = "dashboards"
+}
+
+resource "azurerm_portal_dashboard" "this" {
+  name                = local.name
+  resource_group_name = data.azurerm_resource_group.this.name
+  location            = data.azurerm_resource_group.this.location
+
+  dashboard_properties = <<-PROPS
+    ${dashboardProperties}
+  PROPS
+
+  tags = var.tags
+}
+
+
+${Object.entries(context.endpoints).map(([endpoint, props], i) => {
+    const fullPath = basePath + endpoint;
+    const availabilityQuery3 = queryFns.availabilityQuery({
+      ...context,
+      endpoint,
+      is_alarm: true,
+      threshold: props.availability_threshold,
+      ...props
+    });
+    const responseTimeQuery3 = queryFns.responseTimeQuery({
+      ...context,
+      endpoint,
+      is_alarm: true,
+      threshold: props.response_time_threshold,
+      ...props
+    });
+    return `resource "azurerm_monitor_scheduled_query_rules_alert" "alarm_availability_${i}" {
+  name                = replace(join("_",split("/", "\${local.name}-availability @ ${fullPath}")), "/\\\\{|\\\\}/", "")
+  resource_group_name = data.azurerm_resource_group.this.name
+  location            = data.azurerm_resource_group.this.location
+
+  action {
+    action_group = ${actionGroupsJson}
+  }
+
+  data_source_id          = "${dataSourceId}"
+  description             = "Availability for ${fullPath} is less than or equal to 99% - \${local.dashboard_base_addr}\${azurerm_portal_dashboard.this.id}"
+  enabled                 = true
+  auto_mitigation_enabled = false
+
+  query = <<-QUERY
+
+    
+${availabilityQuery3}
+
+  QUERY
+
+  severity    = 1
+  frequency   = ${props.availability_evaluation_frequency ?? 10}
+  time_window = ${props.availability_evaluation_time_window ?? 20}
+  trigger {
+    operator  = "GreaterThanOrEqual"
+    threshold = ${props.availability_event_occurrences ?? 1}
+  }
+
+  tags = var.tags
+}
+
+resource "azurerm_monitor_scheduled_query_rules_alert" "alarm_time_${i}" {
+  name                = replace(join("_",split("/", "\${local.name}-responsetime @ ${fullPath}")), "/\\\\{|\\\\}/", "")
+  resource_group_name = data.azurerm_resource_group.this.name
+  location            = data.azurerm_resource_group.this.location
+
+  action {
+    action_group = ${actionGroupsJson}
+  }
+
+  data_source_id          = "${dataSourceId}"
+  description             = "Response time for ${fullPath} is less than or equal to 1s - \${local.dashboard_base_addr}\${azurerm_portal_dashboard.this.id}"
+  enabled                 = true
+  auto_mitigation_enabled = false
+
+  query = <<-QUERY
+
+    
+${responseTimeQuery3}
+
+  QUERY
+
+  severity    = 1
+  frequency   = ${props.response_time_evaluation_frequency ?? 10}
+  time_window = ${props.response_time_evaluation_time_window ?? 20}
+  trigger {
+    operator  = "GreaterThanOrEqual"
+    threshold = ${props.response_time_event_occurrences ?? 1}
+  }
+
+  tags = var.tags
+}
+`;
+  }).join("\n")}
+`;
+}
+
+// src/builders/azure-dashboard/builder.ts
+var AzDashboardBuilder = class extends Builder {
+  rawBuilder;
+  terraformConfig;
+  constructor(options) {
+    super(azureDashboardTerraformTemplate, {
+      action_groups_ids: options.actionGroupsIds,
+      data_source_id: options.dataSourceId,
+      endpoints: {},
+      evaluation_frequency: options.evaluationFrequency,
+      event_occurrences: options.eventOccurrences,
+      hosts: [],
+      location: options.location,
+      name: options.name.replace(/ /g, "_"),
+      // Replace spaces with underscores for Terraform compatibility
+      resource_type: options.resourceType,
+      time_window: options.evaluationTimeWindow,
+      timespan: options.timespan
+    });
+    this.rawBuilder = options.dashboardBuilder;
+    this.terraformConfig = options.terraformConfig;
+  }
+  /**
+   * Package Terraform configuration.
+   * Creates opex.tf and generates terraform assets (main.tf, variables.tf, env/).
+   */
+  async package(outputPath, values = {}) {
+    try {
+      await mkdir2(outputPath, { recursive: true });
+      const terraformFilePath = path3.join(outputPath, "opex.tf");
+      const content = this.produce(values);
+      await writeFile2(terraformFilePath, content, "utf-8");
+      await generateTerraformAssets(outputPath, this.terraformConfig);
+    } catch (error) {
+      throw new FileError(
+        `Failed to package Terraform configuration in ${outputPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Render Terraform template with embedded dashboard JSON from raw builder.
+   */
+  produce(values = {}) {
+    const normalizedValues = values.endpoints ? { ...values, endpoints: normalizeEndpointKeys(values.endpoints) } : values;
+    const rawJson = this.rawBuilder.produce(normalizedValues);
+    const dashboard = JSON.parse(rawJson);
+    this.properties.dashboard_properties = JSON.stringify(
+      dashboard.properties,
+      null,
+      2
+    );
+    const rawProps = this.rawBuilder.props();
+    this.properties.hosts = rawProps.hosts;
+    this.properties.endpoints = rawProps.endpoints;
+    return super.produce(normalizedValues);
+  }
+};
+
+// src/core/builder-factory.ts
+async function createAzureRawBuilder(params) {
+  const oa3Spec = await params.resolver.resolve();
+  return new AzDashboardRawBuilder({
+    availabilityThreshold: params.availability_threshold,
+    evaluationFrequency: params.evaluation_frequency,
+    evaluationTimeWindow: params.evaluation_time_window,
+    eventOccurrences: params.event_occurrences,
+    location: params.location,
+    name: params.name,
+    oa3Spec,
+    queries: params.queries,
+    resources: params.resources,
+    resourceType: params.resource_type,
+    responseTimeThreshold: params.response_time_threshold,
+    timespan: params.timespan
+  });
+}
+async function createAzureTerraformBuilder(params) {
+  const rawBuilder = await createAzureRawBuilder(params);
+  return new AzDashboardBuilder({
+    actionGroupsIds: params.action_groups_ids,
+    dashboardBuilder: rawBuilder,
+    dataSourceId: params.data_source_id,
+    evaluationFrequency: params.evaluation_frequency,
+    evaluationTimeWindow: params.evaluation_time_window,
+    eventOccurrences: params.event_occurrences,
+    location: params.location,
+    name: params.name,
+    resourceType: params.resource_type,
+    terraformConfig: params.terraform,
+    timespan: params.timespan
+  });
+}
+var builderRegistry = {
+  "azure-dashboard": createAzureTerraformBuilder,
+  "azure-dashboard-raw": createAzureRawBuilder
+};
+async function createBuilder(templateType, params) {
+  const factory = builderRegistry[templateType];
+  if (!factory) {
+    throw new InvalidBuilderError(
+      `Invalid builder error: unknown builder ${templateType}`
+    );
+  }
+  try {
+    return await factory(params);
+  } catch (error) {
+    throw new InvalidBuilderError(
+      `Failed to create builder: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// src/core/config/config.schema.ts
+import { z as z4 } from "zod";
+
+// src/core/shared/query-config.schema.ts
+import { z as z3 } from "zod";
+var QueryConfigSchema = z3.object({
+  response_time_percentile: z3.number().default(95).describe("Percentile for response time queries. Default: 95"),
+  status_code_categories: z3.array(z3.string()).default(["1XX", "2XX", "3XX", "4XX", "5XX"]).describe("HTTP status code categories for response codes queries")
+});
+
+// src/core/config/defaults.ts
+var DEFAULT_TIMESPAN = "5m";
+var DEFAULTS = {
+  availability_threshold: DEFAULT_AVAILABILITY_THRESHOLD,
+  evaluation_frequency: EVALUATION_FREQUENCY_MINUTES,
+  evaluation_time_window: TIME_WINDOW_MINUTES,
+  event_occurrences: EVENT_OCCURRENCES,
+  response_time_threshold: DEFAULT_RESPONSE_TIME_THRESHOLD,
+  timespan: DEFAULT_TIMESPAN
+};
+
+// src/core/config/config.schema.ts
+var EndpointOverrideSchema = EndpointOverridePropertiesSchema.extend({
+  availability_evaluation_frequency: z4.number().optional().describe(
+    "Frequency in minutes to evaluate availability alarm. Default: 10"
+  ),
+  availability_evaluation_time_window: z4.number().optional().describe(
+    "Time window in minutes for availability alarm evaluation. Default: 20"
+  ),
+  availability_event_occurrences: z4.number().optional().describe(
+    "Number of event occurrences to trigger availability alarm. Default: 1"
+  ),
+  availability_threshold: z4.number().optional().describe("Minimum availability percentage (0-1). Default: 0.99 (99%)"),
+  response_time_evaluation_frequency: z4.number().optional().describe(
+    "Frequency in minutes to evaluate response time alarm. Default: 10"
+  ),
+  response_time_evaluation_time_window: z4.number().optional().describe(
+    "Time window in minutes for response time alarm evaluation. Default: 20"
+  ),
+  response_time_event_occurrences: z4.number().optional().describe(
+    "Number of event occurrences to trigger response time alarm. Default: 1"
+  ),
+  response_time_threshold: z4.number().optional().describe("Maximum response time in seconds. Default: 1")
+});
+var OverridesSchema = z4.object({
+  endpoints: z4.record(z4.string(), EndpointOverrideSchema).optional().describe(
+    "Override alarm thresholds and settings for specific endpoints (key: endpoint path)"
+  ),
+  hosts: z4.array(z4.string()).optional().describe(
+    "Override host URLs from OpenAPI spec (e.g., https://example.com)"
+  ),
+  queries: QueryConfigSchema.optional().describe(
+    "Optional query configuration overrides"
+  )
+});
+var BackendConfigSchema = z4.object({
+  container_name: z4.string().describe("Blob container name for Terraform state"),
+  key: z4.string().describe("State file key/path"),
+  resource_group_name: z4.string().describe("Azure resource group for backend state"),
+  storage_account_name: z4.string().describe("Storage account for Terraform state")
+});
+var EnvironmentConfigSchema = z4.object({
+  backend: BackendConfigSchema.optional().describe(
+    "Azure backend configuration for Terraform state"
+  ),
+  env_short: z4.string().max(1).describe("Environment short name (1 char: 'd'=dev, 'u'=uat, 'p'=prod)"),
+  prefix: z4.string().max(6).describe("Project prefix (max 6 chars, e.g., 'io', 'pagopa')")
+});
+var TerraformConfigSchema = z4.object({
+  environments: z4.object({
+    dev: EnvironmentConfigSchema.optional(),
+    prod: EnvironmentConfigSchema.optional(),
+    uat: EnvironmentConfigSchema.optional()
+  }).optional().describe("Environment-specific configurations for dev/uat/prod")
+});
+var ConfigSchema = z4.object({
+  action_groups: z4.array(z4.string()).describe(
+    "Array of Azure Action Group resource IDs for alarm notifications"
+  ),
+  availability_threshold: z4.number().optional().default(DEFAULTS.availability_threshold).describe(
+    "Default minimum availability percentage (0-1). Default: 0.99 (99%)"
+  ),
+  data_source: z4.string().describe(
+    "Azure resource ID for metrics data source (Application Gateway or API Management)"
+  ),
+  evaluation_frequency: z4.number().optional().default(DEFAULTS.evaluation_frequency).describe("Default frequency in minutes to evaluate alarms. Default: 10"),
+  evaluation_time_window: z4.number().optional().default(DEFAULTS.evaluation_time_window).describe(
+    "Default time window in minutes for alarm evaluation. Default: 20"
+  ),
+  event_occurrences: z4.number().optional().default(DEFAULTS.event_occurrences).describe(
+    "Default number of event occurrences to trigger an alarm. Default: 1"
+  ),
+  location: z4.string().describe("Azure region/location for the dashboard (e.g., West Europe)"),
+  name: z4.string().describe("Name of the dashboard"),
+  oa3_spec: z4.string().describe(
+    "Path or HTTP URL to OpenAPI 3.x specification file (supports OA2 and OA3)"
+  ),
+  overrides: OverridesSchema.optional().describe(
+    "Optional overrides for hosts, per-endpoint alarm thresholds, and query configurations"
+  ),
+  queries: QueryConfigSchema.optional().describe(
+    "Optional global query configuration overrides"
+  ),
+  resource_type: z4.enum(["app-gateway", "api-management"]).optional().default("app-gateway").describe(
+    "Type of Azure resource to monitor: app-gateway (Application Gateway) or api-management (API Management). Default: app-gateway"
+  ),
+  response_time_threshold: z4.number().optional().default(DEFAULTS.response_time_threshold).describe("Default maximum response time in seconds. Default: 1.0"),
+  terraform: TerraformConfigSchema.optional().describe(
+    "Optional Terraform and environment-specific configuration"
+  ),
+  timespan: z4.string().optional().default(DEFAULTS.timespan).describe(
+    "Time range for dashboard queries (e.g., 5m, 1h, 24h). Default: 5m"
+  )
+});
+
+// src/core/config/loader.ts
+import { readFile } from "fs/promises";
+import * as yaml from "js-yaml";
+async function loadConfig(configPath) {
+  const content = await (async () => {
+    try {
+      if (configPath === "-") {
+        return await readStdin();
+      }
+      return await readFile(configPath, "utf-8");
+    } catch (error) {
+      throw new FileError(
+        `Failed to read config file: ${configPath} - ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  })();
+  try {
+    const rawConfig = yaml.load(content);
+    const config = ConfigSchema.parse(rawConfig);
+    return config;
+  } catch (error) {
+    if (error && typeof error === "object" && "name" in error && error.name === "YAMLException") {
+      throw new ConfigError(`Invalid YAML syntax: ${error.message}`);
+    }
+    throw new ConfigError(
+      `Invalid configuration: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+
+// src/core/resolver/oa3-resolver.ts
+import SwaggerParser from "@apidevtools/swagger-parser";
+var OA3Resolver = class {
+  specPath;
+  constructor(specPath) {
+    this.specPath = specPath;
+  }
+  /**
+   * Resolve OpenAPI specification.
+   * Parses fresh each time (no caching) to match Python behavior.
+   * Resolves all $ref references automatically.
+   */
+  async resolve() {
+    try {
+      const api = await SwaggerParser.dereference(this.specPath);
+      return api;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new ParseError(`OA3 parsing error: ${error.message}`);
+      }
+      throw new ParseError(`OA3 parsing error: ${String(error)}`);
+    }
+  }
+};
+
+// src/cli/helpers/output-writer.ts
+import { mkdir as mkdir3 } from "fs/promises";
+async function ensureDirectory(dirPath) {
+  try {
+    await mkdir3(dirPath, { recursive: true });
+  } catch (error) {
+    throw new FileError(
+      `Failed to create directory ${dirPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function writeToStdout(content) {
+  process.stdout.write(content);
+}
+
+// src/cli/helpers/spec-downloader.ts
+import { access, unlink, writeFile as writeFile3 } from "fs/promises";
+import tmp from "tmp";
+async function cleanupTempFile(filePath) {
+  try {
+    await access(filePath);
+    await unlink(filePath);
+  } catch {
+  }
+}
+async function downloadSpec(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to download spec: ${response.status} ${response.statusText}`
+    );
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  const tempFile = tmp.fileSync({
+    postfix: ".yaml",
+    prefix: "opex-spec-"
+  }).name;
+  try {
+    await writeFile3(tempFile, Buffer.from(arrayBuffer));
+  } catch (error) {
+    throw new FileError(
+      `Failed to write spec to ${tempFile}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return tempFile;
+}
+
+// src/cli/commands/generate.ts
+function createGenerateCommand() {
+  const command = new Command("generate");
+  command.description("Generate a dashboard definition from OpenAPI specification").requiredOption(
+    "-t, --template-type <type>",
+    "Type of template to generate",
+    (value) => {
+      if (!["azure-dashboard", "azure-dashboard-raw"].includes(value)) {
+        throw new Error(
+          "Invalid template type. Must be: azure-dashboard or azure-dashboard-raw"
+        );
+      }
+      return value;
+    }
+  ).requiredOption(
+    "-c, --config <path>",
+    "Path to YAML configuration file (use - for stdin)"
+  ).option(
+    "--package [path]",
+    "Save template as a package in specified directory (default: current directory)",
+    false
+  ).action(generateHandler);
+  return command;
+}
+async function generateHandler(options) {
+  try {
+    const config = await loadConfig(options.config);
+    const isHttp = config.oa3_spec.startsWith("http");
+    const tempFile = isHttp ? await downloadSpec(config.oa3_spec) : void 0;
+    const specPath = tempFile ?? config.oa3_spec;
+    const allowedResourceTypes = ["app-gateway", "api-management"];
+    if (!allowedResourceTypes.includes(config.resource_type)) {
+      throw new ConfigError(
+        `Invalid resource_type configuration: valid values are ${allowedResourceTypes.join(
+          ", "
+        )}`
+      );
+    }
+    const resolver = new OA3Resolver(specPath);
+    const builderParams = {
+      action_groups_ids: config.action_groups,
+      availability_threshold: config.availability_threshold,
+      data_source_id: config.data_source,
+      evaluation_frequency: config.evaluation_frequency,
+      evaluation_time_window: config.evaluation_time_window,
+      event_occurrences: config.event_occurrences,
+      location: config.location,
+      name: config.name,
+      queries: config.queries || config.overrides?.queries,
+      resolver,
+      resource_type: config.resource_type,
+      resources: [config.data_source],
+      response_time_threshold: config.response_time_threshold,
+      terraform: config.terraform,
+      timespan: config.timespan
+    };
+    const builder = await createBuilder(options.templateType, builderParams);
+    const overrides = config.overrides || {};
+    if (options.package) {
+      const outputPath = options.package;
+      await ensureDirectory(outputPath);
+      await builder.package(outputPath, overrides);
+    } else {
+      const output = builder.produce(overrides);
+      writeToStdout(output);
+    }
+    if (tempFile) {
+      await cleanupTempFile(tempFile);
+    }
+  } catch (error) {
+    console.error(
+      "Error:",
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
+  }
+}
+
+// src/cli/index.ts
+var program = new Command2();
+program.name("opex_dashboard").description("Generate operational dashboards from OpenAPI 3 specifications");
+program.addCommand(createGenerateCommand()).version("0.0.2");
+program.parse(process.argv);