@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/commands/status-all/diagnosis.js

@@ -1,7 +1,7 @@
 import { resolveGatewayLogPaths } from "../../daemon/launchd.js";
 import { formatPortDiagnostics } from "../../infra/ports.js";
 import { summarizeRestartSentinel, } from "../../infra/restart-sentinel.js";
-import { formatAge, redactSecrets } from "./format.js";
+import { formatTimeAgo, redactSecrets } from "./format.js";
 import { readFileTailLines, summarizeLogTail } from "./gateway.js";
 export async function appendStatusAllDiagnosis(params) {
     const { lines, muted, ok, warn, fail } = params;
@@ -11,7 +11,7 @@ export async function appendStatusAllDiagnosis(params) {
         lines.push(`${icon} ${colored}`);
     };
     lines.push("");
-    lines.push(`${muted("Gateway connection details:")}`);
+    lines.push(muted("Gateway connection details:"));
     for (const line of redactSecrets(params.connectionDetailsForReport)
         .split("\n")
         .map((l) => l.trimEnd())) {
@@ -40,7 +40,7 @@ export async function appendStatusAllDiagnosis(params) {
     }
     if (params.sentinel?.payload) {
         emitCheck("Restart sentinel present", "warn");
-        lines.push(`  ${muted(`${summarizeRestartSentinel(params.sentinel.payload)} · ${formatAge(Date.now() - params.sentinel.payload.ts)}`)}`);
+        lines.push(`  ${muted(`${summarizeRestartSentinel(params.sentinel.payload)} · ${formatTimeAgo(Date.now() - params.sentinel.payload.ts)}`)}`);
     }
     else {
         emitCheck("Restart sentinel: none", "ok");
@@ -49,7 +49,7 @@ export async function appendStatusAllDiagnosis(params) {
     const isTrivialLastErr = lastErrClean.length < 8 || lastErrClean === "}" || lastErrClean === "{";
     if (lastErrClean && !isTrivialLastErr) {
         lines.push("");
-        lines.push(`${muted("Gateway last log line:")}`);
+        lines.push(muted("Gateway last log line:"));
         lines.push(`  ${muted(redactSecrets(lastErrClean))}`);
     }
     if (params.portUsage) {
@@ -101,7 +101,7 @@ export async function appendStatusAllDiagnosis(params) {
         ]);
         if (stderrTail.length > 0 || stdoutTail.length > 0) {
             lines.push("");
-            lines.push(`${muted(`Gateway logs (tail, summarized): ${logPaths.logDir}`)}`);
+            lines.push(muted(`Gateway logs (tail, summarized): ${logPaths.logDir}`));
             lines.push(`  ${muted(`# stderr: ${logPaths.stderrPath}`)}`);
             for (const line of summarizeLogTail(stderrTail, { maxLines: 22 }).map(redactSecrets)) {
                 lines.push(`  ${muted(line)}`);
@@ -127,16 +127,20 @@ export async function appendStatusAllDiagnosis(params) {
         emitCheck(`Channel issues skipped (gateway ${params.gatewayReachable ? "query failed" : "unreachable"})`, "warn");
     }
     const healthErr = (() => {
-        if (!params.health || typeof params.health !== "object")
+        if (!params.health || typeof params.health !== "object") {
             return "";
+        }
         const record = params.health;
-        if (!("error" in record))
+        if (!("error" in record)) {
             return "";
+        }
         const value = record.error;
-        if (!value)
+        if (!value) {
             return "";
-        if (typeof value === "string")
+        }
+        if (typeof value === "string") {
             return value;
+        }
         try {
             return JSON.stringify(value, null, 2);
         }
@@ -146,7 +150,7 @@ export async function appendStatusAllDiagnosis(params) {
     })();
     if (healthErr) {
         lines.push("");
-        lines.push(`${muted("Gateway health:")}`);
+        lines.push(muted("Gateway health:"));
         lines.push(`  ${muted(redactSecrets(healthErr))}`);
     }
     lines.push("");

package/dist/commands/status-all/format.js

@@ -30,6 +30,7 @@ export function formatGatewayAuthUsed(auth) {
         return "password";
     return "none";
 }
+export { formatTimeAgo } from "../../infra/format-time/format-relative.js";
 export function redactSecrets(text) {
     if (!text)
         return text;

package/dist/commands/status.gateway-probe.js

@@ -1,3 +1,4 @@
+export { pickGatewaySelfPresence } from "./gateway-presence.js";
 export function resolveGatewayProbeAuth(cfg) {
     const isRemoteMode = cfg.gateway?.mode === "remote";
     const remote = isRemoteMode ? cfg.gateway?.remote : undefined;
@@ -8,10 +9,8 @@ export function resolveGatewayProbeAuth(cfg) {
             ? remote.token.trim()
             : undefined
         : process.env.POOLBOT_GATEWAY_TOKEN?.trim() ||
-            process.env.CLAWDBOT_GATEWAY_TOKEN?.trim() ||
             (typeof authToken === "string" && authToken.trim().length > 0 ? authToken.trim() : undefined);
     const password = process.env.POOLBOT_GATEWAY_PASSWORD?.trim() ||
-        process.env.CLAWDBOT_GATEWAY_PASSWORD?.trim() ||
         (isRemoteMode
             ? typeof remote?.password === "string" && remote.password.trim().length > 0
                 ? remote.password.trim()
@@ -21,17 +20,3 @@ export function resolveGatewayProbeAuth(cfg) {
                 : undefined);
     return { token, password };
 }
-export function pickGatewaySelfPresence(presence) {
-    if (!Array.isArray(presence))
-        return null;
-    const entries = presence;
-    const self = entries.find((e) => e.mode === "gateway" && e.reason === "self") ?? null;
-    if (!self)
-        return null;
-    return {
-        host: typeof self.host === "string" ? self.host : undefined,
-        ip: typeof self.ip === "string" ? self.ip : undefined,
-        version: typeof self.version === "string" ? self.version : undefined,
-        platform: typeof self.platform === "string" ? self.platform : undefined,
-    };
-}

package/dist/commands/systemd-linger.js

@@ -1,10 +1,12 @@
 import { enableSystemdUserLinger, isSystemdUserServiceAvailable, readSystemdUserLingerStatus, } from "../daemon/systemd.js";
 import { note } from "../terminal/note.js";
 export async function ensureSystemdUserLingerInteractive(params) {
-    if (process.platform !== "linux")
+    if (process.platform !== "linux") {
         return;
-    if (params.prompt === false)
+    }
+    if (params.prompt === false) {
         return;
+    }
     const env = params.env ?? process.env;
     const prompter = params.prompter ?? { note };
     const title = params.title ?? "Systemd";
@@ -17,8 +19,9 @@ export async function ensureSystemdUserLingerInteractive(params) {
         await prompter.note("Unable to read loginctl linger status. Ensure systemd + loginctl are available.", title);
         return;
     }
-    if (status.linger === "yes")
+    if (status.linger === "yes") {
         return;
+    }
     const reason = params.reason ??
         "Systemd user services stop when you log out or go idle, which kills the Gateway.";
     const actionNote = params.requireConfirm
@@ -56,14 +59,17 @@ export async function ensureSystemdUserLingerInteractive(params) {
     await prompter.note(`Run manually: sudo loginctl enable-linger ${status.user}`, title);
 }
 export async function ensureSystemdUserLingerNonInteractive(params) {
-    if (process.platform !== "linux")
+    if (process.platform !== "linux") {
         return;
+    }
     const env = params.env ?? process.env;
-    if (!(await isSystemdUserServiceAvailable()))
+    if (!(await isSystemdUserServiceAvailable())) {
         return;
+    }
     const status = await readSystemdUserLingerStatus(env);
-    if (!status || status.linger === "yes")
+    if (!status || status.linger === "yes") {
         return;
+    }
     const result = await enableSystemdUserLinger({
         env,
         user: status.user,

package/dist/config/agent-limits.js

@@ -1,5 +1,7 @@
 export const DEFAULT_AGENT_MAX_CONCURRENT = 4;
 export const DEFAULT_SUBAGENT_MAX_CONCURRENT = 8;
+// Keep depth-1 subagents as leaves unless config explicitly opts into nesting.
+export const DEFAULT_SUBAGENT_MAX_SPAWN_DEPTH = 1;
 export function resolveAgentMaxConcurrent(cfg) {
     const raw = cfg?.agents?.defaults?.maxConcurrent;
     if (typeof raw === "number" && Number.isFinite(raw)) {

package/dist/config/commands.js

@@ -1,38 +1,55 @@
 import { normalizeChannelId } from "../channels/plugins/index.js";
+import { isPlainObject } from "../infra/plain-object.js";
 function resolveAutoDefault(providerId) {
     const id = normalizeChannelId(providerId);
-    if (!id)
+    if (!id) {
         return false;
-    if (id === "discord" || id === "telegram")
+    }
+    if (id === "discord" || id === "telegram") {
         return true;
-    if (id === "slack")
+    }
+    if (id === "slack") {
         return false;
+    }
     return false;
 }
 export function resolveNativeSkillsEnabled(params) {
-    const { providerId, providerSetting, globalSetting } = params;
-    const setting = providerSetting === undefined ? globalSetting : providerSetting;
-    if (setting === true)
-        return true;
-    if (setting === false)
-        return false;
-    return resolveAutoDefault(providerId);
+    return resolveNativeCommandSetting(params);
 }
 export function resolveNativeCommandsEnabled(params) {
+    return resolveNativeCommandSetting(params);
+}
+function resolveNativeCommandSetting(params) {
     const { providerId, providerSetting, globalSetting } = params;
     const setting = providerSetting === undefined ? globalSetting : providerSetting;
-    if (setting === true)
+    if (setting === true) {
         return true;
-    if (setting === false)
+    }
+    if (setting === false) {
         return false;
-    // auto or undefined -> heuristic
+    }
     return resolveAutoDefault(providerId);
 }
 export function isNativeCommandsExplicitlyDisabled(params) {
     const { providerSetting, globalSetting } = params;
-    if (providerSetting === false)
+    if (providerSetting === false) {
         return true;
-    if (providerSetting === undefined)
+    }
+    if (providerSetting === undefined) {
         return globalSetting === false;
+    }
     return false;
 }
+function getOwnCommandFlagValue(config, key) {
+    const { commands } = config ?? {};
+    if (!isPlainObject(commands) || !Object.hasOwn(commands, key)) {
+        return undefined;
+    }
+    return commands[key];
+}
+export function isCommandFlagEnabled(config, key) {
+    return getOwnCommandFlagValue(config, key) === true;
+}
+export function isRestartEnabled(config) {
+    return getOwnCommandFlagValue(config, "restart") !== false;
+}

package/dist/config/config-paths.js

@@ -1,4 +1,5 @@
-const BLOCKED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+import { isPlainObject } from "../utils.js";
+import { isBlockedObjectKey } from "./prototype-keys.js";
 export function parseConfigPath(raw) {
     const trimmed = raw.trim();
     if (!trimmed) {
@@ -14,7 +15,7 @@ export function parseConfigPath(raw) {
             error: "Invalid path. Use dot notation (e.g. foo.bar).",
         };
     }
-    if (parts.some((part) => BLOCKED_KEYS.has(part))) {
+    if (parts.some((part) => isBlockedObjectKey(part))) {
         return { ok: false, error: "Invalid path segment." };
     }
     return { ok: true, path: parts };
@@ -37,14 +38,16 @@ export function unsetConfigValueAtPath(root, path) {
     for (let idx = 0; idx < path.length - 1; idx += 1) {
         const key = path[idx];
         const next = cursor[key];
-        if (!isPlainObject(next))
+        if (!isPlainObject(next)) {
             return false;
+        }
         stack.push({ node: cursor, key });
         cursor = next;
     }
     const leafKey = path[path.length - 1];
-    if (!(leafKey in cursor))
+    if (!(leafKey in cursor)) {
         return false;
+    }
     delete cursor[leafKey];
     for (let idx = stack.length - 1; idx >= 0; idx -= 1) {
         const { node, key } = stack[idx];
@@ -61,15 +64,10 @@ export function unsetConfigValueAtPath(root, path) {
 export function getConfigValueAtPath(root, path) {
     let cursor = root;
     for (const key of path) {
-        if (!isPlainObject(cursor))
+        if (!isPlainObject(cursor)) {
             return undefined;
+        }
         cursor = cursor[key];
     }
     return cursor;
 }
-function isPlainObject(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        !Array.isArray(value) &&
-        Object.prototype.toString.call(value) === "[object Object]");
-}

package/dist/config/config.js

@@ -1,4 +1,4 @@
-export { createConfigIO, loadConfig, parseConfigJson5, readConfigFileSnapshot, resolveConfigSnapshotHash, writeConfigFile, } from "./io.js";
+export { createConfigIO, loadConfig, parseConfigJson5, readConfigFileSnapshot, readConfigFileSnapshotForWrite, resolveConfigSnapshotHash, writeConfigFile, } from "./io.js";
 export { migrateLegacyConfig } from "./legacy-migrate.js";
 export * from "./paths.js";
 export * from "./runtime-overrides.js";

package/dist/config/defaults.js

@@ -1,5 +1,5 @@
 import { DEFAULT_CONTEXT_TOKENS } from "../agents/defaults.js";
-import { parseModelRef } from "../agents/model-selection.js";
+import { normalizeProviderId, parseModelRef } from "../agents/model-selection.js";
 import { DEFAULT_AGENT_MAX_CONCURRENT, DEFAULT_SUBAGENT_MAX_CONCURRENT } from "./agent-limits.js";
 import { resolveTalkApiKey } from "./talk.js";
 let defaultWarnState = { warned: false };
@@ -22,6 +22,12 @@ const DEFAULT_MODEL_COST = {
 };
 const DEFAULT_MODEL_INPUT = ["text"];
 const DEFAULT_MODEL_MAX_TOKENS = 8192;
+function resolveDefaultProviderApi(providerId, providerApi) {
+    if (providerApi) {
+        return providerApi;
+    }
+    return normalizeProviderId(providerId) === "anthropic" ? "anthropic-messages" : undefined;
+}
 function isPositiveNumber(value) {
     return typeof value === "number" && Number.isFinite(value) && value > 0;
 }
@@ -135,6 +141,12 @@ export function applyModelDefaults(cfg) {
             if (!Array.isArray(models) || models.length === 0) {
                 continue;
             }
+            const providerApi = resolveDefaultProviderApi(providerId, provider.api);
+            let nextProvider = provider;
+            if (providerApi && provider.api !== providerApi) {
+                mutated = true;
+                nextProvider = { ...nextProvider, api: providerApi };
+            }
             let providerMutated = false;
             const nextModels = models.map((model) => {
                 const raw = model;
@@ -168,6 +180,10 @@ export function applyModelDefaults(cfg) {
                 if (raw.maxTokens !== maxTokens) {
                     modelMutated = true;
                 }
+                const api = raw.api ?? providerApi;
+                if (raw.api !== api) {
+                    modelMutated = true;
+                }
                 if (!modelMutated) {
                     return model;
                 }
@@ -179,12 +195,16 @@ export function applyModelDefaults(cfg) {
                     cost,
                     contextWindow,
                     maxTokens,
+                    api,
                 };
             });
             if (!providerMutated) {
+                if (nextProvider !== provider) {
+                    nextProviders[providerId] = nextProvider;
+                }
                 continue;
             }
-            nextProviders[providerId] = { ...provider, models: nextModels };
+            nextProviders[providerId] = { ...nextProvider, models: nextModels };
             mutated = true;
         }
         if (mutated) {

package/dist/config/discord-preview-streaming.js

@@ -0,0 +1,104 @@
+function normalizeStreamingMode(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized || null;
+}
+export function parseStreamingMode(value) {
+    const normalized = normalizeStreamingMode(value);
+    if (normalized === "off" ||
+        normalized === "partial" ||
+        normalized === "block" ||
+        normalized === "progress") {
+        return normalized;
+    }
+    return null;
+}
+export function parseDiscordPreviewStreamMode(value) {
+    const parsed = parseStreamingMode(value);
+    if (!parsed) {
+        return null;
+    }
+    return parsed === "progress" ? "partial" : parsed;
+}
+export function parseSlackLegacyDraftStreamMode(value) {
+    const normalized = normalizeStreamingMode(value);
+    if (normalized === "replace" || normalized === "status_final" || normalized === "append") {
+        return normalized;
+    }
+    return null;
+}
+export function mapSlackLegacyDraftStreamModeToStreaming(mode) {
+    if (mode === "append") {
+        return "block";
+    }
+    if (mode === "status_final") {
+        return "progress";
+    }
+    return "partial";
+}
+export function mapStreamingModeToSlackLegacyDraftStreamMode(mode) {
+    if (mode === "block") {
+        return "append";
+    }
+    if (mode === "progress") {
+        return "status_final";
+    }
+    return "replace";
+}
+export function resolveTelegramPreviewStreamMode(params = {}) {
+    const parsedStreaming = parseStreamingMode(params.streaming);
+    if (parsedStreaming) {
+        if (parsedStreaming === "progress") {
+            return "partial";
+        }
+        return parsedStreaming;
+    }
+    const legacy = parseDiscordPreviewStreamMode(params.streamMode);
+    if (legacy) {
+        return legacy;
+    }
+    if (typeof params.streaming === "boolean") {
+        return params.streaming ? "partial" : "off";
+    }
+    return "off";
+}
+export function resolveDiscordPreviewStreamMode(params = {}) {
+    const parsedStreaming = parseDiscordPreviewStreamMode(params.streaming);
+    if (parsedStreaming) {
+        return parsedStreaming;
+    }
+    const legacy = parseDiscordPreviewStreamMode(params.streamMode);
+    if (legacy) {
+        return legacy;
+    }
+    if (typeof params.streaming === "boolean") {
+        return params.streaming ? "partial" : "off";
+    }
+    return "off";
+}
+export function resolveSlackStreamingMode(params = {}) {
+    const parsedStreaming = parseStreamingMode(params.streaming);
+    if (parsedStreaming) {
+        return parsedStreaming;
+    }
+    const legacyStreamMode = parseSlackLegacyDraftStreamMode(params.streamMode);
+    if (legacyStreamMode) {
+        return mapSlackLegacyDraftStreamModeToStreaming(legacyStreamMode);
+    }
+    // Legacy `streaming` was a Slack native-streaming toggle; preview mode stayed replace.
+    if (typeof params.streaming === "boolean") {
+        return "partial";
+    }
+    return "partial";
+}
+export function resolveSlackNativeStreaming(params = {}) {
+    if (typeof params.nativeStreaming === "boolean") {
+        return params.nativeStreaming;
+    }
+    if (typeof params.streaming === "boolean") {
+        return params.streaming;
+    }
+    return true;
+}

package/dist/config/env-substitution.js

@@ -21,6 +21,7 @@
  */
 // Pattern for valid uppercase env var names: starts with letter or underscore,
 // followed by letters, numbers, or underscores (all uppercase)
+import { isPlainObject } from "../utils.js";
 const ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
 export class MissingEnvVarError extends Error {
     varName;
@@ -32,11 +33,35 @@ export class MissingEnvVarError extends Error {
         this.name = "MissingEnvVarError";
     }
 }
-function isPlainObject(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        !Array.isArray(value) &&
-        Object.prototype.toString.call(value) === "[object Object]");
+function parseEnvTokenAt(value, index) {
+    if (value[index] !== "$") {
+        return null;
+    }
+    const next = value[index + 1];
+    const afterNext = value[index + 2];
+    // Escaped: $${VAR} -> ${VAR}
+    if (next === "$" && afterNext === "{") {
+        const start = index + 3;
+        const end = value.indexOf("}", start);
+        if (end !== -1) {
+            const name = value.slice(start, end);
+            if (ENV_VAR_NAME_PATTERN.test(name)) {
+                return { kind: "escaped", name, end };
+            }
+        }
+    }
+    // Substitution: ${VAR} -> value
+    if (next === "{") {
+        const start = index + 2;
+        const end = value.indexOf("}", start);
+        if (end !== -1) {
+            const name = value.slice(start, end);
+            if (ENV_VAR_NAME_PATTERN.test(name)) {
+                return { kind: "substitution", name, end };
+            }
+        }
+    }
+    return null;
 }
 function substituteString(value, env, configPath) {
     if (!value.includes("$")) {
@@ -49,43 +74,46 @@ function substituteString(value, env, configPath) {
             chunks.push(char);
             continue;
         }
-        const next = value[i + 1];
-        const afterNext = value[i + 2];
-        // Escaped: $${VAR} -> ${VAR}
-        if (next === "$" && afterNext === "{") {
-            const start = i + 3;
-            const end = value.indexOf("}", start);
-            if (end !== -1) {
-                const name = value.slice(start, end);
-                if (ENV_VAR_NAME_PATTERN.test(name)) {
-                    chunks.push(`\${${name}}`);
-                    i = end;
-                    continue;
-                }
-            }
+        const token = parseEnvTokenAt(value, i);
+        if (token?.kind === "escaped") {
+            chunks.push(`\${${token.name}}`);
+            i = token.end;
+            continue;
         }
-        // Substitution: ${VAR} -> value
-        if (next === "{") {
-            const start = i + 2;
-            const end = value.indexOf("}", start);
-            if (end !== -1) {
-                const name = value.slice(start, end);
-                if (ENV_VAR_NAME_PATTERN.test(name)) {
-                    const envValue = env[name];
-                    if (envValue === undefined || envValue === "") {
-                        throw new MissingEnvVarError(name, configPath);
-                    }
-                    chunks.push(envValue);
-                    i = end;
-                    continue;
-                }
+        if (token?.kind === "substitution") {
+            const envValue = env[token.name];
+            if (envValue === undefined || envValue === "") {
+                throw new MissingEnvVarError(token.name, configPath);
             }
+            chunks.push(envValue);
+            i = token.end;
+            continue;
         }
         // Leave untouched if not a recognized pattern
         chunks.push(char);
     }
     return chunks.join("");
 }
+export function containsEnvVarReference(value) {
+    if (!value.includes("$")) {
+        return false;
+    }
+    for (let i = 0; i < value.length; i += 1) {
+        const char = value[i];
+        if (char !== "$") {
+            continue;
+        }
+        const token = parseEnvTokenAt(value, i);
+        if (token?.kind === "escaped") {
+            i = token.end;
+            continue;
+        }
+        if (token?.kind === "substitution") {
+            return true;
+        }
+    }
+    return false;
+}
 function substituteAny(value, env, path) {
     if (typeof value === "string") {
         return substituteString(value, env, path);

package/dist/config/env-vars.js

@@ -1,21 +1,59 @@
-export function collectConfigEnvVars(cfg) {
+import { isDangerousHostEnvVarName, normalizeEnvVarKey } from "../infra/host-env-security.js";
+function collectConfigEnvVarsByTarget(cfg) {
     const envConfig = cfg?.env;
-    if (!envConfig)
+    if (!envConfig) {
         return {};
+    }
     const entries = {};
     if (envConfig.vars) {
-        for (const [key, value] of Object.entries(envConfig.vars)) {
-            if (!value)
+        for (const [rawKey, value] of Object.entries(envConfig.vars)) {
+            if (!value) {
+                continue;
+            }
+            const key = normalizeEnvVarKey(rawKey, { portable: true });
+            if (!key) {
                 continue;
+            }
+            if (isDangerousHostEnvVarName(key)) {
+                continue;
+            }
             entries[key] = value;
         }
     }
-    for (const [key, value] of Object.entries(envConfig)) {
-        if (key === "shellEnv" || key === "vars")
+    for (const [rawKey, value] of Object.entries(envConfig)) {
+        if (rawKey === "shellEnv" || rawKey === "vars") {
             continue;
-        if (typeof value !== "string" || !value.trim())
+        }
+        if (typeof value !== "string" || !value.trim()) {
+            continue;
+        }
+        const key = normalizeEnvVarKey(rawKey, { portable: true });
+        if (!key) {
+            continue;
+        }
+        if (isDangerousHostEnvVarName(key)) {
             continue;
+        }
         entries[key] = value;
     }
     return entries;
 }
+export function collectConfigRuntimeEnvVars(cfg) {
+    return collectConfigEnvVarsByTarget(cfg);
+}
+export function collectConfigServiceEnvVars(cfg) {
+    return collectConfigEnvVarsByTarget(cfg);
+}
+/** @deprecated Use `collectConfigRuntimeEnvVars` or `collectConfigServiceEnvVars`. */
+export function collectConfigEnvVars(cfg) {
+    return collectConfigRuntimeEnvVars(cfg);
+}
+export function applyConfigEnvVars(cfg, env = process.env) {
+    const entries = collectConfigRuntimeEnvVars(cfg);
+    for (const [key, value] of Object.entries(entries)) {
+        if (env[key]?.trim()) {
+            continue;
+        }
+        env[key] = value;
+    }
+}