@geekmidas/cli 10.0.0-alpha.62 → 10.0.0-alpha.63

package/dist/{sniffer-DHE2Nafd.mjs → sniffer-aO_-s5vq.mjs}

@@ -1,26 +1,25 @@
 import { n as __require, t as __exportAll } from "./rolldown-runtime-BhDjJH2R.mjs";
 import { n as gkmHome } from "./home-GI7pJl1M.mjs";
-import { a as output, t as discover } from "./discover-FrYvzkeC.mjs";
-import { c as loadWorkspaceAppInfo, f as appKey, l as loadWorkspaceConfig, r as NotInAnApp, s as loadConfig, t as ConfigNotFound } from "./config-Bf4-bROQ.mjs";
-import { E as TEST_STAGE, p as getPublicEnvPrefix, t as allConstructGlobs } from "./workspace-BFe57es7.mjs";
+import { h as confineCwd, m as assertSecretNames, p as activeSandbox, r as discover, s as nodeWithTsx, u as SECRETS_DIR_ENV, v as output } from "./discover-BaT6bpnA.mjs";
+import { d as loadConfig, f as loadWorkspaceAppInfo, g as appKey, o as NotInAnApp, p as loadWorkspaceConfig, r as ConfigNotFound } from "./config-LKKCVCnC.mjs";
+import { E as TEST_STAGE, p as getPublicEnvPrefix, t as allConstructGlobs } from "./workspace-Dh7rr7l4.mjs";
 import { i as toEmbeddableSecrets } from "./storage-BzaUxmqe.mjs";
 import { i as FileSecretsStore, n as secretsStoreFor } from "./store-BS8A7NcA.mjs";
 import { r as runtimeOf } from "./runtime-DbakJS8u.mjs";
 import { i as DEFAULT_STORAGE, n as DEFAULT_CACHE, r as DEFAULT_EVENTS$1, t as readFakes } from "./fakes-C9RiT6XG.mjs";
-import { createRequire } from "node:module";
 import { basename, dirname, join, parse, resolve } from "node:path";
 import { stdin, stdout } from "node:process";
 import * as readline from "node:readline/promises";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
-import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
-import { hostname, networkInterfaces, userInfo } from "node:os";
+import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { hostname, networkInterfaces, tmpdir, userInfo } from "node:os";
 import { promisify } from "node:util";
 import { DEFAULT_POSTGRES_VERSION, cacheTable, cookieDomain, dependenciesOf, dependentsOf, externalApiUrl, kebabCase, mobileOrigins, provideKey, providedKeyFor, provisionOrder, publicEnvFor, schemeBase } from "@geekmidas/manifest";
+import { fileURLToPath } from "node:url";
 import { execFile, spawn } from "node:child_process";
 import { createServer } from "node:net";
 import { config } from "dotenv";
 import { createCipheriv, createHash, randomBytes, randomUUID } from "node:crypto";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import { formatKeyring, generateKeyring } from "@geekmidas/constructs/encryption";
 import { ownerRole, readerRole, roleStatements } from "@geekmidas/db/pg/roles";
 import * as snsUrl from "@geekmidas/events/sns/url";
@@ -585,45 +584,6 @@ function normalizeRoutes(routes) {
 	return Array.isArray(routes) ? routes : [routes];
 }
 //#endregion
