@voltro/cli 0.33.0 → 0.35.0

package/bin/nodeEnvironment.d.mts

@@ -0,0 +1,30 @@
+// Types for `nodeEnvironment.mjs`. Hand-written because the implementation is
+// plain ESM on purpose — `bin/voltro.mjs` runs before the tsx loader and cannot
+// import TypeScript, so the rule has to live in a file BOTH sides can load.
+// `src/nodeEnvironment.ts` is the TypeScript face of it.
+
+export type NodeEnvironmentName = string
+
+/** Which environment an undeclared `NODE_ENV` resolves to, per command. */
+export declare const COMMAND_ENVIRONMENT_DEFAULTS: Readonly<Record<string, NodeEnvironmentName | undefined>>
+
+/** The first non-flag token of a `voltro …` argv, lowercased. */
+export declare const commandOf: (argv: ReadonlyArray<string>) => string | undefined
+
+/** Resolve this invocation's environment WITHOUT mutating `process.env`. */
+export declare const resolveNodeEnvironment: (
+  argv: ReadonlyArray<string>,
+  env?: Record<string, string | undefined>,
+) => NodeEnvironmentName | undefined
+
+/** Was `NODE_ENV` defaulted by us rather than declared by the operator? */
+export declare const nodeEnvironmentWasDefaulted: () => boolean
+
+/** Write the resolved environment into `process.env.NODE_ENV` when unset. */
+export declare const declareNodeEnvironment: (
+  argv: ReadonlyArray<string>,
+  env?: Record<string, string | undefined>,
+) => NodeEnvironmentName | undefined
+
+/** Tests only. */
+export declare const resetNodeEnvironmentDeclaration: () => void

package/bin/nodeEnvironment.mjs

