@checkstack/healthcheck-script-backend 0.1.13 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,84 @@
 # @checkstack/healthcheck-script-backend
 
+## 0.3.0
+
+### Minor Changes
+
+- 3dd1914: Migrate health check strategies to VersionedAggregated with \_type discriminator
+
+  All 13 health check strategies now use `VersionedAggregated` for their `aggregatedResult` property, enabling automatic bucket merging with 100% mathematical fidelity.
+
+  **Key changes:**
+
+  - **`_type` discriminator**: All aggregated state objects now include a required `_type` field (`"average"`, `"rate"`, `"counter"`, `"minmax"`) for reliable type detection
+  - The `HealthCheckStrategy` interface now requires `aggregatedResult` to be a `VersionedAggregated<AggregatedResultShape>`
+  - Strategy/collector `mergeResult` methods return state objects with `_type` (e.g., `{ _type: "average", _sum, _count, avg }`)
+  - `mergeAggregatedBucketResults`, `combineBuckets`, and `reaggregateBuckets` now require `registry` and `strategyId` parameters
+  - `HealthCheckService` constructor now requires both `registry` and `collectorRegistry` parameters
+  - Frontend `extractComputedValue` now uses `_type` discriminator for robust type detection
+
+  **Breaking Change**: State objects now require `_type`. Merge functions automatically add `_type` to output. The bucket merging functions and `HealthCheckService` now require additional required parameters.
+
+### Patch Changes
+
+- Updated dependencies [3dd1914]
+  - @checkstack/backend-api@0.7.0
+
+## 0.2.0
+
+### Minor Changes
+
+- f676e11: Add script execution support and migrate CodeEditor to Monaco
+
+  **Integration providers** (`@checkstack/integration-script-backend`):
+
+  - **Script** - Execute TypeScript/JavaScript with context object
+  - **Bash** - Execute shell scripts with environment variables ($EVENT*ID, $PAYLOAD*\*)
+
+  **Health check collectors** (`@checkstack/healthcheck-script-backend`):
+
+  - **InlineScriptCollector** - Run TypeScript directly for health checks
+  - **ExecuteCollector** - Bash syntax highlighting for command field
+
+  **CodeEditor migration to Monaco** (`@checkstack/ui`):
+
+  - Replaced CodeMirror with Monaco Editor (VS Code's editor)
+  - Full TypeScript/JavaScript IntelliSense with custom type definitions
+  - Added `generateTypeDefinitions()` for JSON Schema → TypeScript conversion
+  - Removed all CodeMirror dependencies
+
+  **Type updates** (`@checkstack/common`):
+
+  - Added `javascript`, `typescript`, and `bash` to `EditorType` union
+
+### Patch Changes
+
+- 48c2080: Migrate aggregation from batch to incremental (`mergeResult`)
+
+  ### Breaking Changes (Internal)
+
+  - Replaced `aggregateResult(runs[])` with `mergeResult(existing, run)` interface across all HealthCheckStrategy and CollectorStrategy implementations
+
+  ### New Features
+
+  - Added incremental aggregation utilities in `@checkstack/backend-api`:
+    - `mergeCounter()` - track occurrences
+    - `mergeAverage()` - track sum/count, compute avg
+    - `mergeRate()` - track success/total, compute %
+    - `mergeMinMax()` - track min/max values
+  - Exported Zod schemas for internal state: `averageStateSchema`, `rateStateSchema`, `minMaxStateSchema`, `counterStateSchema`
+
+  ### Improvements
+
+  - Enables O(1) storage overhead by maintaining incremental aggregation state
+  - Prepares for real-time hourly aggregation without batch accumulation
+
+- Updated dependencies [f676e11]
+- Updated dependencies [48c2080]
+  - @checkstack/common@0.6.2
+  - @checkstack/backend-api@0.6.0
+  - @checkstack/healthcheck-common@0.8.2
+
 ## 0.1.13
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/healthcheck-script-backend",
-  "version": "0.1.13",
+  "version": "0.3.0",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {
@@ -9,14 +9,14 @@
     "lint:code": "eslint . --max-warnings 0"
   },
   "dependencies": {
-    "@checkstack/backend-api": "0.5.1",
-    "@checkstack/common": "0.6.0",
-    "@checkstack/healthcheck-common": "0.7.0"
+    "@checkstack/backend-api": "0.5.2",
+    "@checkstack/common": "0.6.1",
+    "@checkstack/healthcheck-common": "0.8.1"
   },
   "devDependencies": {
     "@types/bun": "^1.0.0",
     "typescript": "^5.0.0",
-    "@checkstack/tsconfig": "0.0.2",
-    "@checkstack/scripts": "0.1.0"
+    "@checkstack/tsconfig": "0.0.3",
+    "@checkstack/scripts": "0.1.1"
   }
 }