-//#region src/owningTsconfigJsx.ts
-const REGISTER = "owning-tsconfig-jsx-register.mjs";
-/** The CLI's `bin/` was not found above the module looking for it. */
-var OwningTsconfigJsxHookMissing = class extends Error {
-	from;
-	constructor(from) {
-		super(`Could not find bin/${REGISTER} in any directory above '${from}'. It ships with @geekmidas/cli beside bin/gkm.mjs; reinstall the package if it is missing.`);
-		this.from = from;
-		this.name = "OwningTsconfigJsxHookMissing";
-	}
-};
-/**
-* The CLI's `bin/owning-tsconfig-jsx-register.mjs`, as a file URL. Searched
-* upward because this module runs from `src/` in the repo and from a chunk in
-* `dist/` once built, and `bin/` sits beside both.
-*/
-function registerUrl() {
-	const from = dirname(fileURLToPath(import.meta.url));
-	for (let dir = from;; dir = dirname(dir)) {
-		const candidate = join(dir, "bin", REGISTER);
-		if (existsSync(candidate)) return pathToFileURL(candidate).href;
-		if (dirname(dir) === dir) throw new OwningTsconfigJsxHookMissing(from);
-	}
-}
-/**
-* `NODE_OPTIONS` for a process that runs app code through tsx, with the hook
-* that compiles each `.tsx` with its own tsconfig's JSX settings (see
-* `bin/owning-tsconfig-jsx.mjs`) put in front of every other `--import`, so it
-* is registered before tsx and reads the source on tsx's behalf.
-*
-* `bin/gkm.mjs` already starts the CLI this way, and its children inherit it;
-* this is for those that set `NODE_OPTIONS` themselves, or whose CLI was
-* started with tsx already imported.
-*/
-function withOwningTsconfigJsx(nodeOptions = "") {
-	if (nodeOptions.includes(REGISTER)) return nodeOptions;
-	return [`--import=${registerUrl()}`, nodeOptions].filter(Boolean).join(" ");
-}
-//#endregion
 //#region src/reconcile/containers.ts
 /**
 * What gkm knows about each container it can derive.
@@ -3533,7 +3493,7 @@ function localAddress(port) {
 /** Long enough for a cold image build; short enough that a hung one ends. */
 const DEFAULT_TIMEOUT_MS = 18e5;
 /** How long a timed-out child has to exit on SIGTERM before it is killed. */
-const KILL_GRACE_MS = 5e3;
+const KILL_GRACE_MS$1 = 5e3;
 /** The command line as a person would read it — for messages, never to run. */
 function display(command, args) {
 	return [command, ...args].join(" ");
@@ -3606,7 +3566,7 @@ function spawnChild(command, args, options, capture) {
 		const timer = setTimeout(() => {
 			timedOut = true;
 			child.kill("SIGTERM");
-			killer = setTimeout(() => child.kill("SIGKILL"), KILL_GRACE_MS);
+			killer = setTimeout(() => child.kill("SIGKILL"), KILL_GRACE_MS$1);
 			killer.unref?.();
 		}, timeoutMs);
 		timer.unref?.();
@@ -3628,6 +3588,221 @@ function spawnChild(command, args, options, capture) {
 	});
 }
 //#endregion
