blokctl 0.6.21 → 0.7.0

package/dist/commands/dev/index.js

@@ -1,9 +1,12 @@
 import { spawn } from "node:child_process";
+import child_process from "node:child_process";
 import path from "node:path";
+import util from "node:util";
 import fsExtra from "fs-extra";
 import { waitForGrpcPort } from "../../services/health-probe.js";
 import { detectRr } from "../../services/runtime-detector.js";
-import { readProjectConfig, validateProjectRuntimes } from "../../services/runtime-setup.js";
+import { generateCSharpNodeRegistry, generateGoNodeRegistry, generateJavaNodeRegistry, generateRustNodeRegistry, readProjectConfig, validateProjectRuntimes, } from "../../services/runtime-setup.js";
+const exec = util.promisify(child_process.exec);
 const runningProcesses = [];
 function spawnProcess(cmd, args, name, currentPath, cwd, env) {
     const child = spawn(cmd, args, {
@@ -98,6 +101,42 @@ export async function devProject(opts) {
                 HOST: "0.0.0.0",
                 BLOK_TRANSPORT: "grpc",
             };
+            if (rt.kind === "python3" || rt.kind === "ruby" || rt.kind === "php") {
+                env.BLOK_NODES_DIR = path.resolve(currentPath, "runtimes", rt.kind, "nodes");
+            }
+            if (rt.kind === "go") {
+                try {
+                    generateGoNodeRegistry(currentPath);
+                }
+                catch (err) {
+                    console.log(`  Warning: Go user-node codegen failed: ${err.message}`);
+                }
+            }
+            if (rt.kind === "rust") {
+                try {
+                    generateRustNodeRegistry(currentPath);
+                }
+                catch (err) {
+                    console.log(`  Warning: Rust user-node codegen failed: ${err.message}`);
+                }
+            }
+            if (rt.kind === "csharp") {
+                try {
+                    generateCSharpNodeRegistry(currentPath);
+                }
+                catch (err) {
+                    console.log(`  Warning: C# user-node codegen failed: ${err.message}`);
+                }
+            }
+            if (rt.kind === "java") {
+                try {
+                    generateJavaNodeRegistry(currentPath);
+                    await exec("mvn package -q -DskipTests", { cwd: runtimeCwd, timeout: 300000 });
+                }
+                catch (err) {
+                    console.log(`  Warning: Java user-node codegen/build failed: ${err.message}`);
+                }
+            }
             runtimeDefs.push({
                 cmd,
                 args,

package/dist/commands/generate/NodeGenerator.d.ts

@@ -7,8 +7,6 @@ type NodeInformation = {
         errors: string[];
         warnings: string[];
         attempts: number;
-        promptVersion?: string;
-        durationMs?: number;
     };
 };
 export type { NodeInformation };

package/dist/commands/generate/NodeGenerator.js

@@ -1,8 +1,6 @@
 import * as fs from "node:fs";
 import { createOpenAI } from "@ai-sdk/openai";
 import { generateText } from "ai";
-import { GenerationAnalytics } from "./GenerationAnalytics.js";
-import { getVersionStamp, registerPromptContent } from "./PromptVersioning.js";
 import createFnNodeSystemPrompt from "./prompts/create-fn-node.system.js";
 import createNodeSystemPrompt from "./prompts/create-node.system.js";
 import * as CompilationValidator from "./validators/CompilationValidator.js";
@@ -10,10 +8,6 @@ import * as NodeValidator from "./validators/NodeValidator.js";
 export default class NodeGenerator {
     MAX_VALIDATION_ATTEMPTS = 3;
     async generateNode(nodeName, userPrompt, apiKey, update = false, nodeStyle = "function") {
-        const analytics = GenerationAnalytics.getInstance();
-        const getElapsed = analytics.startTimer();
-        const promptId = nodeStyle === "function" ? "create-fn-node" : "create-node";
-        const promptVersion = getVersionStamp(promptId);
         const openai = createOpenAI({
             compatibility: "strict",
             apiKey: apiKey,
@@ -21,7 +15,6 @@ export default class NodeGenerator {
         const promptTemplate = nodeStyle === "function" ? createFnNodeSystemPrompt : createNodeSystemPrompt;
         let prompt = promptTemplate.prompt;
         let existingCode = null;
-        registerPromptContent(promptId, prompt);
         if (update) {
             const dirName = nodeName.toLowerCase().replace(/\s+/g, "-");
             const dirPath = process.cwd();
@@ -72,17 +65,6 @@ export default class NodeGenerator {
                 console.log(`⚠️  Validation failed (attempt ${attempts}/${this.MAX_VALIDATION_ATTEMPTS}). Retrying with feedback...`);
             }
         }
-        const durationMs = getElapsed();
-        analytics.recordEvent({
-            type: "node",
-            subtype: nodeStyle,
-            name: nodeName,
-            success: isValid,
-            attempts,
-            durationMs,
-            errors: allErrors,
-            promptVersion,
-        });
         return {
             nodeName,
             userPrompt,
@@ -92,8 +74,6 @@ export default class NodeGenerator {
                 errors: validationErrors,
                 warnings: validationWarnings,
                 attempts,
-                promptVersion,
-                durationMs,
             },
         };
     }

package/dist/commands/generate/RuntimeGenerator.d.ts

@@ -11,8 +11,6 @@ export type RuntimeInformation = {
         errors: string[];
         warnings: string[];
         attempts: number;
-        promptVersion?: string;
-        durationMs?: number;
     };
 };
 declare const SUPPORTED_LANGUAGES: readonly ["go", "java", "rust", "python", "csharp", "php", "ruby"];

package/dist/commands/generate/RuntimeGenerator.js

@@ -1,8 +1,6 @@
 import * as fs from "node:fs";
 import { createOpenAI } from "@ai-sdk/openai";
 import { generateText } from "ai";
-import { GenerationAnalytics } from "./GenerationAnalytics.js";
-import { getVersionStamp, registerPromptContent } from "./PromptVersioning.js";
 import createRuntimeSystemPrompt from "./prompts/create-runtime.system.js";
 const SUPPORTED_LANGUAGES = ["go", "java", "rust", "python", "csharp", "php", "ruby"];
 export function isSupportedLanguage(lang) {
@@ -11,15 +9,11 @@ export function isSupportedLanguage(lang) {
 export default class RuntimeGenerator {
     MAX_VALIDATION_ATTEMPTS = 3;
     async generateRuntime(language, userPrompt, apiKey, update = false, existingPath) {
-        const analytics = GenerationAnalytics.getInstance();
-        const getElapsed = analytics.startTimer();
-        const promptVersion = getVersionStamp("create-runtime");
         const openai = createOpenAI({
             compatibility: "strict",
             apiKey: apiKey,
         });
         let prompt = createRuntimeSystemPrompt.prompt;
-        registerPromptContent("create-runtime", prompt);
         if (update && existingPath) {
             const existingContent = this.readExistingRuntime(existingPath);
             prompt = `${createRuntimeSystemPrompt.updatePrompt}\n\n${existingContent}`;
@@ -54,17 +48,6 @@ export default class RuntimeGenerator {
             }
         }
         const files = this.parseFiles(generatedCode, language);
-        const durationMs = getElapsed();
-        analytics.recordEvent({
-            type: "node",
-            subtype: `runtime-${language}`,
-            name: `runtime-${language}`,
-            success: isValid,
-            attempts,
-            durationMs,
-            errors: allErrors,
-            promptVersion,
-        });
         return {
             language,
             userPrompt,
@@ -75,8 +58,6 @@ export default class RuntimeGenerator {
                 errors: validationErrors,
                 warnings: validationWarnings,
                 attempts,
-                promptVersion,
-                durationMs,
             },
         };
     }

package/dist/commands/generate/RuntimeGenerator.test.js

@@ -6,7 +6,6 @@ vi.mock("ai", () => ({
     generateText: vi.fn(),
 }));
 import { generateText } from "ai";
-import { GenerationAnalytics } from "./GenerationAnalytics.js";
 import RuntimeGenerator, { isSupportedLanguage } from "./RuntimeGenerator.js";
 const mockedGenerateText = vi.mocked(generateText);
 describe("RuntimeGenerator", () => {
@@ -15,7 +14,6 @@ describe("RuntimeGenerator", () => {
         generator = new RuntimeGenerator();
         vi.clearAllMocks();
         vi.spyOn(console, "log").mockImplementation(() => { });
-        GenerationAnalytics.resetInstance();
     });
     afterEach(() => {
         vi.restoreAllMocks();
@@ -433,39 +431,12 @@ func main() {
             expect(result.validationResult?.attempts).toBe(3);
             expect(result.validationResult?.errors.length).toBeGreaterThan(0);
         });
-        it("should record analytics event", async () => {
-            mockedGenerateText.mockResolvedValueOnce({ text: validGoRuntime });
-            await generator.generateRuntime("go", "test", "test-key");
-            const analytics = GenerationAnalytics.getInstance();
-            const stats = analytics.getStats();
-            expect(stats.totalGenerations).toBe(1);
-            expect(stats.successCount).toBe(1);
-        });
-        it("should record failed analytics event", async () => {
-            mockedGenerateText.mockResolvedValue({ text: "invalid" });
-            await generator.generateRuntime("java", "test", "test-key");
-            const analytics = GenerationAnalytics.getInstance();
-            const stats = analytics.getStats();
-            expect(stats.totalGenerations).toBe(1);
-            expect(stats.failureCount).toBe(1);
-        });
         it("should strip markdown fences from LLM output", async () => {
             const wrappedCode = `\`\`\`go\n${validGoRuntime}\n\`\`\``;
             mockedGenerateText.mockResolvedValueOnce({ text: wrappedCode });
             const result = await generator.generateRuntime("go", "test", "test-key");
             expect(result.validationResult?.valid).toBe(true);
         });
-        it("should include prompt version in validation result", async () => {
-            mockedGenerateText.mockResolvedValueOnce({ text: validGoRuntime });
-            const result = await generator.generateRuntime("go", "test", "test-key");
-            expect(result.validationResult?.promptVersion).toBe("create-runtime@1.0.0");
-        });
-        it("should include duration in validation result", async () => {
-            mockedGenerateText.mockResolvedValueOnce({ text: validGoRuntime });
-            const result = await generator.generateRuntime("go", "test", "test-key");
-            expect(result.validationResult?.durationMs).toBeDefined();
-            expect(typeof result.validationResult?.durationMs).toBe("number");
-        });
     });
     describe("language-specific validation", () => {
         it("should warn Go code without go.mod", () => {

package/dist/commands/generate/TriggerGenerator.d.ts

@@ -8,8 +8,6 @@ export type TriggerInformation = {
         errors: string[];
         warnings: string[];
         attempts: number;
-        promptVersion?: string;
-        durationMs?: number;
     };
 };
 export default class TriggerGenerator {

package/dist/commands/generate/TriggerGenerator.js

@@ -1,22 +1,16 @@
 import * as fs from "node:fs";
 import { createOpenAI } from "@ai-sdk/openai";
 import { generateText } from "ai";
-import { GenerationAnalytics } from "./GenerationAnalytics.js";
-import { getVersionStamp, registerPromptContent } from "./PromptVersioning.js";
 import createTriggerSystemPrompt from "./prompts/create-trigger.system.js";
 import * as CompilationValidator from "./validators/CompilationValidator.js";
 export default class TriggerGenerator {
     MAX_VALIDATION_ATTEMPTS = 3;
     async generateTrigger(triggerName, triggerType, userPrompt, apiKey, update = false, existingTriggerPath) {
-        const analytics = GenerationAnalytics.getInstance();
-        const getElapsed = analytics.startTimer();
-        const promptVersion = getVersionStamp("create-trigger");
         const openai = createOpenAI({
             compatibility: "strict",
             apiKey: apiKey,
         });
         let prompt = createTriggerSystemPrompt.prompt;
-        registerPromptContent("create-trigger", prompt);
         if (update && existingTriggerPath) {
             const existingContent = fs.readFileSync(existingTriggerPath, "utf8");
             prompt = `${createTriggerSystemPrompt.updatePrompt}\n\n${existingContent}`;
@@ -58,17 +52,6 @@ export default class TriggerGenerator {
                 console.log(`⚠️  Trigger validation failed (attempt ${attempts}/${this.MAX_VALIDATION_ATTEMPTS}). Retrying with feedback...`);
             }
         }
-        const durationMs = getElapsed();
-        analytics.recordEvent({
-            type: "trigger",
-            subtype: triggerType,
-            name: triggerName,
-            success: isValid,
-            attempts,
-            durationMs,
-            errors: allErrors,
-            promptVersion,
-        });
         return {
             triggerName,
             triggerType,
@@ -79,8 +62,6 @@ export default class TriggerGenerator {
                 errors: validationErrors,
                 warnings: validationWarnings,
                 attempts,
-                promptVersion,
-                durationMs,
             },
         };
     }

package/dist/commands/generate/WorkflowGenerator.d.ts

@@ -8,8 +8,6 @@ export type WorkflowInformation = {
         errors: string[];
         warnings: string[];
         attempts: number;
-        promptVersion?: string;
-        durationMs?: number;
     };
 };
 export default class WorkflowGenerator {

package/dist/commands/generate/WorkflowGenerator.js

@@ -1,22 +1,16 @@
 import * as fs from "node:fs";
 import { createOpenAI } from "@ai-sdk/openai";
 import { generateText } from "ai";
-import { GenerationAnalytics } from "./GenerationAnalytics.js";
-import { getVersionStamp, registerPromptContent } from "./PromptVersioning.js";
 import createWorkflowSystemPrompt from "./prompts/create-workflow.system.js";
 import * as WorkflowValidator from "./validators/WorkflowValidator.js";
 export default class WorkflowGenerator {
     MAX_VALIDATION_ATTEMPTS = 3;
     async generateWorkflow(workflowName, userPrompt, apiKey, triggerType, update = false, existingWorkflowPath) {
-        const analytics = GenerationAnalytics.getInstance();
-        const getElapsed = analytics.startTimer();
-        const promptVersion = getVersionStamp("create-workflow");
         const openai = createOpenAI({
             compatibility: "strict",
             apiKey: apiKey,
         });
         let prompt = createWorkflowSystemPrompt.prompt;
-        registerPromptContent("create-workflow", prompt);
         if (update && existingWorkflowPath) {
             const existingContent = fs.readFileSync(existingWorkflowPath, "utf8");
             prompt = `${createWorkflowSystemPrompt.updatePrompt}\n\n${existingContent}`;
@@ -50,17 +44,6 @@ export default class WorkflowGenerator {
                 console.log(`⚠️  Workflow validation failed (attempt ${attempts}/${this.MAX_VALIDATION_ATTEMPTS}). Retrying with feedback...`);
             }
         }
-        const durationMs = getElapsed();
-        analytics.recordEvent({
-            type: "workflow",
-            subtype: triggerType,
-            name: workflowName,
-            success: isValid,
-            attempts,
-            durationMs,
-            errors: allErrors,
-            promptVersion,
-        });
         return {
             workflowName,
             userPrompt,
@@ -71,8 +54,6 @@ export default class WorkflowGenerator {
                 errors: validationErrors,
                 warnings: validationWarnings,
                 attempts,
-                promptVersion,
-                durationMs,
             },
         };
     }

package/dist/commands/generate/e2e/NodeGenerator.e2e.test.js

@@ -115,18 +115,6 @@ describe("NodeGenerator E2E", () => {
             const callArgs = mockedGenerateText.mock.calls[0][0];
             expect(callArgs.temperature).toBe(0.2);
         });
-        it("should include prompt version in validation result", async () => {
-            mockedGenerateText.mockResolvedValueOnce({ text: VALID_FUNCTION_FIRST_NODE });
-            mockValidPass();
-            const result = await generator.generateNode("test-node", "Create a test node", "test-api-key", false, "function");
-            expect(result.validationResult.promptVersion).toContain("create-fn-node@");
-        });
-        it("should include duration in validation result", async () => {
-            mockedGenerateText.mockResolvedValueOnce({ text: VALID_FUNCTION_FIRST_NODE });
-            mockValidPass();
-            const result = await generator.generateNode("test-node", "Create a test node", "test-api-key", false, "function");
-            expect(result.validationResult.durationMs).toBeGreaterThanOrEqual(0);
-        });
     });
     describe("validation feedback loop", () => {
         it("should retry with feedback on first failure and succeed on second attempt", async () => {

package/dist/commands/generate/e2e/RuntimeGenerator.e2e.test.js

@@ -645,18 +645,6 @@ describe("RuntimeGenerator E2E", () => {
             expect(mockedGenerateText).toHaveBeenCalledTimes(1);
         });
     });
-    describe("analytics integration", () => {
-        it("should include prompt version in validation result", async () => {
-            mockedGenerateText.mockResolvedValueOnce({ text: VALID_GO_RUNTIME });
-            const result = await generator.generateRuntime("go", "Create a runtime", "test-api-key");
-            expect(result.validationResult.promptVersion).toContain("create-runtime@");
-        });
-        it("should include duration in validation result", async () => {
-            mockedGenerateText.mockResolvedValueOnce({ text: VALID_GO_RUNTIME });
-            const result = await generator.generateRuntime("go", "Create a runtime", "test-api-key");
-            expect(result.validationResult.durationMs).toBeGreaterThanOrEqual(0);
-        });
-    });
     describe("multi-file parsing", () => {
         it("should parse files separated by // FILE: markers", async () => {
             const code = [

package/dist/commands/generate/e2e/TriggerGenerator.e2e.test.js

@@ -278,18 +278,4 @@ describe("TriggerGenerator E2E", () => {
             expect(system).toContain("loadNodes");
         });
     });
-    describe("analytics integration", () => {
-        it("should include prompt version in validation result", async () => {
-            mockedGenerateText.mockResolvedValueOnce({ text: VALID_QUEUE_TRIGGER });
-            mockedValidateCode.mockReturnValue({ success: true, errors: [], warnings: [] });
-            const result = await generator.generateTrigger("test-trigger", "queue", "Create a test trigger", "test-api-key");
-            expect(result.validationResult.promptVersion).toContain("create-trigger@");
-        });
-        it("should include duration in validation result", async () => {
-            mockedGenerateText.mockResolvedValueOnce({ text: VALID_QUEUE_TRIGGER });
-            mockedValidateCode.mockReturnValue({ success: true, errors: [], warnings: [] });
-            const result = await generator.generateTrigger("test-trigger", "queue", "Create a test trigger", "test-api-key");
-            expect(result.validationResult.durationMs).toBeGreaterThanOrEqual(0);
-        });
-    });
 });

package/dist/commands/monitor/monitor-component.js

@@ -120,11 +120,11 @@ const fetchPrometheusMetrics = async (host, token) => {
     mapWorkflow(wfErrors, "errors", (v) => Math.round(+v));
     mapWorkflow(wfReqs, "requests", (v) => Math.round(+v));
     const nodeMetricsRaw = await Promise.all([
-        queryPrometheus("(sum(increase(node_total[1m])) by (node_name, workflow_path)) > 0", host, token),
-        queryPrometheus("sum(increase(node_time[1m])) by (node_name, workflow_path)", host, token),
-        queryPrometheus("(sum(increase(node_errors_total[1m])) by (node_name, workflow_path)) > 0", host, token),
-        queryPrometheus("sum(increase(node_cpu[1m])) by (node_name, workflow_path)", host, token),
-        queryPrometheus("sum(increase(node_memory[1m])) by (node_name, workflow_path)", host, token),
+        queryPrometheus("(sum(increase(blok_node_executions_total[1m])) by (node_name, workflow_path)) > 0", host, token),
+        queryPrometheus("sum(increase(blok_node_duration_seconds_sum[1m])) by (node_name, workflow_path)", host, token),
+        queryPrometheus("(sum(increase(blok_node_errors_total[1m])) by (node_name, workflow_path)) > 0", host, token),
+        queryPrometheus("sum(increase(blok_node_cpu_usage[1m])) by (node_name, workflow_path)", host, token),
+        queryPrometheus("sum(increase(blok_node_memory_bytes[1m])) by (node_name, workflow_path)", host, token),
     ]);
     const nodeMap = {};
     const setNodeMetric = (list, key, convert) => {

package/dist/commands/observability/add.d.ts

@@ -0,0 +1,2 @@
+import type { OptionValues } from "../../services/commander.js";
+export declare function observabilityAdd(moduleArg: string | undefined, options: OptionValues): Promise<void>;

package/dist/commands/observability/add.js

@@ -0,0 +1,113 @@
+import fs from "node:fs";
+import path from "node:path";
+import * as p from "@clack/prompts";
+import color from "picocolors";
+import { isNonInteractive } from "../../services/non-interactive.js";
+import { rewriteObservabilityEnvBlock, withObservabilityModule } from "../../services/observability-mutations.js";
+import { OBSERVABILITY_MODULE_IDS, allObservabilityModules, getObservabilityModule, resolveWithDependencies, } from "./descriptor.js";
+import { ObservabilityCommandError, readConfigSafe, readFrameworkVersion, reportObservabilityError, resolveProjectRoot, } from "./shared.js";
+export async function observabilityAdd(moduleArg, options) {
+    try {
+        const root = resolveProjectRoot(options.directory);
+        const config = readConfigSafe(root);
+        const enabled = config.observability ?? {};
+        const nonInteractive = isNonInteractive() || options.yes === true;
+        let id = moduleArg?.trim().toLowerCase();
+        if (!id) {
+            if (nonInteractive) {
+                throw new ObservabilityCommandError(`Specify a module: blokctl observability add <${OBSERVABILITY_MODULE_IDS.join("|")}>`);
+            }
+            const choices = allObservabilityModules()
+                .filter((m) => !enabled[m.id])
+                .map((m) => ({ value: m.id, label: m.label, hint: m.description }));
+            if (choices.length === 0) {
+                p.intro(color.inverse(" Add observability module "));
+                p.outro(color.dim("All observability modules are already enabled."));
+                return;
+            }
+            const picked = await p.select({ message: "Which observability module do you want to add?", options: choices });
+            if (p.isCancel(picked)) {
+                p.cancel("Cancelled.");
+                return;
+            }
+            id = picked;
+        }
+        const mod = getObservabilityModule(id);
+        if (!mod) {
+            throw new ObservabilityCommandError(`Unknown observability module "${id}". Known: ${OBSERVABILITY_MODULE_IDS.join(", ")}.`);
+        }
+        p.intro(color.inverse(` Add ${mod.label} `));
+        if (enabled[mod.id] && options.force !== true) {
+            p.outro(color.dim(`${mod.label} is already enabled. Re-run with --force to re-apply its scaffold.`));
+            return;
+        }
+        const { resolved, added } = resolveWithDependencies([mod.id]);
+        const newDeps = added.filter((d) => !enabled[d]);
+        if (newDeps.length > 0) {
+            const labels = newDeps.map((d) => getObservabilityModule(d)?.label ?? d).join(", ");
+            if (nonInteractive) {
+                p.log.info(color.dim(`Also enabling required dependencies: ${labels}`));
+            }
+            else {
+                const ok = await p.confirm({
+                    message: `${mod.label} requires ${labels}. Enable ${newDeps.length > 1 ? "them" : "it"} too?`,
+                    initialValue: true,
+                });
+                if (p.isCancel(ok) || !ok) {
+                    p.outro(color.dim("Left unchanged."));
+                    return;
+                }
+            }
+        }
+        const toApply = resolved.filter((rid) => rid === mod.id || !enabled[rid]);
+        const addedAt = new Date().toISOString();
+        const version = readFrameworkVersion(root);
+        const s = p.spinner();
+        let nextConfig = config;
+        const scaffoldOpts = {
+            projectDir: root,
+            nonInteractive,
+            tier: options.tier,
+            localRepo: options.local,
+        };
+        for (const rid of toApply) {
+            const d = getObservabilityModule(rid);
+            if (!d)
+                continue;
+            if (d.validate)
+                await d.validate(root);
+            if (d.scaffold) {
+                s.start(`Scaffolding ${d.label}…`);
+                await d.scaffold(scaffoldOpts);
+                s.stop(`${d.label} ready`);
+            }
+            if (d.setup)
+                await d.setup(scaffoldOpts);
+            const extra = rid === "obs-stack" ? { settings: { tier: options.tier ?? "lite" } } : {};
+            nextConfig = withObservabilityModule(nextConfig, rid, { enabled: true, addedAt, version, ...extra });
+        }
+        fs.mkdirSync(path.join(root, ".blok"), { recursive: true });
+        fs.writeFileSync(path.join(root, ".blok", "config.json"), `${JSON.stringify(nextConfig, null, 2)}\n`);
+        const enabledIds = Object.keys(nextConfig.observability ?? {});
+        const envBlocks = enabledIds.map((eid) => getObservabilityModule(eid)?.envBlock({ projectDir: root }) ?? "");
+        const envPath = path.join(root, ".env.local");
+        const envContent = fs.existsSync(envPath) ? fs.readFileSync(envPath, "utf8") : "";
+        fs.writeFileSync(envPath, rewriteObservabilityEnvBlock(envContent, envBlocks));
+        const deps = {};
+        for (const rid of toApply)
+            Object.assign(deps, getObservabilityModule(rid)?.packageDeps ?? {});
+        if (Object.keys(deps).length > 0)
+            mergePackageDeps(root, deps);
+        p.note(toApply.map((rid) => `${color.green("✓")} ${getObservabilityModule(rid)?.label ?? rid}`).join("\n"), `${mod.label} added`);
+        p.outro(color.dim(`Enabled modules: ${enabledIds.join(", ")}.`));
+    }
+    catch (err) {
+        reportObservabilityError(err);
+    }
+}
+function mergePackageDeps(root, deps) {
+    const pkgPath = path.join(root, "package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    pkg.dependencies = { ...(pkg.dependencies ?? {}), ...deps };
+    fs.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+}

package/dist/commands/observability/alerting-module.test.js

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { getObservabilityModule } from "./descriptor.js";
+const alerting = getObservabilityModule("alerting");
+const errorSink = getObservabilityModule("error-sink");
+describe("alerting + error-sink modules (MO-ALERTS)", () => {
+    it("alerting depends on metrics, declares alertmanager, and enables alerting", () => {
+        expect(alerting.dependencies).toEqual(["metrics"]);
+        expect(alerting.composeServices).toEqual(["alertmanager"]);
+        expect(alerting.envBlock({ projectDir: "/x" })).toContain("BLOK_ALERTING_ENABLED=true");
+    });
+    it("error-sink ships inert — SENTRY_DSN is commented out", () => {
+        for (const line of errorSink.envBlock({ projectDir: "/x" }).split("\n")) {
+            if (/SENTRY_DSN=/.test(line))
+                expect(line.trim().startsWith("#")).toBe(true);
+        }
+    });
+    describe("verify()", () => {
+        let tmp;
+        beforeEach(() => {
+            tmp = fs.mkdtempSync(path.join(os.tmpdir(), "blok-alerts-"));
+        });
+        afterEach(() => fs.rmSync(tmp, { recursive: true, force: true }));
+        it("error-sink: inert when no SENTRY_DSN", async () => {
+            fs.writeFileSync(path.join(tmp, ".env.local"), "# SENTRY_DSN=\n");
+            expect((await errorSink.verify?.(tmp))?.message).toMatch(/inert/);
+        });
+        it("error-sink: flags the missing dep when DSN is set but @sentry/node is absent", async () => {
+            fs.writeFileSync(path.join(tmp, ".env.local"), "SENTRY_DSN=https://k@e.test/1\n");
+            expect((await errorSink.verify?.(tmp))?.message).toMatch(/@sentry\/node missing/);
+        });
+        it("alerting: points at obs-stack when the rules file isn't in the project", async () => {
+            expect((await alerting.verify?.(tmp))?.message).toMatch(/obs-stack=full/);
+        });
+        it("alerting: reports rules present when they exist", async () => {
+            fs.mkdirSync(path.join(tmp, "infra", "metrics", "rules"), { recursive: true });
+            fs.writeFileSync(path.join(tmp, "infra", "metrics", "rules", "blok-alerts.yml"), "groups: []\n");
+            expect((await alerting.verify?.(tmp))?.message).toMatch(/alert rules present/);
+        });
+    });
+});

package/dist/commands/observability/apply.d.ts

@@ -0,0 +1,10 @@
+import type { ObservabilityModuleConfig } from "../../services/runtime-setup.js";
+export declare function resolveObservabilitySelection(moduleIds: string[], opts: {
+    addedAt: string;
+    version?: string;
+    projectDir: string;
+}): {
+    configMap: Record<string, ObservabilityModuleConfig>;
+    envBlocks: string[];
+    added: string[];
+};

package/dist/commands/observability/apply.js

@@ -0,0 +1,11 @@
+import { getObservabilityModule, resolveWithDependencies } from "./descriptor.js";
+export function resolveObservabilitySelection(moduleIds, opts) {
+    if (moduleIds.length === 0)
+        return { configMap: {}, envBlocks: [], added: [] };
+    const { resolved, added } = resolveWithDependencies(moduleIds);
+    const configMap = {};
+    for (const id of resolved)
+        configMap[id] = { enabled: true, addedAt: opts.addedAt, version: opts.version };
+    const envBlocks = resolved.map((id) => getObservabilityModule(id)?.envBlock({ projectDir: opts.projectDir }) ?? "");
+    return { configMap, envBlocks, added };
+}