@@ -0,0 +1,158 @@
+// THE decision: which environment is this process running in?
+//
+// ## Why this file is plain ESM and lives beside the launcher
+//
+// `bin/voltro.mjs` runs BEFORE the tsx loader is registered, so it cannot
+// import a `.ts` module — and it was the first reader of `NODE_ENV`, three
+// times, in fast paths that execute before any command's own default. Every
+// other reader is TypeScript. A rule that has to hold across that boundary
+// either lives in a file both sides can load, or it is two copies. It is this
+// file; `src/nodeEnvironment.ts` re-exports it so the TypeScript side has one
+// import and one set of types (`nodeEnvironment.d.mts`).
+//
+// ## The rule, and the three things it had to reconcile
+//
+// `voltro serve`, `voltro start` and the web preview server each carried
+// `if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production'`, with a
+// comment saying an unset NODE_ENV in a serving container means production.
+// NOTHING else agreed:
+//
+//   - **The launcher decided first.** `bin/voltro.mjs` read `NODE_ENV` in the
+//     `serve` / `start` fast paths, which run before the command's default. So
+//     a NODE_ENV-less production deploy with a missing serve bundle skipped the
+//     "production requires a precompiled bundle" guard, fell through to the tsx
+//     path, and — in a `--prod --no-optional` image, which has no tsx — died as
+//     `Cannot find package 'tsx'` instead of naming the real cause.
+//
+//   - **The migration commands ran the DEV branch of every gate.** In a
+//     pre-deploy job in the SAME image with NODE_ENV unset: `db apply`'s
+//     "auto-apply on prod is not allowed" refusal did not fire, `db
+//     rollback-file`'s refusal did not fire, and the plan ledger recorded
+//     `environment: 'dev'` for a production apply.
+//
+//   - **And the framework TABLE SET disagreed with the process that serves
+//     it.** `traceTableEnabled()` and `undoCaptureEnabled()` are "on unless
+//     production", so a NODE_ENV-less `voltro db apply` declared
+//     `_voltro_traces` + `_voltro_undo_log` and `voltro serve` (which defaults
+//     to production) did not. The declared set is what the schema FINGERPRINT
+//     hashes, so the two no longer agree about it: the apply records one
+//     fingerprint and the serving container computes another, and serve's boot
+//     gate refuses with `prod-mismatch` — telling the operator to run `voltro db
+//     apply`, which is what they had just done. The loop has no exit.
+//
+// So: **an undeclared `NODE_ENV` resolves to `production` for every deploy-side
+// command, and to `development` for `voltro dev`.** One rule, applied per
+// command, with the polarity argued per gate at each use site:
+//
+//   - For a REFUSAL (`db apply` auto-apply, `db rollback-file`) the cost of a
+//     false positive is one environment variable and the cost of a false
+//     negative is an un-reviewed DDL applied to a production database. Refuse.
+//   - For a TABLE-CREATION decision the safe direction is not "production", it
+//     is *the same answer the serving process will compute*. Since serve
+//     resolves an undeclared environment to production, so must every migration
+//     command, or the two declare different schemas. This is the gate the
+//     write-up in `frameworkTableAssembly.ts` claimed could never disagree.
+//   - `voltro dev` resolves to `development` so the ambiguity never reaches the
+//     boot auto-migrate at all: dev's table set becomes a declared fact rather
+//     than the absence of one.
+//
+// Commands NOT in the table below are left alone deliberately. Nothing in them
+// branches on `NODE_ENV` in a way that crosses a process boundary, and
+// declaring an environment for `voltro test` (vitest sets its own) or `voltro
+// doctor` (whose serve-preflight default is documented as NODE_ENV-shaped)
+// would change behaviour this decision has no opinion about.
+
+/**
+ * Which environment an undeclared `NODE_ENV` resolves to, per command.
+ *
+ * A command absent from this map keeps an undeclared `NODE_ENV` undeclared.
+ * That is a decision, not an omission — see the header.
+ */
+export const COMMAND_ENVIRONMENT_DEFAULTS = Object.freeze({
+  // The serving processes. An unset NODE_ENV in a container that is answering
+  // traffic is production; this is the rule the three call sites already had.
+  serve: 'production',
+  start: 'production',
+  // The deploy-side schema commands. They must resolve IDENTICALLY to `serve`
+  // or the declared framework-table set — and therefore the fingerprint — of
+  // the pre-deploy job differs from the serving container's.
+  db: 'production',
+  migrate: 'production',
+  // The development loop. Declared rather than left unset so the boot
+  // auto-migrate's table set is a stated fact.
+  dev: 'development',
+})
+
+/** Has `NODE_ENV` been given a value by the operator / the environment? */
+const isDeclared = (raw) => typeof raw === 'string' && raw.length > 0
+
+/**
+ * The command a `voltro …` argv invokes — the first non-flag token, lowercased.
+ * `undefined` when the argv carries only flags (`voltro --version`).
+ */
+export const commandOf = (argv) => {
+  for (const arg of argv ?? []) {
+    if (typeof arg === 'string' && !arg.startsWith('-')) return arg.toLowerCase()
+  }
+  return undefined
+}
+
+/**
+ * Resolve this invocation's environment WITHOUT mutating anything.
+ *
+ * Returns the declared `NODE_ENV` when there is one; otherwise the command's
+ * default from {@link COMMAND_ENVIRONMENT_DEFAULTS}; otherwise `undefined`,
+ * meaning "this command has no opinion and the environment stays undeclared".
+ *
+ * The launcher uses this form: it must not write `process.env.NODE_ENV`,
+ * because it runs BEFORE `.env` / `.env.local` are loaded and a value it wrote
+ * there would silently outrank the app's own dotenv file for every later
+ * reader. Reading is safe; writing pre-dotenv is not.
+ */
+export const resolveNodeEnvironment = (argv, env) => {
+  const source = env ?? process.env
+  if (isDeclared(source.NODE_ENV)) return source.NODE_ENV.toLowerCase()
+  const command = commandOf(argv)
+  if (command === undefined) return undefined
+  return COMMAND_ENVIRONMENT_DEFAULTS[command]
+}
+
+/**
+ * Whether `NODE_ENV` for THIS process was defaulted by us rather than declared
+ * by the operator.
+ *
+ * Module-level, not an environment variable: a refusal wants to SAY "NODE_ENV
+ * was not set, so this run resolved to production", and exporting that fact
+ * into the environment would make it inheritable by every child — a fact about
+ * one process, leaking as configuration.
+ */
+let defaulted = false
+
+/** See {@link declareNodeEnvironment}. */
+export const nodeEnvironmentWasDefaulted = () => defaulted
+
+/**
+ * DECLARE this process's environment: write the resolved value into
+ * `process.env.NODE_ENV` when it is unset, so that every later reader —
+ * including the ones this module cannot reach (`undoCaptureEnabled` lives in
+ * `@voltro/runtime`, which must not depend on the CLI) — sees a value that was
+ * decided once, here, rather than each guessing from an absence.
+ *
+ * Call it AFTER `.env` loading: a dotenv-provided `NODE_ENV` is a declaration
+ * and must win over our default.
+ *
+ * Returns the resolved name, or `undefined` when the command has no default and
+ * `NODE_ENV` was unset.
+ */
+export const declareNodeEnvironment = (argv, env) => {
+  const source = env ?? process.env
+  if (isDeclared(source.NODE_ENV)) return source.NODE_ENV.toLowerCase()
+  const resolved = resolveNodeEnvironment(argv, source)
+  if (resolved === undefined) return undefined
+  source.NODE_ENV = resolved
+  defaulted = true
+  return resolved
+}
+
+/** Reset the "we defaulted it" flag. Tests only — a process declares once. */
+export const resetNodeEnvironmentDeclaration = () => { defaulted = false }