+//#region src/sandbox/env.ts
+/**
+* What of the host's environment a local sandbox passes on.
+*
+* An allowlist, not a denylist: a credential's variable has any name its
+* owner chose (`DOKPLOY_TOKEN`, `AWS_SECRET_ACCESS_KEY`, `MY_VAULT_TOKEN`), so
+* the only safe default is to name what a program needs to *run* and pass
+* nothing else.
+*/
+/**
+* Variables a command needs to find programs, write temp files, print in the
+* user's locale and reach the network through the host's proxy — and nothing
+* that authenticates as anyone.
+*
+* Deliberately left out:
+* - `NODE_OPTIONS`: it can `--require` or `--import` code into every node
+*   process, and CI often holds `--import tsx` there. A step that needs a
+*   loader passes its own.
+* - `NODE_AUTH_TOKEN`, `NPM_TOKEN`, `npm_config_*`: registry tokens
+*   (`actions/setup-node` writes `NODE_AUTH_TOKEN`), which is why there is no
+*   `NODE_*` wildcard.
+* - `AWS_*`, `DOCKER_*`, `DOKPLOY_*`, `GITHUB_TOKEN`, `TURBO_TOKEN`, `GKM_*`:
+*   credentials, or where the deploy keeps them.
+* - `SHELL`, `EDITOR` and the rest of a login session: nothing here starts a
+*   shell.
+*
+* Proxies are passed: behind one, nothing installs or builds without it. A
+* proxy URL with a password in it reaches the command too — a host that keeps
+* one there and builds code it does not trust should pass a sandbox of its
+* own.
+*/
+const SANDBOX_ENV_ALLOWLIST = [
+	"PATH",
+	"HOME",
+	"USER",
+	"LOGNAME",
+	"TMPDIR",
+	"TMP",
+	"TEMP",
+	"LANG",
+	"LANGUAGE",
+	"TZ",
+	/^LC_[A-Z]+$/,
+	"TERM",
+	"COLORTERM",
+	"NO_COLOR",
+	"FORCE_COLOR",
+	"CI",
+	"NODE_ENV",
+	"NODE_EXTRA_CA_CERTS",
+	"COREPACK_HOME",
+	"PNPM_HOME",
+	"XDG_CACHE_HOME",
+	"XDG_DATA_HOME",
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+	"NO_PROXY",
+	"http_proxy",
+	"https_proxy",
+	"no_proxy",
+	"SystemRoot",
+	"SYSTEMROOT",
+	"windir",
+	"WINDIR",
+	"ComSpec",
+	"COMSPEC",
+	"PATHEXT",
+	"USERPROFILE",
+	"APPDATA",
+	"LOCALAPPDATA"
+];
+function allowed(name) {
+	return SANDBOX_ENV_ALLOWLIST.some((entry) => typeof entry === "string" ? entry === name : entry.test(name));
+}
+/**
+* The allowlisted part of `source`, plus each of `extra` the host chose to
+* pass on by name.
+*/
+function allowlistedEnv(source = process.env, extra = []) {
+	const env = {};
+	for (const [name, value] of Object.entries(source)) {
+		if (value === void 0) continue;
+		if (allowed(name) || extra.includes(name)) env[name] = value;
+	}
+	return env;
+}
+//#endregion
+//#region src/sandbox/local.ts
+/** How long a timed-out command has to exit on SIGTERM before SIGKILL. */
+const KILL_GRACE_MS = 5e3;
+/** Where `output` sends a child's streams. */
+const STDIO = {
+	capture: [
+		"ignore",
+		"pipe",
+		"pipe"
+	],
+	inherit: "inherit",
+	stderr: [
+		"ignore",
+		2,
+		2
+	],
+	ignore: "ignore"
+};
+/**
+* A child process on this machine, as this user, with an allowlisted
+* environment.
+*
+* What it withholds from the command: the host's environment beyond
+* {@link SANDBOX_ENV_ALLOWLIST}, a shell, a working directory outside the
+* project, and any time past the timeout. What it does not: the host's
+* filesystem, which the command can read and write as the user running the
+* deploy. So it is not `isolating`, and it is the default for projects the
+* host already trusts — the developer's own, a team's own CI. Code nobody
+* vetted belongs in a sandbox that is.
+*
+* A timed-out command is sent SIGTERM, then SIGKILL; processes it started
+* itself are its to stop.
+*/
+var LocalSandbox = class {
+	root;
+	isolating = false;
+	env;
+	constructor(options) {
+		this.root = resolve(options.root);
+		this.env = {
+			...allowlistedEnv(options.hostEnv ?? process.env, options.passEnv),
+			...options.home ? {
+				HOME: options.home,
+				USERPROFILE: options.home
+			} : {}
+		};
+	}
+	async exec(command, args, options) {
+		const cwd = confineCwd(this.root, options.cwd);
+		assertSecretNames(options.secrets);
+		options.signal?.throwIfAborted();
+		const secretsDir = await mountSecrets(options.secrets);
+		try {
+			return await spawnConfined(command, args, {
+				...options,
+				cwd,
+				env: secretsDir ? {
+					...options.env,
+					[SECRETS_DIR_ENV]: secretsDir
+				} : options.env
+			});
+		} finally {
+			if (secretsDir) await rm(secretsDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+};
+/**
+* Each secret as a 0600 file in a fresh 0700 directory outside the project —
+* where nothing the build writes, packs or commits will pick it up.
+*/
+async function mountSecrets(secrets) {
+	if (!secrets || Object.keys(secrets).length === 0) return void 0;
+	const dir = await mkdtemp(join(tmpdir(), "gkm-secrets-"));
+	for (const [name, value] of Object.entries(secrets)) await writeFile(join(dir, name), value, { mode: 384 });
+	return dir;
+}
+function spawnConfined(command, args, options) {
+	const { output = "capture", signal, timeoutMs } = options;
+	return new Promise((resolvePromise, reject) => {
+		const child = spawn(command, [...args], {
+			cwd: options.cwd,
+			env: { ...options.env },
+			stdio: STDIO[output],
+			shell: false,
+			...signal ? { signal } : {}
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout?.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		child.stderr?.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		let timedOut = false;
+		let killer;
+		const timer = setTimeout(() => {
+			timedOut = true;
+			child.kill("SIGTERM");
+			killer = setTimeout(() => child.kill("SIGKILL"), KILL_GRACE_MS);
+			killer.unref?.();
+		}, timeoutMs);
+		timer.unref?.();
+		const settle = () => {
+			clearTimeout(timer);
+			if (killer) clearTimeout(killer);
+		};
+		child.on("error", (error) => {
+			settle();
+			reject(signal?.aborted ? signal.reason : error);
+		});
+		child.on("close", (code, killedBy) => {
+			settle();
+			if (signal?.aborted) reject(signal.reason);
+			else if (timedOut) reject(new CommandTimedOut(command, args, timeoutMs));
+			else resolvePromise({
+				exitCode: code,
+				signal: killedBy ?? null,
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+//#endregion
 //#region src/secrets/encryption.ts
 var encryption_exports = /* @__PURE__ */ __exportAll({
 	encryptSecrets: () => encryptSecrets,
@@ -4052,17 +4227,17 @@ function isStateStore(value) {
 async function createStateStore(options) {
 	const { config, workspaceRoot, workspaceName } = options;
 	if (!config || config.provider === "local") {
-		const { LocalStateStore } = await import("./LocalStateStore-B51rnfgn.mjs").then((n) => n.n);
+		const { LocalStateStore } = await import("./LocalStateStore-BGIXcrvX.mjs").then((n) => n.n);
 		return new LocalStateStore(workspaceRoot);
 	}
 	if (isStateStore(config.provider)) return config.provider;
 	if (isStateProvider(config.provider)) {
-		const { LegacyStateStore } = await import("./LegacyStateStore-A8d2GdT7.mjs");
+		const { LegacyStateStore } = await import("./LegacyStateStore-Q3GmKOdw.mjs");
 		return new LegacyStateStore(config.provider, { warn: options.warn });
 	}
 	if (config.provider === "ssm") {
 		if (!workspaceName) throw new StateStoreNeedsWorkspaceName("ssm");
-		const { SSMStateStore } = await import("./SSMStateStore-iK5UKp9d.mjs");
+		const { SSMStateStore } = await import("./SSMStateStore-CAQDVpoc.mjs");
 		const ssm = config;
 		return SSMStateStore.create({
 			workspaceName,
@@ -4072,7 +4247,7 @@ async function createStateStore(options) {
 	}
 	if (config.provider === "s3") {
 		if (!workspaceName) throw new StateStoreNeedsWorkspaceName("s3");
-		const { S3StateStore } = await import("./S3StateStore-CJewPhgz.mjs");
+		const { S3StateStore } = await import("./S3StateStore-D7l_lWJ3.mjs");
 		const s3 = config;
 		return S3StateStore.create({
 			workspaceName,
@@ -6221,13 +6396,6 @@ var DokployApi = class {
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /**
-* Resolve the tsx package path from the CLI package's dependencies.
-* This ensures tsx is available regardless of whether the target project has it installed.
-*/
-function resolveTsxPath() {
-	return createRequire(import.meta.url).resolve("tsx");
-}
-/**
 * Resolve the path to a sniffer helper file.
 * Handles both dev (.ts with tsx) and production (.mjs from dist).
 *
@@ -6246,6 +6414,39 @@ function resolveSnifferFile(baseName) {
 	return tsPath;
 }
 /**
+* Run a sniffer worker in the sandbox, with the sandbox's environment and
+* nothing of the deploy's: the deploy's Dokploy token, registry login and AWS
+* keys stay where they are. A worker that outlives the timeout is killed, and
+* comes back as the error the caller reports.
+*/
+async function runSniffer(run, workspacePath, cwd, nodeArgs) {
+	const sandbox = run.sandbox ?? activeSandbox() ?? new LocalSandbox({ root: resolve(workspacePath) });
+	try {
+		const result = await sandbox.exec("node", nodeArgs, {
+			cwd,
+			env: { ...sandbox.env },
+			timeoutMs: run.timeoutMs ?? 3e4,
+			output: "capture"
+		});
+		return {
+			stdout: result.stdout,
+			stderr: result.stderr,
+			code: result.exitCode
+		};
+	} catch (error) {
+		return { error: error instanceof Error ? error : new Error(String(error)) };
+	}
+}
+/** The worker's JSON answer: the last object on stdout naming `envVars`. */
+function snifferAnswer(stdout) {
+	try {
+		const jsonMatch = stdout.match(/\{[^{}]*"envVars"[^{}]*\}[^{]*$/);
+		return jsonMatch ? JSON.parse(jsonMatch[0]) : void 0;
+	} catch {
+		return;
+	}
+}
+/**
 * Get required environment variables for an app.
 *
 * Detection strategy (in order):
@@ -6267,6 +6468,10 @@ function resolveSnifferFile(baseName) {
 */
 async function sniffAppEnvironment(app, appName, workspacePath, options = {}) {
 	const { logWarnings = true, markOptional = false } = options;
+	const run = {
+		...options.sandbox ? { sandbox: options.sandbox } : {},
+		...options.timeoutMs ? { timeoutMs: options.timeoutMs } : {}
+	};
 	if (app.type === "web" || app.type === "mobile") {
 		const publicPrefix = getPublicEnvPrefix(app.framework);
 		const depVars = publicPrefix ? (app.dependencies ?? []).map((dep) => `${publicPrefix}${dep.toUpperCase()}_URL`) : [];
@@ -6277,7 +6482,7 @@ async function sniffAppEnvironment(app, appName, workspacePath, options = {}) {
 			if (app.config.client) configPaths.push(app.config.client);
 			if (app.config.server) configPaths.push(app.config.server);
 			for (const configPath of configPaths) {
-				const result = await sniffEntryFile(configPath, app.path, workspacePath);
+				const result = await sniffEntryFile(configPath, app.path, workspacePath, run);
 				if (logWarnings && result.error) output.warn(`[sniffer] ${appName}: Config file "${configPath}" threw error during sniffing (env vars still captured): ${result.error.message}`);
 				sniffedVars.push(...result.envVars);
 				sniffedOptional.push(...result.optionalEnvVars);
@@ -6296,7 +6501,7 @@ async function sniffAppEnvironment(app, appName, workspacePath, options = {}) {
 		};
 	}
 	if (app.entry) {
-		const result = await sniffEntryFile(app.entry, app.path, workspacePath);
+		const result = await sniffEntryFile(app.entry, app.path, workspacePath, run);
 		if (logWarnings && result.error) output.warn(`[sniffer] ${appName}: Entry file threw error during sniffing (env vars still captured): ${result.error.message}`);
 		return {
 			appName,
@@ -6305,7 +6510,7 @@ async function sniffAppEnvironment(app, appName, workspacePath, options = {}) {
 		};
 	}
 	if (app.routes) {
-		const result = await sniffRouteFiles(normalizeRoutes(app.routes), app.path, workspacePath);
+		const result = await sniffRouteFiles(normalizeRoutes(app.routes), app.path, workspacePath, run);
 		if (logWarnings && result.error) output.warn(`[sniffer] ${appName}: Route sniffing threw error (env vars still captured): ${result.error.message}`);
 		return {
 			appName,
@@ -6314,7 +6519,7 @@ async function sniffAppEnvironment(app, appName, workspacePath, options = {}) {
 		};
 	}
 	if (app.envParser) {
-		const result = await sniffEnvParser(app.envParser, app.path, workspacePath);
+		const result = await sniffEnvParser(app.envParser, app.path, workspacePath, run);
 		if (logWarnings) {
 			if (result.error) output.warn(`[sniffer] ${appName}: envParser threw error during sniffing (env vars still captured): ${result.error.message}`);
 			if (result.unhandledRejections.length > 0) output.warn(`[sniffer] ${appName}: Fire-and-forget rejections during sniffing (suppressed): ${result.unhandledRejections.map((e) => e.message).join(", ")}`);
@@ -6359,63 +6564,27 @@ function applyMarkOptional(envVars, optionalEnvVars, markOptional) {
 * @param workspacePath - Absolute path to workspace root
 * @returns EntrySniffResult with env vars and optional error
 */
-async function sniffEntryFile(entryPath, appPath, workspacePath) {
+async function sniffEntryFile(entryPath, appPath, workspacePath, run = {}) {
 	const fullEntryPath = resolve(workspacePath, appPath, entryPath);
 	const loaderPath = resolveSnifferFile("sniffer-loader");
 	const workerPath = resolveSnifferFile("sniffer-worker");
-	return new Promise((resolvePromise) => {
-		const child = spawn("node", [
-			"--import",
-			loaderPath,
-			workerPath,
-			fullEntryPath
-		], {
-			cwd: resolve(workspacePath, appPath),
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			],
-			env: {
-				...process.env,
-				NODE_OPTIONS: withOwningTsconfigJsx("--import=tsx")
-			}
-		});
-		let stdout = "";
-		let stderr = "";
-		child.stdout.on("data", (data) => {
-			stdout += data.toString();
-		});
-		child.stderr.on("data", (data) => {
-			stderr += data.toString();
-		});
-		child.on("close", (code) => {
-			try {
-				const jsonMatch = stdout.match(/\{[^{}]*"envVars"[^{}]*\}[^{]*$/);
-				if (jsonMatch) {
-					const result = JSON.parse(jsonMatch[0]);
-					resolvePromise({
-						envVars: result.envVars || [],
-						optionalEnvVars: result.optionalEnvVars || [],
-						error: result.error ? new Error(result.error) : void 0
-					});
-					return;
-				}
-			} catch {}
-			resolvePromise({
-				envVars: [],
-				optionalEnvVars: [],
-				error: /* @__PURE__ */ new Error(`Failed to sniff entry file (exit code ${code}): ${stderr || stdout || "No output"}`)
-			});
-		});
-		child.on("error", (err) => {
-			resolvePromise({
-				envVars: [],
-				optionalEnvVars: [],
-				error: err
-			});
-		});
-	});
+	const ran = await runSniffer(run, workspacePath, resolve(workspacePath, appPath), nodeWithTsx(workerPath, [fullEntryPath], [loaderPath]));
+	if ("error" in ran) return {
+		envVars: [],
+		optionalEnvVars: [],
+		error: ran.error
+	};
+	const answer = snifferAnswer(ran.stdout);
+	if (answer) return {
+		envVars: answer.envVars || [],
+		optionalEnvVars: answer.optionalEnvVars || [],
+		error: answer.error ? new Error(answer.error) : void 0
+	};
+	return {
+		envVars: [],
+		optionalEnvVars: [],
+		error: /* @__PURE__ */ new Error(`Failed to sniff entry file (exit code ${ran.code}): ${ran.stderr || ran.stdout || "No output"}`)
+	};
 }
 /**
 * Sniff route files by loading constructs and calling getEnvironment().
@@ -6431,116 +6600,79 @@ async function sniffEntryFile(entryPath, appPath, workspacePath) {
 * @param workspacePath - Absolute path to workspace root
 * @returns EntrySniffResult with env vars and optional error
 */
-async function sniffRouteFiles(routes, appPath, workspacePath) {
+async function sniffRouteFiles(routes, appPath, workspacePath, run = {}) {
 	const fullAppPath = resolve(workspacePath, appPath);
 	const workerPath = resolveSnifferFile("sniffer-routes-worker");
-	const tsxPath = resolveTsxPath();
 	const pattern = (Array.isArray(routes) ? routes : [routes])[0];
 	if (!pattern) return {
 		envVars: [],
 		optionalEnvVars: [],
 		error: /* @__PURE__ */ new Error("No route patterns provided")
 	};
-	return new Promise((resolvePromise) => {
-		const child = spawn("node", [
-			"--import",
-			tsxPath,
-			workerPath,
-			fullAppPath,
-			pattern
-		], {
-			cwd: fullAppPath,
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			],
-			env: { ...process.env }
-		});
-		let stdout = "";
-		let stderr = "";
-		child.stdout.on("data", (data) => {
-			stdout += data.toString();
-		});
-		child.stderr.on("data", (data) => {
-			stderr += data.toString();
-		});
-		child.on("close", (code) => {
-			if (stderr) stderr.split("\n").filter((line) => line.trim()).forEach((line) => output.warn(line));
-			try {
-				const jsonMatch = stdout.match(/\{[^{}]*"envVars"[^{}]*\}[^{]*$/);
-				if (jsonMatch) {
-					const result = JSON.parse(jsonMatch[0]);
-					resolvePromise({
-						envVars: result.envVars || [],
-						optionalEnvVars: result.optionalEnvVars || [],
-						error: result.error ? new Error(result.error) : void 0
-					});
-					return;
-				}
-			} catch {}
-			resolvePromise({
-				envVars: [],
-				optionalEnvVars: [],
-				error: /* @__PURE__ */ new Error(`Failed to sniff route files (exit code ${code}): ${stderr || stdout || "No output"}`)
-			});
-		});
-		child.on("error", (err) => {
-			resolvePromise({
-				envVars: [],
-				optionalEnvVars: [],
-				error: err
-			});
-		});
-	});
+	const ran = await runSniffer(run, workspacePath, fullAppPath, nodeWithTsx(workerPath, [fullAppPath, pattern]));
+	if ("error" in ran) return {
+		envVars: [],
+		optionalEnvVars: [],
+		error: ran.error
+	};
+	if (ran.stderr) ran.stderr.split("\n").filter((line) => line.trim()).forEach((line) => output.warn(line));
+	const answer = snifferAnswer(ran.stdout);
+	if (answer) return {
+		envVars: answer.envVars || [],
+		optionalEnvVars: answer.optionalEnvVars || [],
+		error: answer.error ? new Error(answer.error) : void 0
+	};
+	return {
+		envVars: [],
+		optionalEnvVars: [],
+		error: /* @__PURE__ */ new Error(`Failed to sniff route files (exit code ${ran.code}): ${ran.stderr || ran.stdout || "No output"}`)
+	};
 }
 /**
 * Run the SnifferEnvironmentParser on an envParser module to detect
 * which environment variables it accesses.
 *
-* This function handles "fire and forget" async operations by using
-* the shared sniffWithFireAndForget utility from @geekmidas/envkit.
+* In a subprocess, like the entry and route sniffers: the module is the
+* project's code, and it was imported into the deploy itself before — with
+* every credential the deploy held in reach. Fire-and-forget rejections are
+* collected there with the shared `sniffWithFireAndForget`.
 *
 * @param envParserPath - The envParser config (e.g., './src/config/env#envParser')
 * @param appPath - The app's path relative to workspace
 * @param workspacePath - Absolute path to workspace root
 * @returns SniffResult with env vars and any errors encountered
 */
-async function sniffEnvParser(envParserPath, appPath, workspacePath) {
+async function sniffEnvParser(envParserPath, appPath, workspacePath, run = {}) {
 	const [modulePath, exportName = "default"] = envParserPath.split("#");
 	if (!modulePath) return {
 		envVars: [],
 		optionalEnvVars: [],
 		unhandledRejections: []
 	};
-	const fullPath = resolve(workspacePath, appPath, modulePath);
-	let SnifferEnvironmentParser;
-	let sniffWithFireAndForget;
-	try {
-		const envkitModule = await import("@geekmidas/envkit/sniffer");
-		SnifferEnvironmentParser = envkitModule.SnifferEnvironmentParser;
-		sniffWithFireAndForget = envkitModule.sniffWithFireAndForget;
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		output.warn(`[sniffer] Failed to import SnifferEnvironmentParser: ${message}`);
-		return {
-			envVars: [],
-			optionalEnvVars: [],
-			unhandledRejections: []
-		};
-	}
-	const sniffer = new SnifferEnvironmentParser();
-	return sniffWithFireAndForget(sniffer, async () => {
-		const envParser = (await import(pathToFileURL(fullPath).href))[exportName];
-		if (typeof envParser !== "function") {
-			output.warn(`[sniffer] Export "${exportName}" from "${modulePath}" is not a function`);
-			return;
-		}
-		const result = envParser(sniffer);
-		if (result && typeof result.parse === "function") try {
-			result.parse();
-		} catch {}
-	});
+	const appRoot = resolve(workspacePath, appPath);
+	const fullPath = resolve(appRoot, modulePath);
+	const workerPath = resolveSnifferFile("sniffer-envparser-worker");
+	const ran = await runSniffer(run, workspacePath, appRoot, nodeWithTsx(workerPath, [fullPath, exportName]));
+	if ("error" in ran) return {
+		envVars: [],
+		optionalEnvVars: [],
+		unhandledRejections: [],
+		error: ran.error
+	};
+	const answer = snifferAnswer(ran.stdout);
+	if (!answer) return {
+		envVars: [],
+		optionalEnvVars: [],
+		unhandledRejections: [],
+		error: /* @__PURE__ */ new Error(`Failed to sniff envParser (exit code ${ran.code}): ${ran.stderr || ran.stdout || "No output"}`)
+	};
+	for (const warning of answer.warnings ?? []) output.warn(warning);
+	return {
+		envVars: answer.envVars ?? [],
+		optionalEnvVars: answer.optionalEnvVars ?? [],
+		unhandledRejections: (answer.unhandledRejections ?? []).map((message) => new Error(message)),
+		...answer.error ? { error: new Error(answer.error) } : {}
+	};
 }
 /**
 * Sniff environment requirements for multiple apps.
@@ -6559,6 +6691,6 @@ async function sniffAllApps(apps, workspacePath, options = {}) {
 	return results;
 }
 //#endregion
-export { quoteIdentifier as $, StateStoreBusy as A, getDokployCredentials as At, run as B, setDnsRecord as C, loadEnvFiles as Ct, DocumentStateStore as D, logoutCommand as Dt, setPostgresBackupId as E, loginCommand as Et, newLockHolder as F, storeDokployCredentials as Ft, derivedContainers as G, FAKE_ENV as H, withGeneratedSecrets as I, canPrompt as It, LOCAL_CA_PATH as J, reconcileWorkspace as K, encryptSecrets as L, prompt as Lt, StateVersionConflict as M, getDokployToken as Mt, contentVersion as N, getHostingerToken as Nt, StageStateMissing as O, validateDokployToken as Ot, createStateStore as P, readCredentials as Pt, postgresStatements as Q, encryption_exports as R, setDeployedImage as S, isPortAvailable as St, setGeneratedSecret as T, prepareEntryCredentials as Tt, backendsOf as U, runOutput as V, constructGlobs as W, applyPostgres as X, forgetState as Y, postgresDatabaseNames as Z, getBackupState as _, primaryPortKey as _t, DockerBuildFailed as a, localRolePassword as at, setApplicationId as b, createEntryWrapper as bt, dockerCommand as c, hostFor as ct, generateDockerignore as d, providerOf as dt, composeFor as et, generateSlimDockerfile as f, storageBackendFor as ft, createEmptyState as g, portKeys as gt, resolveHost as h, fakeKey as ht, DokployApiError as i, envFor as it, StateStoreWithoutLocking as j, getDokployRegistryId as jt, StateLocked as k, whoamiCommand as kt, siteDockerfile as l, cacheBackendFor as lt, isMainFrontendApp as m, describeServices as mt, sniffAppEnvironment as n, appEnvKeys as nt, DockerPushFailed as o, planFor as ot, validateImageRef as p, DEFAULT_IMAGES as pt, workspace_exports as q, DokployApi as r, networkEnv as rt, appPackageName as s, resourceName as st, sniffAllApps as t, pgClient as tt, detectPackageManager as u, eventsBackendFor as ut, getGeneratedSecret as v, withOwningTsconfigJsx as vt, setDnsVerification as w, loadSecretsForApp as wt, setBackupState as x, findAvailablePort as xt, isDnsVerified as y, createCredentialsPreload as yt, keyFingerprint as z };
+export { workspace_exports as $, StateStoreBusy as A, prepareEntryCredentials as At, LocalSandbox as B, storeDokployCredentials as Bt, setDnsRecord as C, primaryPortKey as Ct, DocumentStateStore as D, isPortAvailable as Dt, setPostgresBackupId as E, findAvailablePort as Et, newLockHolder as F, getDokployCredentials as Ft, DEFAULT_TIMEOUT_MS as G, allowlistedEnv as H, prompt as Ht, withGeneratedSecrets as I, getDokployRegistryId as It, FAKE_ENV as J, run as K, encryptSecrets as L, getDokployToken as Lt, StateVersionConflict as M, logoutCommand as Mt, contentVersion as N, validateDokployToken as Nt, StageStateMissing as O, loadEnvFiles as Ot, createStateStore as P, whoamiCommand as Pt, reconcileWorkspace as Q, encryption_exports as R, getHostingerToken as Rt, setDeployedImage as S, portKeys as St, setGeneratedSecret as T, createEntryWrapper as Tt, CommandFailed as U, SANDBOX_ENV_ALLOWLIST as V, canPrompt as Vt, CommandTimedOut as W, constructGlobs as X, backendsOf as Y, derivedContainers as Z, getBackupState as _, providerOf as _t, DockerBuildFailed as a, quoteIdentifier as at, setApplicationId as b, describeServices as bt, dockerCommand as c, appEnvKeys as ct, generateDockerignore as d, localRolePassword as dt, LOCAL_CA_PATH as et, generateSlimDockerfile as f, planFor as ft, createEmptyState as g, eventsBackendFor as gt, resolveHost as h, cacheBackendFor as ht, DokployApiError as i, postgresStatements as it, StateStoreWithoutLocking as j, loginCommand as jt, StateLocked as k, loadSecretsForApp as kt, siteDockerfile as l, networkEnv as lt, isMainFrontendApp as m, hostFor as mt, sniffAppEnvironment as n, applyPostgres as nt, DockerPushFailed as o, composeFor as ot, validateImageRef as p, resourceName as pt, runOutput as q, DokployApi as r, postgresDatabaseNames as rt, appPackageName as s, pgClient as st, sniffAllApps as t, forgetState as tt, detectPackageManager as u, envFor as ut, getGeneratedSecret as v, storageBackendFor as vt, setDnsVerification as w, createCredentialsPreload as wt, setBackupState as x, fakeKey as xt, isDnsVerified as y, DEFAULT_IMAGES as yt, keyFingerprint as z, readCredentials as zt };
 
-//# sourceMappingURL=sniffer-DHE2Nafd.mjs.map
+//# sourceMappingURL=sniffer-aO_-s5vq.mjs.map