@maroonedsoftware/johnny5 0.1.0

package/dist/integrations/docker/index.js

@@ -0,0 +1,102 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/integrations/docker/index.ts
+import { existsSync } from "fs";
+import { isAbsolute, resolve } from "path";
+var parseComposePs = /* @__PURE__ */ __name((raw) => {
+  const trimmed = raw.trim();
+  if (!trimmed) return [];
+  if (trimmed.startsWith("[")) {
+    return JSON.parse(trimmed);
+  }
+  const services = [];
+  for (const line of trimmed.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      services.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return services;
+}, "parseComposePs");
+var dockerServicesUp = /* @__PURE__ */ __name((options = {}) => {
+  const composeFileRel = options.composeFile ?? "docker-compose.yml";
+  const skipIfMissing = options.skipIfMissing ?? true;
+  const check = {
+    name: "docker compose services up",
+    run: /* @__PURE__ */ __name(async (ctx) => {
+      const composeFile = isAbsolute(composeFileRel) ? composeFileRel : resolve(ctx.paths.repoRoot, composeFileRel);
+      if (!existsSync(composeFile)) {
+        return skipIfMissing ? {
+          ok: true,
+          message: `no ${composeFileRel}; skipping`
+        } : {
+          ok: false,
+          message: `${composeFile} is missing`
+        };
+      }
+      let raw;
+      try {
+        const result = await ctx.shell.run("docker", [
+          "compose",
+          "ps",
+          "--format",
+          "json"
+        ], {
+          cwd: ctx.paths.repoRoot
+        });
+        raw = String(result.stdout);
+      } catch (err) {
+        return {
+          ok: false,
+          message: `\`docker compose ps\` failed: ${err.message}`,
+          fixHint: "Ensure Docker is installed and running."
+        };
+      }
+      const services = parseComposePs(raw);
+      if (services.length === 0) {
+        return {
+          ok: false,
+          message: "no compose services running",
+          fixHint: "Run `docker compose up -d`."
+        };
+      }
+      const notRunning = services.filter((s) => s.State !== "running");
+      if (notRunning.length > 0) {
+        return {
+          ok: false,
+          message: `not running: ${notRunning.map((s) => s.Service).join(", ")}`,
+          fixHint: "Run `docker compose up -d`."
+        };
+      }
+      return {
+        ok: true,
+        message: `${services.length} service(s) running`
+      };
+    }, "run")
+  };
+  if (options.autoStart) {
+    check.autoFix = async (ctx) => {
+      const exit = await ctx.shell.runStreaming("docker", [
+        "compose",
+        "up",
+        "-d"
+      ], {
+        cwd: ctx.paths.repoRoot
+      });
+      return exit === 0 ? {
+        ok: true,
+        message: "compose services started"
+      } : {
+        ok: false,
+        message: `compose up exited ${exit}`
+      };
+    };
+  }
+  return check;
+}, "dockerServicesUp");
+export {
+  dockerServicesUp
+};
+//# sourceMappingURL=index.js.map

package/dist/integrations/docker/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/integrations/docker/index.ts"],"sourcesContent":["import { existsSync } from 'node:fs';\nimport { isAbsolute, resolve } from 'node:path';\nimport type { Check } from '../../types.js';\n\n/** Options for `dockerServicesUp`. */\nexport interface DockerServicesOptions {\n    /**\n     * Path to `docker-compose.yml`. Relative paths are resolved against the\n     * repo root. Defaults to `'docker-compose.yml'`.\n     */\n    composeFile?: string;\n    /**\n     * When true (default), a missing compose file is treated as a passing\n     * check with a skip message. When false, it's a failure.\n     */\n    skipIfMissing?: boolean;\n    /** When true, the check attaches an `autoFix` that runs `docker compose up -d`. */\n    autoStart?: boolean;\n}\n\ninterface ComposeService {\n    Service: string;\n    State: string;\n}\n\nconst parseComposePs = (raw: string): ComposeService[] => {\n    const trimmed = raw.trim();\n    if (!trimmed) return [];\n    if (trimmed.startsWith('[')) {\n        return JSON.parse(trimmed) as ComposeService[];\n    }\n    // NDJSON\n    const services: ComposeService[] = [];\n    for (const line of trimmed.split('\\n')) {\n        if (!line.trim()) continue;\n        try {\n            services.push(JSON.parse(line) as ComposeService);\n        } catch {\n            // ignore malformed line\n        }\n    }\n    return services;\n};\n\n/**\n * Check that `docker compose ps` reports every service in the running state.\n * Parses both JSON-array and NDJSON output formats. When `autoStart` is set the\n * returned check exposes an `autoFix` that runs `docker compose up -d`.\n */\nexport const dockerServicesUp = (options: DockerServicesOptions = {}): Check => {\n    const composeFileRel = options.composeFile ?? 'docker-compose.yml';\n    const skipIfMissing = options.skipIfMissing ?? true;\n\n    const check: Check = {\n        name: 'docker compose services up',\n        run: async ctx => {\n            const composeFile = isAbsolute(composeFileRel) ? composeFileRel : resolve(ctx.paths.repoRoot, composeFileRel);\n            if (!existsSync(composeFile)) {\n                return skipIfMissing\n                    ? { ok: true, message: `no ${composeFileRel}; skipping` }\n                    : { ok: false, message: `${composeFile} is missing` };\n            }\n            let raw: string;\n            try {\n                const result = await ctx.shell.run('docker', ['compose', 'ps', '--format', 'json'], { cwd: ctx.paths.repoRoot });\n                raw = String(result.stdout);\n            } catch (err) {\n                return {\n                    ok: false,\n                    message: `\\`docker compose ps\\` failed: ${(err as Error).message}`,\n                    fixHint: 'Ensure Docker is installed and running.',\n                };\n            }\n\n            const services = parseComposePs(raw);\n            if (services.length === 0) {\n                return {\n                    ok: false,\n                    message: 'no compose services running',\n                    fixHint: 'Run `docker compose up -d`.',\n                };\n            }\n            const notRunning = services.filter(s => s.State !== 'running');\n            if (notRunning.length > 0) {\n                return {\n                    ok: false,\n                    message: `not running: ${notRunning.map(s => s.Service).join(', ')}`,\n                    fixHint: 'Run `docker compose up -d`.',\n                };\n            }\n            return { ok: true, message: `${services.length} service(s) running` };\n        },\n    };\n\n    if (options.autoStart) {\n        check.autoFix = async ctx => {\n            const exit = await ctx.shell.runStreaming('docker', ['compose', 'up', '-d'], { cwd: ctx.paths.repoRoot });\n            return exit === 0 ? { ok: true, message: 'compose services started' } : { ok: false, message: `compose up exited ${exit}` };\n        };\n    }\n\n    return check;\n};\n"],"mappings":";;;;AAAA,SAASA,kBAAkB;AAC3B,SAASC,YAAYC,eAAe;AAwBpC,IAAMC,iBAAiB,wBAACC,QAAAA;AACpB,QAAMC,UAAUD,IAAIE,KAAI;AACxB,MAAI,CAACD,QAAS,QAAO,CAAA;AACrB,MAAIA,QAAQE,WAAW,GAAA,GAAM;AACzB,WAAOC,KAAKC,MAAMJ,OAAAA;EACtB;AAEA,QAAMK,WAA6B,CAAA;AACnC,aAAWC,QAAQN,QAAQO,MAAM,IAAA,GAAO;AACpC,QAAI,CAACD,KAAKL,KAAI,EAAI;AAClB,QAAI;AACAI,eAASG,KAAKL,KAAKC,MAAME,IAAAA,CAAAA;IAC7B,QAAQ;IAER;EACJ;AACA,SAAOD;AACX,GAjBuB;AAwBhB,IAAMI,mBAAmB,wBAACC,UAAiC,CAAC,MAAC;AAChE,QAAMC,iBAAiBD,QAAQE,eAAe;AAC9C,QAAMC,gBAAgBH,QAAQG,iBAAiB;AAE/C,QAAMC,QAAe;IACjBC,MAAM;IACNC,KAAK,8BAAMC,QAAAA;AACP,YAAML,cAAcM,WAAWP,cAAAA,IAAkBA,iBAAiBQ,QAAQF,IAAIG,MAAMC,UAAUV,cAAAA;AAC9F,UAAI,CAACW,WAAWV,WAAAA,GAAc;AAC1B,eAAOC,gBACD;UAAEU,IAAI;UAAMC,SAAS,MAAMb,cAAAA;QAA2B,IACtD;UAAEY,IAAI;UAAOC,SAAS,GAAGZ,WAAAA;QAAyB;MAC5D;AACA,UAAIb;AACJ,UAAI;AACA,cAAM0B,SAAS,MAAMR,IAAIS,MAAMV,IAAI,UAAU;UAAC;UAAW;UAAM;UAAY;WAAS;UAAEW,KAAKV,IAAIG,MAAMC;QAAS,CAAA;AAC9GtB,cAAM6B,OAAOH,OAAOI,MAAM;MAC9B,SAASC,KAAK;AACV,eAAO;UACHP,IAAI;UACJC,SAAS,iCAAkCM,IAAcN,OAAO;UAChEO,SAAS;QACb;MACJ;AAEA,YAAM1B,WAAWP,eAAeC,GAAAA;AAChC,UAAIM,SAAS2B,WAAW,GAAG;AACvB,eAAO;UACHT,IAAI;UACJC,SAAS;UACTO,SAAS;QACb;MACJ;AACA,YAAME,aAAa5B,SAAS6B,OAAOC,CAAAA,MAAKA,EAAEC,UAAU,SAAA;AACpD,UAAIH,WAAWD,SAAS,GAAG;AACvB,eAAO;UACHT,IAAI;UACJC,SAAS,gBAAgBS,WAAWI,IAAIF,CAAAA,MAAKA,EAAEG,OAAO,EAAEC,KAAK,IAAA,CAAA;UAC7DR,SAAS;QACb;MACJ;AACA,aAAO;QAAER,IAAI;QAAMC,SAAS,GAAGnB,SAAS2B,MAAM;MAAsB;IACxE,GApCK;EAqCT;AAEA,MAAItB,QAAQ8B,WAAW;AACnB1B,UAAM2B,UAAU,OAAMxB,QAAAA;AAClB,YAAMyB,OAAO,MAAMzB,IAAIS,MAAMiB,aAAa,UAAU;QAAC;QAAW;QAAM;SAAO;QAAEhB,KAAKV,IAAIG,MAAMC;MAAS,CAAA;AACvG,aAAOqB,SAAS,IAAI;QAAEnB,IAAI;QAAMC,SAAS;MAA2B,IAAI;QAAED,IAAI;QAAOC,SAAS,qBAAqBkB,IAAAA;MAAO;IAC9H;EACJ;AAEA,SAAO5B;AACX,GArDgC;","names":["existsSync","isAbsolute","resolve","parseComposePs","raw","trimmed","trim","startsWith","JSON","parse","services","line","split","push","dockerServicesUp","options","composeFileRel","composeFile","skipIfMissing","check","name","run","ctx","isAbsolute","resolve","paths","repoRoot","existsSync","ok","message","result","shell","cwd","String","stdout","err","fixHint","length","notRunning","filter","s","State","map","Service","join","autoStart","autoFix","exit","runStreaming"]}

package/dist/integrations/filesystem/index.d.ts

@@ -0,0 +1,31 @@
+import { b as Check } from '../../types-CH7ccr3j.js';
+import '@maroonedsoftware/appconfig';
+import 'execa';
+
+/** Options for `envFile`. */
+interface EnvFileOptions {
+    /** Path to the .env file. Relative paths are resolved against the repo root. */
+    path: string;
+    /** Process env vars that must be set after the file is loaded. */
+    required?: string[];
+}
+/**
+ * Check that an `.env` file exists at `options.path` and that every entry in
+ * `options.required` is present on `process.env`. Note: this check does not
+ * itself load the file — it assumes `buildContext` has already done so.
+ */
+declare const envFile: (options: EnvFileOptions) => Check;
+/** Options for `portsFree`. Each entry is either a bare port number or `{ port, label }`. */
+interface PortsFreeOptions {
+    ports: Array<{
+        port: number;
+        label?: string;
+    } | number>;
+}
+/**
+ * Check that every port in `options.ports` is free on `127.0.0.1`. Probes by
+ * attempting to bind; reports the labels of any port that fails to bind.
+ */
+declare const portsFree: (options: PortsFreeOptions) => Check;
+
+export { type EnvFileOptions, type PortsFreeOptions, envFile, portsFree };

package/dist/integrations/filesystem/index.js

@@ -0,0 +1,73 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/integrations/filesystem/index.ts
+import net from "net";
+import { existsSync } from "fs";
+import { isAbsolute, resolve } from "path";
+var envFile = /* @__PURE__ */ __name((options) => ({
+  name: `${options.path} present`,
+  run: /* @__PURE__ */ __name(async (ctx) => {
+    const absolute = isAbsolute(options.path) ? options.path : resolve(ctx.paths.repoRoot, options.path);
+    if (!existsSync(absolute)) {
+      return {
+        ok: false,
+        message: `${absolute} is missing`,
+        fixHint: `Create ${options.path} (often from a .env.example).`
+      };
+    }
+    const missing = (options.required ?? []).filter((v) => !process.env[v]);
+    if (missing.length > 0) {
+      return {
+        ok: false,
+        message: `present, but missing: ${missing.join(", ")}`,
+        fixHint: `Add ${missing.join(", ")} to ${options.path}`
+      };
+    }
+    return {
+      ok: true,
+      message: "present"
+    };
+  }, "run")
+}), "envFile");
+var probePort = /* @__PURE__ */ __name((port) => new Promise((resolveDone) => {
+  const server = net.createServer();
+  server.once("error", () => resolveDone(false));
+  server.once("listening", () => {
+    server.close(() => resolveDone(true));
+  });
+  server.listen(port, "127.0.0.1");
+}), "probePort");
+var portsFree = /* @__PURE__ */ __name((options) => {
+  const specs = options.ports.map((p) => typeof p === "number" ? {
+    port: p,
+    label: String(p)
+  } : {
+    port: p.port,
+    label: p.label ?? String(p.port)
+  });
+  return {
+    name: "dev ports free",
+    run: /* @__PURE__ */ __name(async () => {
+      const occupied = [];
+      for (const spec of specs) {
+        const free = await probePort(spec.port);
+        if (!free) occupied.push(spec);
+      }
+      if (occupied.length === 0) return {
+        ok: true,
+        message: specs.map((s) => `:${s.port}`).join(", ")
+      };
+      return {
+        ok: false,
+        message: `in use: ${occupied.map((s) => `${s.label}:${s.port}`).join(", ")}`,
+        fixHint: `Stop the process holding these ports (\`lsof -i :${occupied[0]?.port}\`).`
+      };
+    }, "run")
+  };
+}, "portsFree");
+export {
+  envFile,
+  portsFree
+};
+//# sourceMappingURL=index.js.map

package/dist/integrations/filesystem/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/integrations/filesystem/index.ts"],"sourcesContent":["import net from 'node:net';\nimport { existsSync } from 'node:fs';\nimport { isAbsolute, resolve } from 'node:path';\nimport type { Check } from '../../types.js';\n\n/** Options for `envFile`. */\nexport interface EnvFileOptions {\n    /** Path to the .env file. Relative paths are resolved against the repo root. */\n    path: string;\n    /** Process env vars that must be set after the file is loaded. */\n    required?: string[];\n}\n\n/**\n * Check that an `.env` file exists at `options.path` and that every entry in\n * `options.required` is present on `process.env`. Note: this check does not\n * itself load the file — it assumes `buildContext` has already done so.\n */\nexport const envFile = (options: EnvFileOptions): Check => ({\n    name: `${options.path} present`,\n    run: async ctx => {\n        const absolute = isAbsolute(options.path) ? options.path : resolve(ctx.paths.repoRoot, options.path);\n        if (!existsSync(absolute)) {\n            return {\n                ok: false,\n                message: `${absolute} is missing`,\n                fixHint: `Create ${options.path} (often from a .env.example).`,\n            };\n        }\n        const missing = (options.required ?? []).filter(v => !process.env[v]);\n        if (missing.length > 0) {\n            return {\n                ok: false,\n                message: `present, but missing: ${missing.join(', ')}`,\n                fixHint: `Add ${missing.join(', ')} to ${options.path}`,\n            };\n        }\n        return { ok: true, message: 'present' };\n    },\n});\n\n/** Options for `portsFree`. Each entry is either a bare port number or `{ port, label }`. */\nexport interface PortsFreeOptions {\n    ports: Array<{ port: number; label?: string } | number>;\n}\n\nconst probePort = (port: number): Promise<boolean> =>\n    new Promise(resolveDone => {\n        const server = net.createServer();\n        server.once('error', () => resolveDone(false));\n        server.once('listening', () => {\n            server.close(() => resolveDone(true));\n        });\n        server.listen(port, '127.0.0.1');\n    });\n\n/**\n * Check that every port in `options.ports` is free on `127.0.0.1`. Probes by\n * attempting to bind; reports the labels of any port that fails to bind.\n */\nexport const portsFree = (options: PortsFreeOptions): Check => {\n    const specs = options.ports.map(p => (typeof p === 'number' ? { port: p, label: String(p) } : { port: p.port, label: p.label ?? String(p.port) }));\n    return {\n        name: 'dev ports free',\n        run: async () => {\n            const occupied: Array<{ port: number; label: string }> = [];\n            for (const spec of specs) {\n                const free = await probePort(spec.port);\n                if (!free) occupied.push(spec);\n            }\n            if (occupied.length === 0) return { ok: true, message: specs.map(s => `:${s.port}`).join(', ') };\n            return {\n                ok: false,\n                message: `in use: ${occupied.map(s => `${s.label}:${s.port}`).join(', ')}`,\n                fixHint: `Stop the process holding these ports (\\`lsof -i :${occupied[0]?.port}\\`).`,\n            };\n        },\n    };\n};\n"],"mappings":";;;;AAAA,OAAOA,SAAS;AAChB,SAASC,kBAAkB;AAC3B,SAASC,YAAYC,eAAe;AAgB7B,IAAMC,UAAU,wBAACC,aAAoC;EACxDC,MAAM,GAAGD,QAAQE,IAAI;EACrBC,KAAK,8BAAMC,QAAAA;AACP,UAAMC,WAAWC,WAAWN,QAAQE,IAAI,IAAIF,QAAQE,OAAOK,QAAQH,IAAII,MAAMC,UAAUT,QAAQE,IAAI;AACnG,QAAI,CAACQ,WAAWL,QAAAA,GAAW;AACvB,aAAO;QACHM,IAAI;QACJC,SAAS,GAAGP,QAAAA;QACZQ,SAAS,UAAUb,QAAQE,IAAI;MACnC;IACJ;AACA,UAAMY,WAAWd,QAAQe,YAAY,CAAA,GAAIC,OAAOC,CAAAA,MAAK,CAACC,QAAQC,IAAIF,CAAAA,CAAE;AACpE,QAAIH,QAAQM,SAAS,GAAG;AACpB,aAAO;QACHT,IAAI;QACJC,SAAS,yBAAyBE,QAAQO,KAAK,IAAA,CAAA;QAC/CR,SAAS,OAAOC,QAAQO,KAAK,IAAA,CAAA,OAAYrB,QAAQE,IAAI;MACzD;IACJ;AACA,WAAO;MAAES,IAAI;MAAMC,SAAS;IAAU;EAC1C,GAlBK;AAmBT,IArBuB;AA4BvB,IAAMU,YAAY,wBAACC,SACf,IAAIC,QAAQC,CAAAA,gBAAAA;AACR,QAAMC,SAASC,IAAIC,aAAY;AAC/BF,SAAOG,KAAK,SAAS,MAAMJ,YAAY,KAAA,CAAA;AACvCC,SAAOG,KAAK,aAAa,MAAA;AACrBH,WAAOI,MAAM,MAAML,YAAY,IAAA,CAAA;EACnC,CAAA;AACAC,SAAOK,OAAOR,MAAM,WAAA;AACxB,CAAA,GARc;AAcX,IAAMS,YAAY,wBAAChC,YAAAA;AACtB,QAAMiC,QAAQjC,QAAQkC,MAAMC,IAAIC,CAAAA,MAAM,OAAOA,MAAM,WAAW;IAAEb,MAAMa;IAAGC,OAAOC,OAAOF,CAAAA;EAAG,IAAI;IAAEb,MAAMa,EAAEb;IAAMc,OAAOD,EAAEC,SAASC,OAAOF,EAAEb,IAAI;EAAE,CAAA;AAC/I,SAAO;IACHtB,MAAM;IACNE,KAAK,mCAAA;AACD,YAAMoC,WAAmD,CAAA;AACzD,iBAAWC,QAAQP,OAAO;AACtB,cAAMQ,OAAO,MAAMnB,UAAUkB,KAAKjB,IAAI;AACtC,YAAI,CAACkB,KAAMF,UAASG,KAAKF,IAAAA;MAC7B;AACA,UAAID,SAASnB,WAAW,EAAG,QAAO;QAAET,IAAI;QAAMC,SAASqB,MAAME,IAAIQ,CAAAA,MAAK,IAAIA,EAAEpB,IAAI,EAAE,EAAEF,KAAK,IAAA;MAAM;AAC/F,aAAO;QACHV,IAAI;QACJC,SAAS,WAAW2B,SAASJ,IAAIQ,CAAAA,MAAK,GAAGA,EAAEN,KAAK,IAAIM,EAAEpB,IAAI,EAAE,EAAEF,KAAK,IAAA,CAAA;QACnER,SAAS,oDAAoD0B,SAAS,CAAA,GAAIhB,IAAAA;MAC9E;IACJ,GAZK;EAaT;AACJ,GAlByB;","names":["net","existsSync","isAbsolute","resolve","envFile","options","name","path","run","ctx","absolute","isAbsolute","resolve","paths","repoRoot","existsSync","ok","message","fixHint","missing","required","filter","v","process","env","length","join","probePort","port","Promise","resolveDone","server","net","createServer","once","close","listen","portsFree","specs","ports","map","p","label","String","occupied","spec","free","push","s"]}

package/dist/integrations/postgres/index.d.ts

@@ -0,0 +1,24 @@
+import { b as Check } from '../../types-CH7ccr3j.js';
+import '@maroonedsoftware/appconfig';
+import 'execa';
+
+/** Options for `postgresReachable`. */
+interface PostgresReachableOptions {
+    /**
+     * The AppConfig key whose string value holds the connection string.
+     * Defaults to `'DATABASE_URL'`.
+     */
+    configKey?: string;
+    /** Direct override — takes precedence over `configKey`. */
+    connectionString?: string;
+    /** Connection timeout in milliseconds. Defaults to `2000`. */
+    timeoutMs?: number;
+}
+/**
+ * Check that Postgres accepts a connection and responds to `select version()`.
+ * Lazily loads `pg` so consumers who don't need the check don't pay the import
+ * cost. Returns a failing result with a clear message when `pg` isn't installed.
+ */
+declare const postgresReachable: (options?: PostgresReachableOptions) => Check;
+
+export { type PostgresReachableOptions, postgresReachable };

package/dist/integrations/postgres/index.js

@@ -0,0 +1,60 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/integrations/postgres/index.ts
+var postgresReachable = /* @__PURE__ */ __name((options = {}) => ({
+  name: "postgres reachable",
+  run: /* @__PURE__ */ __name(async (ctx) => {
+    let pg;
+    try {
+      pg = await import("pg");
+    } catch {
+      return {
+        ok: false,
+        message: "`pg` is not installed; add it as a dependency to use this check"
+      };
+    }
+    const configKey = options.configKey ?? "DATABASE_URL";
+    let url = options.connectionString;
+    if (!url) {
+      try {
+        url = ctx.config.getString(configKey);
+      } catch {
+        url = process.env[configKey];
+      }
+    }
+    if (!url) {
+      return {
+        ok: false,
+        message: `${configKey} is not set`,
+        fixHint: `Set ${configKey} in your .env.`
+      };
+    }
+    const client = new pg.Client({
+      connectionString: url,
+      connectionTimeoutMillis: options.timeoutMs ?? 2e3
+    });
+    try {
+      await client.connect();
+      const result = await client.query("select version() as version");
+      const version = result.rows[0]?.version ?? "unknown";
+      const short = version.split(" ").slice(0, 2).join(" ");
+      return {
+        ok: true,
+        message: short
+      };
+    } catch (err) {
+      return {
+        ok: false,
+        message: `connection failed: ${err.message}`,
+        fixHint: "Start Postgres (`docker compose up -d`) or check the connection string."
+      };
+    } finally {
+      await client.end().catch(() => void 0);
+    }
+  }, "run")
+}), "postgresReachable");
+export {
+  postgresReachable
+};
+//# sourceMappingURL=index.js.map

package/dist/integrations/postgres/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/integrations/postgres/index.ts"],"sourcesContent":["import type { Check } from '../../types.js';\n\n/** Options for `postgresReachable`. */\nexport interface PostgresReachableOptions {\n    /**\n     * The AppConfig key whose string value holds the connection string.\n     * Defaults to `'DATABASE_URL'`.\n     */\n    configKey?: string;\n    /** Direct override — takes precedence over `configKey`. */\n    connectionString?: string;\n    /** Connection timeout in milliseconds. Defaults to `2000`. */\n    timeoutMs?: number;\n}\n\n/**\n * Check that Postgres accepts a connection and responds to `select version()`.\n * Lazily loads `pg` so consumers who don't need the check don't pay the import\n * cost. Returns a failing result with a clear message when `pg` isn't installed.\n */\nexport const postgresReachable = (options: PostgresReachableOptions = {}): Check => ({\n    name: 'postgres reachable',\n    run: async ctx => {\n        let pg: typeof import('pg');\n        try {\n            pg = await import('pg');\n        } catch {\n            return { ok: false, message: '`pg` is not installed; add it as a dependency to use this check' };\n        }\n\n        const configKey = options.configKey ?? 'DATABASE_URL';\n        let url: string | undefined = options.connectionString;\n        if (!url) {\n            try {\n                url = ctx.config.getString(configKey);\n            } catch {\n                url = process.env[configKey];\n            }\n        }\n        if (!url) {\n            return {\n                ok: false,\n                message: `${configKey} is not set`,\n                fixHint: `Set ${configKey} in your .env.`,\n            };\n        }\n\n        const client = new pg.Client({ connectionString: url, connectionTimeoutMillis: options.timeoutMs ?? 2000 });\n        try {\n            await client.connect();\n            const result = await client.query<{ version: string }>('select version() as version');\n            const version = result.rows[0]?.version ?? 'unknown';\n            const short = version.split(' ').slice(0, 2).join(' ');\n            return { ok: true, message: short };\n        } catch (err) {\n            return {\n                ok: false,\n                message: `connection failed: ${(err as Error).message}`,\n                fixHint: 'Start Postgres (`docker compose up -d`) or check the connection string.',\n            };\n        } finally {\n            await client.end().catch(() => undefined);\n        }\n    },\n});\n"],"mappings":";;;;AAoBO,IAAMA,oBAAoB,wBAACC,UAAoC,CAAC,OAAc;EACjFC,MAAM;EACNC,KAAK,8BAAMC,QAAAA;AACP,QAAIC;AACJ,QAAI;AACAA,WAAK,MAAM,OAAO,IAAA;IACtB,QAAQ;AACJ,aAAO;QAAEC,IAAI;QAAOC,SAAS;MAAkE;IACnG;AAEA,UAAMC,YAAYP,QAAQO,aAAa;AACvC,QAAIC,MAA0BR,QAAQS;AACtC,QAAI,CAACD,KAAK;AACN,UAAI;AACAA,cAAML,IAAIO,OAAOC,UAAUJ,SAAAA;MAC/B,QAAQ;AACJC,cAAMI,QAAQC,IAAIN,SAAAA;MACtB;IACJ;AACA,QAAI,CAACC,KAAK;AACN,aAAO;QACHH,IAAI;QACJC,SAAS,GAAGC,SAAAA;QACZO,SAAS,OAAOP,SAAAA;MACpB;IACJ;AAEA,UAAMQ,SAAS,IAAIX,GAAGY,OAAO;MAAEP,kBAAkBD;MAAKS,yBAAyBjB,QAAQkB,aAAa;IAAK,CAAA;AACzG,QAAI;AACA,YAAMH,OAAOI,QAAO;AACpB,YAAMC,SAAS,MAAML,OAAOM,MAA2B,6BAAA;AACvD,YAAMC,UAAUF,OAAOG,KAAK,CAAA,GAAID,WAAW;AAC3C,YAAME,QAAQF,QAAQG,MAAM,GAAA,EAAKC,MAAM,GAAG,CAAA,EAAGC,KAAK,GAAA;AAClD,aAAO;QAAEtB,IAAI;QAAMC,SAASkB;MAAM;IACtC,SAASI,KAAK;AACV,aAAO;QACHvB,IAAI;QACJC,SAAS,sBAAuBsB,IAActB,OAAO;QACrDQ,SAAS;MACb;IACJ,UAAA;AACI,YAAMC,OAAOc,IAAG,EAAGC,MAAM,MAAMC,MAAAA;IACnC;EACJ,GAzCK;AA0CT,IA5CiC;","names":["postgresReachable","options","name","run","ctx","pg","ok","message","configKey","url","connectionString","config","getString","process","env","fixHint","client","Client","connectionTimeoutMillis","timeoutMs","connect","result","query","version","rows","short","split","slice","join","err","end","catch","undefined"]}

package/dist/integrations/redis/index.d.ts

@@ -0,0 +1,28 @@
+import { b as Check } from '../../types-CH7ccr3j.js';
+import '@maroonedsoftware/appconfig';
+import 'execa';
+
+/** Options for `redisReachable`. */
+interface RedisReachableOptions {
+    /** Direct override for the Redis host. Takes precedence over `hostConfigKey` / env. */
+    host?: string;
+    /** Direct override for the Redis port. Takes precedence over `portConfigKey` / env. */
+    port?: number;
+    /**
+     * Optional AppConfig keys to read host/port from when they aren't supplied
+     * directly. Default: `'REDIS_HOST'`, `'REDIS_PORT'`. Falls back to the
+     * matching `process.env` entry when the config getter throws.
+     */
+    hostConfigKey?: string;
+    portConfigKey?: string;
+    /** Connection timeout in milliseconds. Defaults to `2000`. */
+    timeoutMs?: number;
+}
+/**
+ * Check that Redis is reachable and answers `PING`. Lazily loads `ioredis` so
+ * consumers who don't need the check don't pay the import cost. Returns a
+ * failing result with a clear message when `ioredis` isn't installed.
+ */
+declare const redisReachable: (options?: RedisReachableOptions) => Check;
+
+export { type RedisReachableOptions, redisReachable };

package/dist/integrations/redis/index.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/integrations/redis/index.ts
+var readConfigString = /* @__PURE__ */ __name((ctx, key) => {
+  try {
+    return ctx.config.getString(key);
+  } catch {
+    return process.env[key];
+  }
+}, "readConfigString");
+var readConfigNumber = /* @__PURE__ */ __name((ctx, key) => {
+  try {
+    return ctx.config.getNumber(key);
+  } catch {
+    const raw = process.env[key];
+    return raw ? Number(raw) : void 0;
+  }
+}, "readConfigNumber");
+var redisReachable = /* @__PURE__ */ __name((options = {}) => ({
+  name: "redis reachable",
+  run: /* @__PURE__ */ __name(async (ctx) => {
+    let RedisCtor;
+    try {
+      const mod = await import("ioredis");
+      RedisCtor = mod.Redis;
+    } catch {
+      return {
+        ok: false,
+        message: "`ioredis` is not installed; add it as a dependency to use this check"
+      };
+    }
+    const host = options.host ?? readConfigString(ctx, options.hostConfigKey ?? "REDIS_HOST") ?? "localhost";
+    const port = options.port ?? readConfigNumber(ctx, options.portConfigKey ?? "REDIS_PORT") ?? 6379;
+    const redis = new RedisCtor({
+      host,
+      port,
+      lazyConnect: true,
+      connectTimeout: options.timeoutMs ?? 2e3,
+      maxRetriesPerRequest: 1,
+      retryStrategy: /* @__PURE__ */ __name(() => null, "retryStrategy")
+    });
+    try {
+      await redis.connect();
+      const pong = await redis.ping();
+      return {
+        ok: pong === "PONG",
+        message: `${host}:${port} \u2192 ${pong}`
+      };
+    } catch (err) {
+      return {
+        ok: false,
+        message: `${host}:${port} unreachable: ${err.message}`,
+        fixHint: "Start Redis (`docker compose up -d`) or set the host/port options."
+      };
+    } finally {
+      redis.disconnect();
+    }
+  }, "run")
+}), "redisReachable");
+export {
+  redisReachable
+};
+//# sourceMappingURL=index.js.map

package/dist/integrations/redis/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/integrations/redis/index.ts"],"sourcesContent":["import type { Check } from '../../types.js';\n\n/** Options for `redisReachable`. */\nexport interface RedisReachableOptions {\n    /** Direct override for the Redis host. Takes precedence over `hostConfigKey` / env. */\n    host?: string;\n    /** Direct override for the Redis port. Takes precedence over `portConfigKey` / env. */\n    port?: number;\n    /**\n     * Optional AppConfig keys to read host/port from when they aren't supplied\n     * directly. Default: `'REDIS_HOST'`, `'REDIS_PORT'`. Falls back to the\n     * matching `process.env` entry when the config getter throws.\n     */\n    hostConfigKey?: string;\n    portConfigKey?: string;\n    /** Connection timeout in milliseconds. Defaults to `2000`. */\n    timeoutMs?: number;\n}\n\nconst readConfigString = (ctx: { config: { getString: (key: string) => string } }, key: string): string | undefined => {\n    try {\n        return ctx.config.getString(key);\n    } catch {\n        return process.env[key];\n    }\n};\n\nconst readConfigNumber = (ctx: { config: { getNumber: (key: string) => number } }, key: string): number | undefined => {\n    try {\n        return ctx.config.getNumber(key);\n    } catch {\n        const raw = process.env[key];\n        return raw ? Number(raw) : undefined;\n    }\n};\n\n/**\n * Check that Redis is reachable and answers `PING`. Lazily loads `ioredis` so\n * consumers who don't need the check don't pay the import cost. Returns a\n * failing result with a clear message when `ioredis` isn't installed.\n */\nexport const redisReachable = (options: RedisReachableOptions = {}): Check => ({\n    name: 'redis reachable',\n    run: async ctx => {\n        let RedisCtor: typeof import('ioredis').Redis;\n        try {\n            const mod = await import('ioredis');\n            RedisCtor = mod.Redis;\n        } catch {\n            return { ok: false, message: '`ioredis` is not installed; add it as a dependency to use this check' };\n        }\n\n        const host = options.host ?? readConfigString(ctx, options.hostConfigKey ?? 'REDIS_HOST') ?? 'localhost';\n        const port = options.port ?? readConfigNumber(ctx, options.portConfigKey ?? 'REDIS_PORT') ?? 6379;\n\n        const redis = new RedisCtor({\n            host,\n            port,\n            lazyConnect: true,\n            connectTimeout: options.timeoutMs ?? 2000,\n            maxRetriesPerRequest: 1,\n            retryStrategy: () => null,\n        });\n        try {\n            await redis.connect();\n            const pong = await redis.ping();\n            return { ok: pong === 'PONG', message: `${host}:${port} → ${pong}` };\n        } catch (err) {\n            return {\n                ok: false,\n                message: `${host}:${port} unreachable: ${(err as Error).message}`,\n                fixHint: 'Start Redis (`docker compose up -d`) or set the host/port options.',\n            };\n        } finally {\n            redis.disconnect();\n        }\n    },\n});\n"],"mappings":";;;;AAmBA,IAAMA,mBAAmB,wBAACC,KAAyDC,QAAAA;AAC/E,MAAI;AACA,WAAOD,IAAIE,OAAOC,UAAUF,GAAAA;EAChC,QAAQ;AACJ,WAAOG,QAAQC,IAAIJ,GAAAA;EACvB;AACJ,GANyB;AAQzB,IAAMK,mBAAmB,wBAACN,KAAyDC,QAAAA;AAC/E,MAAI;AACA,WAAOD,IAAIE,OAAOK,UAAUN,GAAAA;EAChC,QAAQ;AACJ,UAAMO,MAAMJ,QAAQC,IAAIJ,GAAAA;AACxB,WAAOO,MAAMC,OAAOD,GAAAA,IAAOE;EAC/B;AACJ,GAPyB;AAclB,IAAMC,iBAAiB,wBAACC,UAAiC,CAAC,OAAc;EAC3EC,MAAM;EACNC,KAAK,8BAAMd,QAAAA;AACP,QAAIe;AACJ,QAAI;AACA,YAAMC,MAAM,MAAM,OAAO,SAAA;AACzBD,kBAAYC,IAAIC;IACpB,QAAQ;AACJ,aAAO;QAAEC,IAAI;QAAOC,SAAS;MAAuE;IACxG;AAEA,UAAMC,OAAOR,QAAQQ,QAAQrB,iBAAiBC,KAAKY,QAAQS,iBAAiB,YAAA,KAAiB;AAC7F,UAAMC,OAAOV,QAAQU,QAAQhB,iBAAiBN,KAAKY,QAAQW,iBAAiB,YAAA,KAAiB;AAE7F,UAAMC,QAAQ,IAAIT,UAAU;MACxBK;MACAE;MACAG,aAAa;MACbC,gBAAgBd,QAAQe,aAAa;MACrCC,sBAAsB;MACtBC,eAAe,6BAAM,MAAN;IACnB,CAAA;AACA,QAAI;AACA,YAAML,MAAMM,QAAO;AACnB,YAAMC,OAAO,MAAMP,MAAMQ,KAAI;AAC7B,aAAO;QAAEd,IAAIa,SAAS;QAAQZ,SAAS,GAAGC,IAAAA,IAAQE,IAAAA,WAAUS,IAAAA;MAAO;IACvE,SAASE,KAAK;AACV,aAAO;QACHf,IAAI;QACJC,SAAS,GAAGC,IAAAA,IAAQE,IAAAA,iBAAsBW,IAAcd,OAAO;QAC/De,SAAS;MACb;IACJ,UAAA;AACIV,YAAMW,WAAU;IACpB;EACJ,GAjCK;AAkCT,IApC8B;","names":["readConfigString","ctx","key","config","getString","process","env","readConfigNumber","getNumber","raw","Number","undefined","redisReachable","options","name","run","RedisCtor","mod","Redis","ok","message","host","hostConfigKey","port","portConfigKey","redis","lazyConnect","connectTimeout","timeoutMs","maxRetriesPerRequest","retryStrategy","connect","pong","ping","err","fixHint","disconnect"]}

package/dist/integrations/serverkit/index.d.ts

@@ -0,0 +1,50 @@
+import { Container, ScopedContainer } from 'injectkit';
+import { AppConfig } from '@maroonedsoftware/appconfig';
+import { Logger } from '@maroonedsoftware/logger';
+import { ServerKitModule } from '@maroonedsoftware/koa';
+import { C as CliContext, d as CommandModule } from '../../types-CH7ccr3j.js';
+import 'execa';
+
+/** Options accepted by `bootstrapForCli`. */
+interface BootstrapForCliOptions<ConfigT extends AppConfig = AppConfig> {
+    modules: ServerKitModule<ConfigT>[];
+    config: ConfigT;
+    logger?: Logger;
+}
+/** An InjectKit container and a `shutdown` hook that runs every module's `shutdown` in reverse order. */
+interface CliContainer {
+    container: Container;
+    shutdown: () => Promise<void>;
+}
+/**
+ * Run each `module.setup(registry, config)` and build the InjectKit container.
+ * Deliberately does NOT call `module.start()` — CLIs don't want background work
+ * (HTTP listeners, job pollers) spinning up. Module `shutdown` hooks are
+ * invoked when the returned `shutdown` is called.
+ */
+declare const bootstrapForCli: <ConfigT extends AppConfig = AppConfig>(options: BootstrapForCliOptions<ConfigT>) => Promise<CliContainer>;
+/**
+ * Associate a list of ServerKit modules with a `CliContext`. The first call to
+ * `getOrBootstrapContainer` for that context will lazily run their `setup`
+ * hooks. `createCliApp` calls this automatically when `modules` is supplied.
+ */
+declare const configureServerKitModules: <ConfigT extends AppConfig>(ctx: CliContext, modules: ServerKitModule<ConfigT>[]) => void;
+/**
+ * Return the bootstrapped container for `ctx`, building it on the first call
+ * and caching the promise for subsequent calls within the same process.
+ * Throws if `configureServerKitModules` hasn't been called for this context.
+ */
+declare const getOrBootstrapContainer: (ctx: CliContext) => Promise<CliContainer>;
+/** `CliContext` augmented with a scoped InjectKit container, handed to `requireContainer` handlers. */
+interface RequireContainerCtx extends CliContext {
+    container: ScopedContainer;
+}
+/**
+ * Wrap a command handler so it lazily bootstraps the ServerKit container and
+ * receives a fresh scoped container per invocation. The root container is NOT
+ * shut down between commands within the same process — call `bootstrapForCli`
+ * directly when explicit teardown is required.
+ */
+declare const requireContainer: <Opts = Record<string, unknown>>(handler: (opts: Opts, ctx: RequireContainerCtx, args: string[]) => Promise<number | void>) => CommandModule<Opts>["run"];
+
+export { type BootstrapForCliOptions, type CliContainer, type RequireContainerCtx, bootstrapForCli, configureServerKitModules, getOrBootstrapContainer, requireContainer };

package/dist/integrations/serverkit/index.js

@@ -0,0 +1,74 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/integrations/serverkit/index.ts
+import { InjectKitRegistry } from "injectkit";
+import { AppConfig } from "@maroonedsoftware/appconfig";
+import { ConsoleLogger, Logger } from "@maroonedsoftware/logger";
+var bootstrapForCli = /* @__PURE__ */ __name(async (options) => {
+  const registry = new InjectKitRegistry();
+  registry.register(Logger).useInstance(options.logger ?? new ConsoleLogger());
+  registry.register(AppConfig).useInstance(options.config);
+  for (const module of options.modules) {
+    if (module.setup) await module.setup(registry, options.config);
+  }
+  const container = registry.build();
+  const shutdown = /* @__PURE__ */ __name(async () => {
+    for (const module of [
+      ...options.modules
+    ].reverse()) {
+      if (!module.shutdown) continue;
+      try {
+        await module.shutdown(container);
+      } catch {
+      }
+    }
+  }, "shutdown");
+  return {
+    container,
+    shutdown
+  };
+}, "bootstrapForCli");
+var STATE_KEY = /* @__PURE__ */ Symbol.for("@maroonedsoftware/johnny5/serverkit/state.v1");
+var getState = /* @__PURE__ */ __name(() => {
+  const g = globalThis;
+  if (!g[STATE_KEY]) {
+    g[STATE_KEY] = {
+      containerByContext: /* @__PURE__ */ new WeakMap()
+    };
+  }
+  return g[STATE_KEY];
+}, "getState");
+var configureServerKitModules = /* @__PURE__ */ __name((ctx, modules) => {
+  getState().containerByContext.set(ctx, {
+    modules
+  });
+}, "configureServerKitModules");
+var getOrBootstrapContainer = /* @__PURE__ */ __name(async (ctx) => {
+  const lazy = getState().containerByContext.get(ctx);
+  if (!lazy) throw new Error("ServerKit modules have not been configured on this CliContext \u2014 call configureServerKitModules() in createCliApp first.");
+  if (!lazy.promise) {
+    lazy.promise = bootstrapForCli({
+      modules: lazy.modules,
+      config: ctx.config
+    });
+  }
+  return lazy.promise;
+}, "getOrBootstrapContainer");
+var requireContainer = /* @__PURE__ */ __name((handler) => {
+  return async (opts, ctx, args) => {
+    const { container } = await getOrBootstrapContainer(ctx);
+    const scoped = container.createScopedContainer();
+    const enriched = Object.assign({}, ctx, {
+      container: scoped
+    });
+    return handler(opts, enriched, args);
+  };
+}, "requireContainer");
+export {
+  bootstrapForCli,
+  configureServerKitModules,
+  getOrBootstrapContainer,
+  requireContainer
+};
+//# sourceMappingURL=index.js.map

package/dist/integrations/serverkit/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/integrations/serverkit/index.ts"],"sourcesContent":["import { InjectKitRegistry, type Container, type ScopedContainer } from 'injectkit';\nimport { AppConfig } from '@maroonedsoftware/appconfig';\nimport { ConsoleLogger, Logger } from '@maroonedsoftware/logger';\nimport type { ServerKitModule } from '@maroonedsoftware/koa';\nimport type { CliContext, CommandModule } from '../../types.js';\n\n/** Options accepted by `bootstrapForCli`. */\nexport interface BootstrapForCliOptions<ConfigT extends AppConfig = AppConfig> {\n    modules: ServerKitModule<ConfigT>[];\n    config: ConfigT;\n    logger?: Logger;\n}\n\n/** An InjectKit container and a `shutdown` hook that runs every module's `shutdown` in reverse order. */\nexport interface CliContainer {\n    container: Container;\n    shutdown: () => Promise<void>;\n}\n\n/**\n * Run each `module.setup(registry, config)` and build the InjectKit container.\n * Deliberately does NOT call `module.start()` — CLIs don't want background work\n * (HTTP listeners, job pollers) spinning up. Module `shutdown` hooks are\n * invoked when the returned `shutdown` is called.\n */\nexport const bootstrapForCli = async <ConfigT extends AppConfig = AppConfig>(\n    options: BootstrapForCliOptions<ConfigT>,\n): Promise<CliContainer> => {\n    const registry = new InjectKitRegistry();\n\n    registry.register(Logger).useInstance(options.logger ?? new ConsoleLogger());\n    registry.register(AppConfig).useInstance(options.config);\n\n    for (const module of options.modules) {\n        if (module.setup) await module.setup(registry, options.config);\n    }\n\n    const container = registry.build();\n\n    const shutdown = async (): Promise<void> => {\n        for (const module of [...options.modules].reverse()) {\n            if (!module.shutdown) continue;\n            try {\n                await module.shutdown(container);\n            } catch {\n                // Ignore individual module shutdown failures during teardown.\n            }\n        }\n    };\n\n    return { container, shutdown };\n};\n\n// Lazy, per-process bootstrap cache. Composite commands within a single\n// invocation reuse the same container; subsequent invocations bootstrap fresh.\ninterface LazyBootstrap<ConfigT extends AppConfig> {\n    modules: ServerKitModule<ConfigT>[];\n    promise?: Promise<CliContainer>;\n}\n\n// State must live on globalThis under a Symbol.for key so that the main johnny5\n// bundle and the /serverkit subpath bundle share it. tsup with `splitting:\n// false` builds each entry independently, so module-scoped state would be\n// duplicated — createCliApp would write to one copy and requireContainer would\n// read from another. Symbol.for makes the WeakMap process-wide regardless of\n// which bundle initialised it first.\nconst STATE_KEY = Symbol.for('@maroonedsoftware/johnny5/serverkit/state.v1');\n\ninterface Johnny5ServerkitState {\n    containerByContext: WeakMap<CliContext, LazyBootstrap<AppConfig>>;\n}\n\nconst getState = (): Johnny5ServerkitState => {\n    const g = globalThis as unknown as Record<symbol, Johnny5ServerkitState | undefined>;\n    if (!g[STATE_KEY]) {\n        g[STATE_KEY] = { containerByContext: new WeakMap() };\n    }\n    return g[STATE_KEY] as Johnny5ServerkitState;\n};\n\n/**\n * Associate a list of ServerKit modules with a `CliContext`. The first call to\n * `getOrBootstrapContainer` for that context will lazily run their `setup`\n * hooks. `createCliApp` calls this automatically when `modules` is supplied.\n */\nexport const configureServerKitModules = <ConfigT extends AppConfig>(ctx: CliContext, modules: ServerKitModule<ConfigT>[]): void => {\n    getState().containerByContext.set(ctx, { modules: modules as ServerKitModule<AppConfig>[] });\n};\n\n/**\n * Return the bootstrapped container for `ctx`, building it on the first call\n * and caching the promise for subsequent calls within the same process.\n * Throws if `configureServerKitModules` hasn't been called for this context.\n */\nexport const getOrBootstrapContainer = async (ctx: CliContext): Promise<CliContainer> => {\n    const lazy = getState().containerByContext.get(ctx);\n    if (!lazy) throw new Error('ServerKit modules have not been configured on this CliContext — call configureServerKitModules() in createCliApp first.');\n    if (!lazy.promise) {\n        lazy.promise = bootstrapForCli({\n            modules: lazy.modules,\n            config: ctx.config,\n        });\n    }\n    return lazy.promise;\n};\n\n/** `CliContext` augmented with a scoped InjectKit container, handed to `requireContainer` handlers. */\nexport interface RequireContainerCtx extends CliContext {\n    container: ScopedContainer;\n}\n\n/**\n * Wrap a command handler so it lazily bootstraps the ServerKit container and\n * receives a fresh scoped container per invocation. The root container is NOT\n * shut down between commands within the same process — call `bootstrapForCli`\n * directly when explicit teardown is required.\n */\nexport const requireContainer = <Opts = Record<string, unknown>>(\n    handler: (opts: Opts, ctx: RequireContainerCtx, args: string[]) => Promise<number | void>,\n): CommandModule<Opts>['run'] => {\n    return async (opts, ctx, args) => {\n        const { container } = await getOrBootstrapContainer(ctx);\n        const scoped = container.createScopedContainer() as ScopedContainer;\n        const enriched: RequireContainerCtx = Object.assign({}, ctx, { container: scoped });\n        return handler(opts, enriched, args);\n    };\n};\n"],"mappings":";;;;AAAA,SAASA,yBAA+D;AACxE,SAASC,iBAAiB;AAC1B,SAASC,eAAeC,cAAc;AAuB/B,IAAMC,kBAAkB,8BAC3BC,YAAAA;AAEA,QAAMC,WAAW,IAAIC,kBAAAA;AAErBD,WAASE,SAASC,MAAAA,EAAQC,YAAYL,QAAQM,UAAU,IAAIC,cAAAA,CAAAA;AAC5DN,WAASE,SAASK,SAAAA,EAAWH,YAAYL,QAAQS,MAAM;AAEvD,aAAWC,UAAUV,QAAQW,SAAS;AAClC,QAAID,OAAOE,MAAO,OAAMF,OAAOE,MAAMX,UAAUD,QAAQS,MAAM;EACjE;AAEA,QAAMI,YAAYZ,SAASa,MAAK;AAEhC,QAAMC,WAAW,mCAAA;AACb,eAAWL,UAAU;SAAIV,QAAQW;MAASK,QAAO,GAAI;AACjD,UAAI,CAACN,OAAOK,SAAU;AACtB,UAAI;AACA,cAAML,OAAOK,SAASF,SAAAA;MAC1B,QAAQ;MAER;IACJ;EACJ,GATiB;AAWjB,SAAO;IAAEA;IAAWE;EAAS;AACjC,GA1B+B;AAyC/B,IAAME,YAAYC,uBAAOC,IAAI,8CAAA;AAM7B,IAAMC,WAAW,6BAAA;AACb,QAAMC,IAAIC;AACV,MAAI,CAACD,EAAEJ,SAAAA,GAAY;AACfI,MAAEJ,SAAAA,IAAa;MAAEM,oBAAoB,oBAAIC,QAAAA;IAAU;EACvD;AACA,SAAOH,EAAEJ,SAAAA;AACb,GANiB;AAaV,IAAMQ,4BAA4B,wBAA4BC,KAAiBf,YAAAA;AAClFS,WAAAA,EAAWG,mBAAmBI,IAAID,KAAK;IAAEf;EAAiD,CAAA;AAC9F,GAFyC;AASlC,IAAMiB,0BAA0B,8BAAOF,QAAAA;AAC1C,QAAMG,OAAOT,SAAAA,EAAWG,mBAAmBO,IAAIJ,GAAAA;AAC/C,MAAI,CAACG,KAAM,OAAM,IAAIE,MAAM,8HAAA;AAC3B,MAAI,CAACF,KAAKG,SAAS;AACfH,SAAKG,UAAUjC,gBAAgB;MAC3BY,SAASkB,KAAKlB;MACdF,QAAQiB,IAAIjB;IAChB,CAAA;EACJ;AACA,SAAOoB,KAAKG;AAChB,GAVuC;AAuBhC,IAAMC,mBAAmB,wBAC5BC,YAAAA;AAEA,SAAO,OAAOC,MAAMT,KAAKU,SAAAA;AACrB,UAAM,EAAEvB,UAAS,IAAK,MAAMe,wBAAwBF,GAAAA;AACpD,UAAMW,SAASxB,UAAUyB,sBAAqB;AAC9C,UAAMC,WAAgCC,OAAOC,OAAO,CAAC,GAAGf,KAAK;MAAEb,WAAWwB;IAAO,CAAA;AACjF,WAAOH,QAAQC,MAAMI,UAAUH,IAAAA;EACnC;AACJ,GATgC;","names":["InjectKitRegistry","AppConfig","ConsoleLogger","Logger","bootstrapForCli","options","registry","InjectKitRegistry","register","Logger","useInstance","logger","ConsoleLogger","AppConfig","config","module","modules","setup","container","build","shutdown","reverse","STATE_KEY","Symbol","for","getState","g","globalThis","containerByContext","WeakMap","configureServerKitModules","ctx","set","getOrBootstrapContainer","lazy","get","Error","promise","requireContainer","handler","opts","args","scoped","createScopedContainer","enriched","Object","assign"]}

package/dist/integrations/versions/index.d.ts

@@ -0,0 +1,26 @@
+import { b as Check } from '../../types-CH7ccr3j.js';
+import '@maroonedsoftware/appconfig';
+import 'execa';
+
+/** Options for `nodeVersion`. */
+interface NodeVersionOptions {
+    /** Minimum Node major version required. The check fails when `process.versions.node` is below this. */
+    min: number;
+}
+/** Check that `process.versions.node` is at least `options.min` (compared by major version). */
+declare const nodeVersion: (options: NodeVersionOptions) => Check;
+/** Options for `pnpmVersion`. */
+interface PnpmVersionOptions {
+    /**
+     * If supplied, the installed pnpm version must match exactly. Otherwise
+     * only presence on PATH is checked.
+     */
+    expected?: string;
+}
+/**
+ * Check that pnpm is on PATH and (optionally) matches a specific version. Fails
+ * with a corepack-flavoured fixHint when the binary is missing or mismatched.
+ */
+declare const pnpmVersion: (options?: PnpmVersionOptions) => Check;
+
+export { type NodeVersionOptions, type PnpmVersionOptions, nodeVersion, pnpmVersion };