package/bin/voltro.mjs

@@ -17,6 +17,7 @@ import { existsSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import { dirname, join, resolve } from 'node:path'
+import { resolveNodeEnvironment } from './nodeEnvironment.mjs'
 
 // FAST PATH — `voltro serve <app>` with a precompiled SERVE BUNDLE boots from that
 // ONE artefact IN THIS PROCESS: no child `node --import tsx`, no CLI command
@@ -32,6 +33,25 @@ const argv = process.argv.slice(2)
 const here = dirname(fileURLToPath(import.meta.url))
 const built = resolve(here, '..', 'dist', 'bin.js')
 
+// WHICH ENVIRONMENT IS THIS. Resolved once, from the shared decider, and
+// deliberately WITHOUT writing `process.env.NODE_ENV`: this file runs before
+// `.env` / `.env.local` are loaded, so a value written here would silently
+// outrank the app's own dotenv file for every later reader.
+//
+// The three guards below used to read `process.env.NODE_ENV === 'production'`
+// directly, and they run BEFORE `runServe` / `runStartCommand` apply their own
+// `if (!process.env.NODE_ENV) … = 'production'`. So a NODE_ENV-less production
+// deploy whose serve bundle was missing skipped the "production requires a
+// precompiled bundle" guard entirely, fell through to the tsx path, and — in a
+// `--prod --no-optional` image, which has no tsx — died as `Cannot find package
+// 'tsx'`: a message naming a package the user never asked for, in place of the
+// one that says what is actually wrong. `serve` and `start` resolve to
+// `production` when NODE_ENV is unset, which is exactly what the commands
+// themselves do a few milliseconds later — this just stops the launcher from
+// being the one reader that disagrees.
+const launchEnvironment = resolveNodeEnvironment(argv, process.env)
+const launchIsProduction = launchEnvironment === 'production'
+
 // FAST PATH — `voltro start <app>` (WEB) runs the built CLI IN THIS PROCESS when
 // the app is fully precompiled: no child `node --import tsx`, no loader hook.
 //
@@ -78,7 +98,7 @@ if (argv[0] === 'start') {
       // through would spawn the tsx path, and a prod image built with
       // `--no-optional` has no tsx at all — the container would die with a
       // misleading `Cannot find package 'tsx'` that hides THIS error.
-      if (process.env.NODE_ENV === 'production') {
+      if (launchIsProduction) {
         console.error('[voltro] FATAL: precompiled `voltro start` failed to load:', error?.message ?? error)
         process.exit(1)
       }
@@ -87,7 +107,7 @@ if (argv[0] === 'start') {
       // in-process import legitimately can't work before a package build.
       console.warn('[voltro] start fast path failed:', error?.message ?? error)
     }
-  } else if (process.env.NODE_ENV === 'production') {
+  } else if (launchIsProduction) {
     // PRODUCTION MUST start from precompiled artefacts — never transpile on
     // demand. Falling through here would spawn tsx (if it is even installed —
     // a prod image built with `--prod --no-optional` has no tsx at all) and
@@ -176,11 +196,16 @@ if (argv[0] === 'serve') {
   // build` produces the bundle and treats a build failure as fatal, so a healthy
   // deploy never hits this. Non-production (dev / an unbuilt local serve) falls
   // through to the tsx path below — on-demand transpile is a DEV-only convenience.
-  if (process.env.NODE_ENV === 'production') {
+  if (launchIsProduction) {
     console.error(
       `[voltro] FATAL: production \`voltro serve\` requires a precompiled serve bundle at\n  ${serveBundle}\n` +
         'but it is missing or failed to load. Run `voltro build` before serving — a bundle-build ' +
-        'failure is fatal by design; production never transpiles on demand.',
+        'failure is fatal by design; production never transpiles on demand.' +
+        (process.env.NODE_ENV
+          ? ''
+          : '\n  (NODE_ENV is not set in the process environment; `voltro serve` resolves that to ' +
+            'production, the same way the command itself does. This launcher runs before `.env` is ' +
+            'loaded, so set NODE_ENV in the environment — not in `.env` — for a non-production serve.)'),
     )
     process.exit(1)
   }
@@ -208,14 +233,53 @@ try {
   }
 }
 
+// THE FIRST LINE A NEW USER SEES SHOULD BE OURS.
+//
+// Every invocation used to open with:
+//
+//   (node:12345) ExperimentalWarning: localStorage is not available because
+//   --localstorage-file was not provided.
+//   (Use `node --trace-warnings ...` to show where the warning was created)
+//
+// — two lines of Node internals before the tool says anything, on `voltro
+// version` as much as on `voltro dev`.
+//
+// The trigger, traced: `@voltro/runtime` → `crdtMerge.ts` → `@voltro/local-first`
+// → `yjs` → `lib0/storage.js`, which touches `globalThis.localStorage` at module
+// load. On Node 26 that access warns. It is a THIRD-PARTY module reading a
+// global at import time, so there is nothing to fix at the point of use, and
+// the framework needs `mergeCrdtStates` synchronously — deferring the import
+// would make `crdtText()` async, which is a public API change to silence a log
+// line.
+//
+// Two things address it, in this order:
+//   1. Lazy command dispatch (`src/commands.ts`) keeps `@voltro/runtime` out of
+//      the graph entirely for commands that do not need it — `voltro version`
+//      is silent on its own now. That is the structural half.
+//   2. This flag covers the rest, for the commands that legitimately load the
+//      runtime. It is NARROW: `--disable-warning` takes a warning TYPE, and
+//      `DeprecationWarning` — the class that matters when a dependency is about
+//      to break — still prints. Verified: a `DeprecationWarning` emitted under
+//      this flag is still shown.
+//
+// Node >= 20.11 has the flag and the framework's floor is 24, so it cannot
+// produce a `bad option` on a supported runtime. If `@voltro/local-first` ever
+// defers its yjs import, delete this — it is a workaround with a named cause,
+// not a policy.
+const QUIET_NODE_INTERNALS = '--disable-warning=ExperimentalWarning'
+
 // Export what we resolved. The child inherits `--import <abs>` in its own
 // `execArgv` and normally passes THAT on (see src/tsxLoader.ts), but a
 // grandchild spawned from a process that is not itself loader-registered has no
 // other way to learn the answer — and re-deriving it from the app's cwd is the
 // exact mistake this block exists to avoid.
+//
+// The quiet flag rides in `execArgv` for the same reason: `tsxLoaderArgs()`
+// inherits the child's whole `execArgv`, so the dev supervisor's respawned
+// grandchild is quiet too without a second place remembering to be.
 const child = spawn(
   process.execPath,
-  ['--import', tsxImport, entry, ...process.argv.slice(2)],
+  [QUIET_NODE_INTERNALS, '--import', tsxImport, entry, ...process.argv.slice(2)],
   { stdio: 'inherit', env: { ...process.env, VOLTRO_TSX_IMPORT: tsxImport } },
 )
 

package/dist/addCommand-BNeoeSxe.js

@@ -0,0 +1,124 @@
+import { t as e } from "./mssqlClusterPatch-_4cE_nun.js";
+import { dirname as t, join as n, resolve as r } from "node:path";
+import { existsSync as i, promises as a } from "node:fs";
+import { createLogger as o } from "@voltro/logger";
+//#region src/addCommand.ts
+var s = o({ scope: "voltro:add" }), c = "redis://localhost:6379", l = (e) => {
+	let a = r(e);
+	for (let e = 0; e < 12; e++) {
+		if (i(n(a, "pnpm-workspace.yaml"))) return a;
+		let e = t(a);
+		if (e === a) break;
+		a = e;
+	}
+	return null;
+}, u = async (e) => {
+	let t = n(e, "apps");
+	if (!i(t)) return [];
+	let r = [], o = await a.readdir(t, { withFileTypes: !0 });
+	for (let e of o) {
+		if (!e.isDirectory()) continue;
+		let o = n(t, e.name), s = await a.readdir(o, { withFileTypes: !0 });
+		for (let e of s) {
+			if (!e.isDirectory()) continue;
+			let t = n(o, e.name, "app.config.ts");
+			if (!i(t)) continue;
+			let s = await a.readFile(t, "utf8");
+			/type:\s*'api'/.test(s) && r.push(t);
+		}
+	}
+	return r;
+}, d = "\n  # --- added by `voltro add redis` ---\n  redis:\n    image: redis:7-alpine\n    restart: unless-stopped\n    ports:\n      - \"6379:6379\"\n    command: [\"redis-server\", \"--save\", \"\", \"--appendonly\", \"no\"]\n    healthcheck:\n      test: [\"CMD\", \"redis-cli\", \"ping\"]\n      interval: 2s\n      timeout: 5s\n      retries: 20\n", f = "\n# --- added by `voltro add redis` ---\nredis:\n  # In-cluster Redis for the @voltro/cache backend. A cache is ephemeral,\n  # so this is a Deployment (no PVC). Set enabled:false to point the app\n  # at a managed Redis via CACHE_REDIS_URL instead.\n  enabled: true\n  image:\n    repository: redis\n    tag: 7-alpine\n", p = "{{- if .Values.redis.enabled }}\n# Added by `voltro add redis`. Ephemeral cache — Deployment, no PVC.\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: {{ include \"voltro-app.fullname\" . }}-redis\n  labels:\n    app.kubernetes.io/component: redis\nspec:\n  replicas: 1\n  selector:\n    matchLabels:\n      app.kubernetes.io/component: redis\n  template:\n    metadata:\n      labels:\n        app.kubernetes.io/component: redis\n    spec:\n      containers:\n        - name: redis\n          image: \"{{ .Values.redis.image.repository }}:{{ .Values.redis.image.tag }}\"\n          args: [\"redis-server\", \"--save\", \"\", \"--appendonly\", \"no\"]\n          ports:\n            - containerPort: 6379\n          readinessProbe:\n            exec:\n              command: [\"redis-cli\", \"ping\"]\n            initialDelaySeconds: 2\n            periodSeconds: 5\n---\napiVersion: v1\nkind: Service\nmetadata:\n  name: {{ include \"voltro-app.fullname\" . }}-redis\n  labels:\n    app.kubernetes.io/component: redis\nspec:\n  selector:\n    app.kubernetes.io/component: redis\n  ports:\n    - port: 6379\n      targetPort: 6379\n{{- end }}\n", m = async (e) => {
+	let t = await a.readFile(e, "utf8");
+	if (/\bcache:\s*'/.test(t)) return !1;
+	let n = /(store:\s*'[^']*'\s*as const,?)/, r = /(type:\s*'api'\s*as const,?)/, i;
+	if (n.test(t)) i = t.replace(n, "$1\n  cache: 'redis' as const,");
+	else if (r.test(t)) i = t.replace(r, "$1\n  cache: 'redis' as const,");
+	else return !1;
+	return await a.writeFile(e, i, "utf8"), !0;
+}, h = async (e) => {
+	let t = await a.readFile(e, "utf8");
+	if (/\n {2}redis:/.test(t)) return !1;
+	let n = /(^services:\s*\n)/m;
+	if (!n.test(t)) return !1;
+	let r = t.replace(n, `$1${d}`);
+	return await a.writeFile(e, r, "utf8"), !0;
+}, g = async (e) => {
+	let t = n(e, "values.yaml"), r = n(e, "templates", "redis.yaml");
+	if (!i(t)) return !1;
+	let o = !1, s = await a.readFile(t, "utf8");
+	return /\nredis:/.test(s) || (await a.writeFile(t, `${s.trimEnd()}\n${f}`, "utf8"), o = !0), i(r) || (await a.writeFile(r, p, "utf8"), o = !0), o;
+}, _ = async (e) => {
+	let t = i(e) ? await a.readFile(e, "utf8") : "";
+	if (/^\s*CACHE_BACKEND\s*=\s*redis\b/m.test(t)) return !1;
+	if (/^#\s*CACHE_BACKEND=redis\b/m.test(t)) {
+		let n = t.replace(/^#\s*(CACHE_BACKEND=redis)\s*$/m, "$1").replace(/^#\s*(CACHE_REDIS_URL=.*)$/m, "$1");
+		return await a.writeFile(e, n, "utf8"), !0;
+	}
+	let n = `${t.trimEnd()}${t ? "\n" : ""}\n# @voltro/cache — Redis backend\nCACHE_BACKEND=redis\nCACHE_REDIS_URL=${c}\n`;
+	return await a.writeFile(e, n, "utf8"), !0;
+}, v = async (e) => {
+	let t = [];
+	for (let n of await u(e)) await m(n) && t.push(`cache: 'redis' → ${n.replace(`${e}/`, "")}`);
+	let r = n(e, "docker-compose.yml");
+	i(r) && await h(r) && t.push("redis service → docker-compose.yml");
+	let a = n(e, "charts", "voltro-app");
+	i(a) && await g(a) && t.push("redis Deployment/Service + values → charts/voltro-app/");
+	for (let r of [".env.example", ".env"]) {
+		let a = n(e, r);
+		(r === ".env.example" || i(a)) && await _(a) && t.push(`CACHE_BACKEND / CACHE_REDIS_URL → ${r}`);
+	}
+	return t;
+}, y = async () => {
+	let e = l(process.cwd());
+	if (!e) return console.error("voltro add redis: not inside a voltro workspace (no pnpm-workspace.yaml found)"), 1;
+	let t = await v(e);
+	if (t.length === 0) return s.info("redis already enabled — nothing to do"), 0;
+	s.info("redis cache enabled", { changes: t.length });
+	for (let e of t) console.log(`  ✓ ${e}`);
+	return console.log("\nNext: start redis (`docker compose up -d redis`) and reboot `voltro dev`."), console.log("The cache backend resolves from CACHE_BACKEND/CACHE_REDIS_URL (or app.config `cache`)."), 0;
+}, b = async (e) => {
+	let t = await a.readFile(e, "utf8"), n = /store:\s*'([^']*)'(\s*as const)?/, r = n.exec(t);
+	if (r) return r[1] === "mssql" ? !1 : (await a.writeFile(e, t.replace(n, `store: 'mssql'${r[2] ?? ""}`), "utf8"), !0);
+	let i = /(type:\s*'api'\s*as const,?)/;
+	return i.test(t) ? (await a.writeFile(e, t.replace(i, "$1\n  store: 'mssql' as const,"), "utf8"), !0) : !1;
+}, x = async (e) => {
+	let t = i(e) ? await a.readFile(e, "utf8") : "";
+	if (/^DB_DIALECT=mssql$/m.test(t)) return !1;
+	let n = /^DB_DIALECT=.*$/m, r = n.test(t) ? t.replace(n, "DB_DIALECT=mssql") : `${t.trimEnd()}${t ? "\n" : ""}\n# SQL Server (mssql) — set the connection string for your server.
+DB_DIALECT=mssql
+# DB_URL=mssql://user:pass@host:1433/database
+`;
+	return await a.writeFile(e, r, "utf8"), !0;
+}, S = async (e, r) => {
+	let o = n(t(e), "package.json");
+	if (!i(o)) return !1;
+	let s = JSON.parse(await a.readFile(o, "utf8"));
+	return s.dependencies ??= {}, s.dependencies[r] ? !1 : (s.dependencies[r] = "workspace:*", s.dependencies = Object.fromEntries(Object.entries(s.dependencies).sort(([e], [t]) => e.localeCompare(t))), await a.writeFile(o, `${JSON.stringify(s, null, 2)}\n`, "utf8"), !0);
+}, C = async (r) => {
+	let a = [];
+	for (let e of await u(r)) await b(e) && a.push(`store: 'mssql' → ${e.replace(`${r}/`, "")}`), await S(e, "@voltro/sql-mssql") && a.push(`+ @voltro/sql-mssql → ${t(e).replace(`${r}/`, "")}/package.json`);
+	for (let e of [".env.example", ".env"]) {
+		let t = n(r, e);
+		(e === ".env.example" || i(t)) && await x(t) && a.push(`DB_DIALECT=mssql → ${e}`);
+	}
+	for (let t of await e(r)) a.push(t);
+	return a;
+}, w = async (e) => {
+	let t = await C(e);
+	if (t.length === 0) return s.info("mssql already wired — nothing to do"), 0;
+	s.info("mssql enabled", { changes: t.length });
+	for (let e of t) console.log(`  ✓ ${e}`);
+	return console.log("\nNext: run `pnpm install` (applies the @effect/cluster patch), set DB_URL to your"), console.log("SQL Server, and reboot `voltro dev`. The patch fixes two mssql-only bugs in the"), console.log("durable cluster workflow engine; it is a no-op on any other dialect."), 0;
+}, T = ["redis", "mssql"], E = async (e) => {
+	let t = e[0];
+	if (t === void 0) return console.error(`usage: voltro add <integration>   (available: ${T.join(", ")})`), 1;
+	if (t === "redis") return y();
+	if (t === "mssql") {
+		let e = l(process.cwd());
+		return e ? w(e) : (console.error("voltro add mssql: not inside a voltro workspace (no pnpm-workspace.yaml found)"), 1);
+	}
+	return console.error(`voltro add: unknown integration '${t}'. Available: ${T.join(", ")}.`), 1;
+};
+//#endregion
+export { v as n, E as r, C as t };

package/dist/addCommand-aXSQveak.js

@@ -0,0 +1,2 @@
+import { r as e } from "./addCommand-BNeoeSxe.js";
+export { e as runAddCommand };

package/dist/agentsMd-BTchIZku.js

@@ -0,0 +1,2 @@
+import { a as e } from "./agentsMd-mhQMF1bx.js";
+export { e as runAgentsMd };