package/src/execute-collector.test.ts

@@ -100,7 +100,7 @@ describe("ExecuteCollector", () => {
     });
   });
 
-  describe("aggregateResult", () => {
+  describe("mergeResult", () => {
     it("should calculate average execution time and success rate", () => {
       const collector = new ExecuteCollector();
       const runs = [
@@ -136,10 +136,11 @@ describe("ExecuteCollector", () => {
         },
       ];
 
-      const aggregated = collector.aggregateResult(runs);
+      let aggregated = collector.mergeResult(undefined, runs[0]);
+      aggregated = collector.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.avgExecutionTimeMs).toBe(75);
-      expect(aggregated.successRate).toBe(100);
+      expect(aggregated.avgExecutionTimeMs.avg).toBe(75);
+      expect(aggregated.successRate.rate).toBe(100);
     });
 
     it("should calculate success rate correctly", () => {
@@ -177,9 +178,10 @@ describe("ExecuteCollector", () => {
         },
       ];
 
-      const aggregated = collector.aggregateResult(runs);
+      let aggregated = collector.mergeResult(undefined, runs[0]);
+      aggregated = collector.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.successRate).toBe(50);
+      expect(aggregated.successRate.rate).toBe(50);
     });
   });
 

package/src/execute-collector.ts

@@ -1,9 +1,16 @@
 import {
   Versioned,
   z,
+  configString,
   type HealthCheckRunForAggregation,
   type CollectorResult,
   type CollectorStrategy,
+  mergeAverage,
+  mergeRate,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedRate,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import {
   healthResultNumber,
@@ -19,7 +26,9 @@ import type { ScriptTransportClient } from "./transport-client";
 // ============================================================================
 
 const executeConfigSchema = z.object({
-  command: z.string().min(1).describe("Command or script path to execute"),
+  command: configString({
+    "x-editor-types": ["shell"],
+  }).describe("Shell command or script to execute"),
   args: z.array(z.string()).default([]).describe("Command arguments"),
   cwd: z.string().optional().describe("Working directory"),
   env: z
@@ -69,20 +78,24 @@ const executeResultSchema = healthResultSchema({
 
 export type ExecuteResult = z.infer<typeof executeResultSchema>;
 
-const executeAggregatedSchema = healthResultSchema({
-  avgExecutionTimeMs: healthResultNumber({
+// Aggregated result fields definition
+const executeAggregatedFields = {
+  avgExecutionTimeMs: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Execution Time",
     "x-chart-unit": "ms",
   }),
-  successRate: healthResultNumber({
+  successRate: aggregatedRate({
     "x-chart-type": "gauge",
     "x-chart-label": "Success Rate",
     "x-chart-unit": "%",
   }),
-});
+};
 
-export type ExecuteAggregatedResult = z.infer<typeof executeAggregatedSchema>;
+// Type inferred from field definitions
+export type ExecuteAggregatedResult = InferAggregatedResult<
+  typeof executeAggregatedFields
+>;
 
 // ============================================================================
 // EXECUTE COLLECTOR
@@ -92,15 +105,12 @@ export type ExecuteAggregatedResult = z.infer<typeof executeAggregatedSchema>;
  * Built-in Script execute collector.
  * Runs commands and checks results.
  */
-export class ExecuteCollector
-  implements
-    CollectorStrategy<
-      ScriptTransportClient,
-      ExecuteConfig,
-      ExecuteResult,
-      ExecuteAggregatedResult
-    >
-{
+export class ExecuteCollector implements CollectorStrategy<
+  ScriptTransportClient,
+  ExecuteConfig,
+  ExecuteResult,
+  ExecuteAggregatedResult
+> {
   id = "execute";
   displayName = "Execute Script";
   description = "Execute a command or script and check the result";
@@ -111,9 +121,9 @@ export class ExecuteCollector
 
   config = new Versioned({ version: 1, schema: executeConfigSchema });
   result = new Versioned({ version: 1, schema: executeResultSchema });
-  aggregatedResult = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: executeAggregatedSchema,
+    fields: executeAggregatedFields,
   });
 
   async execute({
@@ -152,28 +162,18 @@ export class ExecuteCollector
     };
   }
 
-  aggregateResult(
-    runs: HealthCheckRunForAggregation<ExecuteResult>[]
+  mergeResult(
+    existing: ExecuteAggregatedResult | undefined,
+    run: HealthCheckRunForAggregation<ExecuteResult>,
   ): ExecuteAggregatedResult {
-    const times = runs
-      .map((r) => r.metadata?.executionTimeMs)
-      .filter((v): v is number => typeof v === "number");
-
-    const successes = runs
-      .map((r) => r.metadata?.success)
-      .filter((v): v is boolean => typeof v === "boolean");
-
-    const successCount = successes.filter(Boolean).length;
+    const metadata = run.metadata;
 
     return {
-      avgExecutionTimeMs:
-        times.length > 0
-          ? Math.round(times.reduce((a, b) => a + b, 0) / times.length)
-          : 0,
-      successRate:
-        successes.length > 0
-          ? Math.round((successCount / successes.length) * 100)
-          : 0,
+      avgExecutionTimeMs: mergeAverage(
+        existing?.avgExecutionTimeMs,
+        metadata?.executionTimeMs,
+      ),
+      successRate: mergeRate(existing?.successRate, metadata?.success),
     };
   }
 }

package/src/index.ts

@@ -2,6 +2,7 @@ import { createBackendPlugin, coreServices } from "@checkstack/backend-api";
 import { ScriptHealthCheckStrategy } from "./strategy";
 import { pluginMetadata } from "./plugin-metadata";
 import { ExecuteCollector } from "./execute-collector";
+import { InlineScriptCollector } from "./inline-script-collector";
 
 export default createBackendPlugin({
   metadata: pluginMetadata,
@@ -17,6 +18,7 @@ export default createBackendPlugin({
         const strategy = new ScriptHealthCheckStrategy();
         healthCheckRegistry.register(strategy);
         collectorRegistry.register(new ExecuteCollector());
+        collectorRegistry.register(new InlineScriptCollector());
       },
     });
   },

package/src/inline-script-collector.test.ts

@@ -0,0 +1,256 @@
+import { describe, it, expect } from "bun:test";
+import {
+  InlineScriptCollector,
+  type InlineScriptConfig,
+} from "./inline-script-collector";
+import type { ScriptTransportClient } from "./transport-client";
+
+/**
+ * Unit tests for the Inline Script Collector.
+ *
+ * Tests cover:
+ * - Basic script execution
+ * - Return value handling
+ * - Error handling
+ * - Timeout protection
+ */
+
+// Mock client (not actually used by InlineScriptCollector, but required by interface)
+const mockClient: ScriptTransportClient = {
+  exec: async () => ({
+    exitCode: 0,
+    stdout: "",
+    stderr: "",
+    timedOut: false,
+  }),
+};
+
+function createConfig(
+  overrides: Partial<InlineScriptConfig> = {},
+): InlineScriptConfig {
+  return {
+    script: "return { success: true };",
+    timeout: 5000,
+    ...overrides,
+  };
+}
+
+describe("InlineScriptCollector", () => {
+  const collector = new InlineScriptCollector();
+
+  // ─────────────────────────────────────────────────────────────
+  // Metadata
+  // ─────────────────────────────────────────────────────────────
+
+  describe("metadata", () => {
+    it("has correct basic metadata", () => {
+      expect(collector.id).toBe("inline-script");
+      expect(collector.displayName).toBe("Inline Script");
+      expect(collector.description).toContain("TypeScript");
+    });
+
+    it("allows multiple instances", () => {
+      expect(collector.allowMultiple).toBe(true);
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────
+  // Basic Execution
+  // ─────────────────────────────────────────────────────────────
+
+  describe("execute - basic", () => {
+    it("executes script returning success object", async () => {
+      const config = createConfig({
+        script: 'return { success: true, message: "All good" };',
+      });
+
+      const result = await collector.execute({
+        config,
+        client: mockClient,
+        pluginId: "script",
+      });
+
+      expect(result.result.success).toBe(true);
+      expect(result.result.message).toBe("All good");
+      expect(result.error).toBeUndefined();
+    });
+
+    it("executes script returning boolean", async () => {
+      const config = createConfig({
+        script: "return true;",
+      });
+
+      const result = await collector.execute({
+        config,
+        client: mockClient,
+        pluginId: "script",
+      });
+
+      expect(result.result.success).toBe(true);
+    });
+
+    it("executes script with no return (defaults to success)", async () => {
+      const config = createConfig({
+        script: "const x = 1 + 1;",
+      });
+
+      const result = await collector.execute({
+        config,
+        client: mockClient,
+        pluginId: "script",
+      });
+
+      expect(result.result.success).toBe(true);
+    });
+
+    it("executes async script", async () => {
+      const config = createConfig({
+        script: `
+          await Promise.resolve();
+          return { success: true, message: "async works" };
+        `,
+      });
+
+      const result = await collector.execute({
+        config,
+        client: mockClient,
+        pluginId: "script",
+      });
+
+      expect(result.result.success).toBe(true);
+      expect(result.result.message).toBe("async works");
+    });
+
+    it("captures numeric value from script", async () => {
+      const config = createConfig({
+        script: "return { success: true, value: 42 };",
+      });
+
+      const result = await collector.execute({
+        config,
+        client: mockClient,
+        pluginId: "script",
+      });
+
+      expect(result.result.value).toBe(42);
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────
+  // Failure Handling
+  // ─────────────────────────────────────────────────────────────
+
+  describe("execute - failures", () => {
+    it("handles script returning false", async () => {
+      const config = createConfig({
+        script: "return false;",
+      });
+
+      const result = await collector.execute({
+        config,
+        client: mockClient,
+        pluginId: "script",
+      });
+
+      expect(result.result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    it("handles script returning success: false", async () => {
+      const config = createConfig({
+        script: 'return { success: false, message: "Check failed" };',
+      });
+
+      const result = await collector.execute({
+        config,
+        client: mockClient,
+        pluginId: "script",
+      });
+
+      expect(result.result.success).toBe(false);
+      expect(result.result.message).toBe("Check failed");
+      expect(result.error).toBe("Check failed");
+    });
+
+    it("handles script errors", async () => {
+      const config = createConfig({
+        script: 'throw new Error("Something went wrong");',
+      });
+
+      const result = await collector.execute({
+        config,
+        client: mockClient,
+        pluginId: "script",
+      });
+
+      expect(result.result.success).toBe(false);
+      expect(result.error).toContain("Something went wrong");
+    });
+
+    it("handles syntax errors", async () => {
+      const config = createConfig({
+        script: "const x = {",
+      });
+
+      const result = await collector.execute({
+        config,
+        client: mockClient,
+        pluginId: "script",
+      });
+
+      expect(result.result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────
+  // Timeout
+  // ─────────────────────────────────────────────────────────────
+
+  describe("execute - timeout", () => {
+    it("times out long-running scripts", async () => {
+      const config = createConfig({
+        script: `
+          await new Promise(resolve => setTimeout(resolve, 5000));
+          return { success: true };
+        `,
+        timeout: 1000,
+      });
+
+      const result = await collector.execute({
+        config,
+        client: mockClient,
+        pluginId: "script",
+      });
+
+      expect(result.result.success).toBe(false);
+      expect(result.result.timedOut).toBe(true);
+      expect(result.error).toContain("timed out");
+    }, 10000);
+  });
+
+  // ─────────────────────────────────────────────────────────────
+  // Aggregation
+  // ─────────────────────────────────────────────────────────────
+
+  describe("mergeResult", () => {
+    it("aggregates execution time and success rate", () => {
+      const run1 = {
+        metadata: { success: true, executionTimeMs: 100, timedOut: false },
+      };
+      const run2 = {
+        metadata: { success: true, executionTimeMs: 200, timedOut: false },
+      };
+      const run3 = {
+        metadata: { success: false, executionTimeMs: 150, timedOut: false },
+      };
+
+      let aggregated = collector.mergeResult(undefined, run1 as never);
+      aggregated = collector.mergeResult(aggregated, run2 as never);
+      aggregated = collector.mergeResult(aggregated, run3 as never);
+
+      expect(aggregated.avgExecutionTimeMs.avg).toBe(150); // (100+200+150)/3
+      expect(aggregated.successRate.rate).toBeCloseTo(67, 0); // 2/3 * 100 = ~67
+    });
+  });
+});

package/src/inline-script-collector.ts

@@ -0,0 +1,348 @@
+import {
+  Versioned,
+  z,
+  configString,
+  configNumber,
+  type HealthCheckRunForAggregation,
+  type CollectorResult,
+  type CollectorStrategy,
+  mergeAverage,
+  mergeRate,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedRate,
+  type InferAggregatedResult,
+} from "@checkstack/backend-api";
+import {
+  healthResultNumber,
+  healthResultString,
+  healthResultBoolean,
+  healthResultSchema,
+} from "@checkstack/healthcheck-common";
+import { pluginMetadata } from "./plugin-metadata";
+import type { ScriptTransportClient } from "./transport-client";
+
+// ============================================================================
+// SCRIPT EXECUTION UTILITIES (shared with integration-script-backend pattern)
+// ============================================================================
+
+/**
+ * Context available to inline scripts.
+ */
+interface ScriptContext {
+  /** Health check configuration */
+  config: Record<string, unknown>;
+  /** Fetch API for HTTP requests */
+  fetch: typeof fetch;
+}
+
+/**
+ * Safe console interface for scripts.
+ */
+interface SafeConsole {
+  log: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+  info: (...args: unknown[]) => void;
+}
+
+/**
+ * Expected return type from health check scripts.
+ */
+interface ScriptHealthResult {
+  /** Whether the health check passed */
+  success: boolean;
+  /** Optional message describing the result */
+  message?: string;
+  /** Optional numeric value for metrics */
+  value?: number;
+}
+
+/**
+ * Execute an inline script with the given context.
+ */
+async function executeInlineScript({
+  script,
+  context,
+  safeConsole,
+  timeoutMs,
+}: {
+  script: string;
+  context: ScriptContext;
+  safeConsole: SafeConsole;
+  timeoutMs: number;
+}): Promise<{
+  result: ScriptHealthResult | undefined;
+  error?: string;
+  timedOut: boolean;
+}> {
+  try {
+    // Create an async function from the script
+    const asyncFn = new Function(
+      "context",
+      "console",
+      "fetch",
+      `return (async () => { ${script} })();`,
+    );
+
+    // Execute with timeout
+    const result = await Promise.race([
+      asyncFn(context, safeConsole, fetch),
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error("__TIMEOUT__")), timeoutMs),
+      ),
+    ]);
+
+    // Normalize result
+    if (result === undefined || result === null) {
+      return { result: { success: true }, timedOut: false };
+    }
+
+    if (typeof result === "boolean") {
+      return { result: { success: result }, timedOut: false };
+    }
+
+    if (typeof result === "object") {
+      return {
+        result: {
+          success: Boolean(result.success ?? true),
+          message: result.message,
+          value: result.value,
+        },
+        timedOut: false,
+      };
+    }
+
+    return {
+      result: { success: true, message: String(result) },
+      timedOut: false,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message === "__TIMEOUT__") {
+      return {
+        result: undefined,
+        error: "Script execution timed out",
+        timedOut: true,
+      };
+    }
+    return { result: undefined, error: message, timedOut: false };
+  }
+}
+
+// ============================================================================
+// CONFIGURATION SCHEMA
+// ============================================================================
+
+const inlineScriptConfigSchema = z.object({
+  script: configString({
+    "x-editor-types": ["typescript"],
+  }).describe(
+    "TypeScript/JavaScript code to execute. Return { success: boolean, message?: string, value?: number }",
+  ),
+  timeout: configNumber({})
+    .min(1000)
+    .max(60_000)
+    .default(10_000)
+    .describe("Maximum execution time in milliseconds"),
+});
+
+export type InlineScriptConfig = z.infer<typeof inlineScriptConfigSchema>;
+
+// ============================================================================
+// RESULT SCHEMAS
+// ============================================================================
+
+const inlineScriptResultSchema = healthResultSchema({
+  success: healthResultBoolean({
+    "x-chart-type": "boolean",
+    "x-chart-label": "Success",
+  }),
+  message: healthResultString({
+    "x-chart-type": "text",
+    "x-chart-label": "Message",
+  }).optional(),
+  value: healthResultNumber({
+    "x-chart-type": "line",
+    "x-chart-label": "Value",
+  }).optional(),
+  executionTimeMs: healthResultNumber({
+    "x-chart-type": "line",
+    "x-chart-label": "Execution Time",
+    "x-chart-unit": "ms",
+  }),
+  timedOut: healthResultBoolean({
+    "x-chart-type": "boolean",
+    "x-chart-label": "Timed Out",
+  }),
+});
+
+export type InlineScriptResult = z.infer<typeof inlineScriptResultSchema>;
+
+// Aggregated result fields definition
+const inlineScriptAggregatedFields = {
+  avgExecutionTimeMs: aggregatedAverage({
+    "x-chart-type": "line",
+    "x-chart-label": "Avg Execution Time",
+    "x-chart-unit": "ms",
+  }),
+  successRate: aggregatedRate({
+    "x-chart-type": "gauge",
+    "x-chart-label": "Success Rate",
+    "x-chart-unit": "%",
+  }),
+};
+
+// Type inferred from field definitions
+export type InlineScriptAggregatedResult = InferAggregatedResult<
+  typeof inlineScriptAggregatedFields
+>;
+
+// ============================================================================
+// INLINE SCRIPT COLLECTOR
+// ============================================================================
+
+/**
+ * Inline Script collector for health checks.
+ * Executes TypeScript/JavaScript code directly and checks the result.
+ *
+ * Scripts should return an object with:
+ * - success: boolean - Whether the check passed
+ * - message?: string - Optional status message
+ * - value?: number - Optional numeric value for metrics
+ *
+ * Scripts have access to:
+ * - context.config - The collector configuration
+ * - console.log/warn/error - Logging functions
+ * - fetch - HTTP client for making requests
+ *
+ * @example
+ * ```typescript
+ * // Simple check
+ * return { success: true, message: "All good!" };
+ *
+ * // HTTP health check
+ * const response = await fetch("https://api.example.com/health");
+ * return {
+ *   success: response.ok,
+ *   message: `Status: ${response.status}`,
+ *   value: response.status
+ * };
+ * ```
+ */
+export class InlineScriptCollector implements CollectorStrategy<
+  ScriptTransportClient,
+  InlineScriptConfig,
+  InlineScriptResult,
+  InlineScriptAggregatedResult
+> {
+  id = "inline-script";
+  displayName = "Inline Script";
+  description = "Execute TypeScript/JavaScript code for health checking";
+
+  supportedPlugins = [pluginMetadata];
+
+  allowMultiple = true;
+
+  config = new Versioned({ version: 1, schema: inlineScriptConfigSchema });
+  result = new Versioned({ version: 1, schema: inlineScriptResultSchema });
+  aggregatedResult = new VersionedAggregated({
+    version: 1,
+    fields: inlineScriptAggregatedFields,
+  });
+
+  async execute({
+    config,
+  }: {
+    config: InlineScriptConfig;
+    client: ScriptTransportClient;
+    pluginId: string;
+  }): Promise<CollectorResult<InlineScriptResult>> {
+    const startTime = Date.now();
+
+    // Build context for the script
+    const scriptContext: ScriptContext = {
+      config: config as unknown as Record<string, unknown>,
+      fetch,
+    };
+
+    // Create a safe console that captures logs
+    const logs: string[] = [];
+    const safeConsole: SafeConsole = {
+      log: (...args) => {
+        logs.push(
+          args
+            .map((a) => (typeof a === "object" ? JSON.stringify(a) : String(a)))
+            .join(" "),
+        );
+      },
+      warn: (...args) => {
+        logs.push(
+          `[WARN] ${args.map((a) => (typeof a === "object" ? JSON.stringify(a) : String(a))).join(" ")}`,
+        );
+      },
+      error: (...args) => {
+        logs.push(
+          `[ERROR] ${args.map((a) => (typeof a === "object" ? JSON.stringify(a) : String(a))).join(" ")}`,
+        );
+      },
+      info: (...args) => {
+        logs.push(
+          `[INFO] ${args.map((a) => (typeof a === "object" ? JSON.stringify(a) : String(a))).join(" ")}`,
+        );
+      },
+    };
+
+    // Execute the script
+    const { result, error, timedOut } = await executeInlineScript({
+      script: config.script,
+      context: scriptContext,
+      safeConsole,
+      timeoutMs: config.timeout,
+    });
+
+    const executionTimeMs = Date.now() - startTime;
+
+    if (error) {
+      return {
+        result: {
+          success: false,
+          message: error,
+          executionTimeMs,
+          timedOut,
+        },
+        error,
+      };
+    }
+
+    return {
+      result: {
+        success: result?.success ?? true,
+        message:
+          result?.message ?? (logs.length > 0 ? logs.join("\n") : undefined),
+        value: result?.value,
+        executionTimeMs,
+        timedOut: false,
+      },
+      error:
+        result?.success === false
+          ? (result.message ?? "Check failed")
+          : undefined,
+    };
+  }
+
+  mergeResult(
+    existing: InlineScriptAggregatedResult | undefined,
+    run: HealthCheckRunForAggregation<InlineScriptResult>,
+  ): InlineScriptAggregatedResult {
+    const metadata = run.metadata;
+
+    return {
+      avgExecutionTimeMs: mergeAverage(
+        existing?.avgExecutionTimeMs,
+        metadata?.executionTimeMs,
+      ),
+      successRate: mergeRate(existing?.successRate, metadata?.success),
+    };
+  }
+}

package/src/strategy.test.ts

@@ -138,7 +138,7 @@ describe("ScriptHealthCheckStrategy", () => {
     });
   });
 
-  describe("aggregateResult", () => {
+  describe("mergeResult", () => {
     it("should calculate averages correctly", () => {
       const strategy = new ScriptHealthCheckStrategy();
       const runs = [
@@ -172,12 +172,13 @@ describe("ScriptHealthCheckStrategy", () => {
         },
       ];
 
-      const aggregated = strategy.aggregateResult(runs);
+      let aggregated = strategy.mergeResult(undefined, runs[0]);
+      aggregated = strategy.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.avgExecutionTime).toBe(75);
-      expect(aggregated.successRate).toBe(100);
-      expect(aggregated.errorCount).toBe(0);
-      expect(aggregated.timeoutCount).toBe(0);
+      expect(aggregated.avgExecutionTime.avg).toBe(75);
+      expect(aggregated.successRate.rate).toBe(100);
+      expect(aggregated.errorCount.count).toBe(0);
+      expect(aggregated.timeoutCount.count).toBe(0);
     });
 
     it("should count errors and timeouts", () => {
@@ -213,11 +214,12 @@ describe("ScriptHealthCheckStrategy", () => {
         },
       ];
 
-      const aggregated = strategy.aggregateResult(runs);
+      let aggregated = strategy.mergeResult(undefined, runs[0]);
+      aggregated = strategy.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.errorCount).toBe(1);
-      expect(aggregated.timeoutCount).toBe(1);
-      expect(aggregated.successRate).toBe(0);
+      expect(aggregated.errorCount.count).toBe(1);
+      expect(aggregated.timeoutCount.count).toBe(1);
+      expect(aggregated.successRate.rate).toBe(0);
     });
   });
 });

package/src/strategy.ts

@@ -3,8 +3,16 @@ import {
   HealthCheckStrategy,
   HealthCheckRunForAggregation,
   Versioned,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedRate,
+  aggregatedCounter,
+  mergeAverage,
+  mergeRate,
+  mergeCounter,
   z,
   type ConnectedClient,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import {
   healthResultBoolean,
@@ -79,31 +87,31 @@ const scriptResultSchema = healthResultSchema({
 
 type ScriptResult = z.infer<typeof scriptResultSchema>;
 
-/**
- * Aggregated metadata for buckets.
- */
-const scriptAggregatedSchema = healthResultSchema({
-  avgExecutionTime: healthResultNumber({
+/** Aggregated field definitions for bucket merging */
+const scriptAggregatedFields = {
+  avgExecutionTime: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Execution Time",
     "x-chart-unit": "ms",
   }),
-  successRate: healthResultNumber({
+  successRate: aggregatedRate({
     "x-chart-type": "gauge",
     "x-chart-label": "Success Rate",
     "x-chart-unit": "%",
   }),
-  errorCount: healthResultNumber({
+  errorCount: aggregatedCounter({
     "x-chart-type": "counter",
     "x-chart-label": "Errors",
   }),
-  timeoutCount: healthResultNumber({
+  timeoutCount: aggregatedCounter({
     "x-chart-type": "counter",
     "x-chart-label": "Timeouts",
   }),
-});
+};
 
-type ScriptAggregatedResult = z.infer<typeof scriptAggregatedSchema>;
+type ScriptAggregatedResult = InferAggregatedResult<
+  typeof scriptAggregatedFields
+>;
 
 // ============================================================================
 // SCRIPT EXECUTOR INTERFACE (for testability)
@@ -182,15 +190,12 @@ const defaultScriptExecutor: ScriptExecutor = {
 // STRATEGY
 // ============================================================================
 
-export class ScriptHealthCheckStrategy
-  implements
-    HealthCheckStrategy<
-      ScriptConfig,
-      ScriptTransportClient,
-      ScriptResult,
-      ScriptAggregatedResult
-    >
-{
+export class ScriptHealthCheckStrategy implements HealthCheckStrategy<
+  ScriptConfig,
+  ScriptTransportClient,
+  ScriptResult,
+  typeof scriptAggregatedFields
+> {
   id = "script";
   displayName = "Script Health Check";
   description = "Execute local scripts or commands for health checking";
@@ -229,59 +234,36 @@ export class ScriptHealthCheckStrategy
     ],
   });
 
-  aggregatedResult: Versioned<ScriptAggregatedResult> = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: scriptAggregatedSchema,
+    fields: scriptAggregatedFields,
   });
 
-  aggregateResult(
-    runs: HealthCheckRunForAggregation<ScriptResult>[]
+  mergeResult(
+    existing: ScriptAggregatedResult | undefined,
+    run: HealthCheckRunForAggregation<ScriptResult>,
   ): ScriptAggregatedResult {
-    const validRuns = runs.filter((r) => r.metadata);
-
-    if (validRuns.length === 0) {
-      return {
-        avgExecutionTime: 0,
-        successRate: 0,
-        errorCount: 0,
-        timeoutCount: 0,
-      };
-    }
+    const metadata = run.metadata;
 
-    const executionTimes = validRuns
-      .map((r) => r.metadata?.executionTimeMs)
-      .filter((t): t is number => typeof t === "number");
+    const avgExecutionTime = mergeAverage(
+      existing?.avgExecutionTime,
+      metadata?.executionTimeMs,
+    );
 
-    const avgExecutionTime =
-      executionTimes.length > 0
-        ? Math.round(
-            executionTimes.reduce((a, b) => a + b, 0) / executionTimes.length
-          )
-        : 0;
+    const isSuccess = metadata?.success ?? false;
+    const successRate = mergeRate(existing?.successRate, isSuccess);
 
-    const successCount = validRuns.filter(
-      (r) => r.metadata?.success === true
-    ).length;
-    const successRate = Math.round((successCount / validRuns.length) * 100);
+    const hasError = metadata?.error !== undefined;
+    const errorCount = mergeCounter(existing?.errorCount, hasError);
 
-    const errorCount = validRuns.filter(
-      (r) => r.metadata?.error !== undefined
-    ).length;
+    const hasTimeout = metadata?.timedOut === true;
+    const timeoutCount = mergeCounter(existing?.timeoutCount, hasTimeout);
 
-    const timeoutCount = validRuns.filter(
-      (r) => r.metadata?.timedOut === true
-    ).length;
-
-    return {
-      avgExecutionTime,
-      successRate,
-      errorCount,
-      timeoutCount,
-    };
+    return { avgExecutionTime, successRate, errorCount, timeoutCount };
   }
 
   async createClient(
-    _config: ScriptConfigInput
+    _config: ScriptConfigInput,
   ): Promise<ConnectedClient<ScriptTransportClient>> {
     const client: ScriptTransportClient = {
       exec: async (request: ScriptRequest): Promise<ScriptResultType> => {