@nocobase/cli 2.1.0-alpha.46 → 2.1.0-alpha.47

package/dist/lib/cli-config.js

@@ -7,25 +7,40 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { loadExactAuthConfig, saveAuthConfig } from './auth-store.js';
-import { resolveDefaultConfigScope } from './cli-home.js';
+import { resolveCliHomeRoot, resolveDefaultConfigScope } from './cli-home.js';
 import { CLI_LOCALE_FLAG_OPTIONS, normalizeCliLocale, resolveCliLocale } from './cli-locale.js';
 export const DEFAULT_LICENSE_PKG_URL = 'https://pkg.nocobase.com/';
 export const DEFAULT_DOCKER_NETWORK = 'nocobase';
 export const DEFAULT_DOCKER_CONTAINER_PREFIX = 'nb';
 export const DEFAULT_DOCKER_BIN = 'docker';
+export const DEFAULT_CADDY_BIN = 'caddy';
 export const DEFAULT_GIT_BIN = 'git';
+export const DEFAULT_NGINX_BIN = 'nginx';
+export const PROXY_PROVIDER_OPTIONS = ['nginx', 'caddy'];
+export const DEFAULT_PROXY_PROVIDER = 'nginx';
+export const DEFAULT_PROXY_HOST = '127.0.0.1';
 export const DEFAULT_YARN_BIN = 'yarn';
+export const DEFAULT_LOG_RETENTION_DAYS = 14;
+export const DEFAULT_LOG_ENABLED = true;
 export const CLI_UPDATE_POLICY_OPTIONS = ['prompt', 'auto', 'off'];
 export const DEFAULT_UPDATE_POLICY = 'prompt';
 export const SUPPORTED_CLI_CONFIG_KEYS = [
     'locale',
+    'default-ui-host',
+    'default-api-host',
     'update.policy',
     'license.pkg-url',
     'docker.network',
     'docker.container-prefix',
     'bin.docker',
+    'bin.caddy',
     'bin.git',
+    'bin.nginx',
+    'proxy.nb-cli-root',
+    'proxy.upstream-host',
     'bin.yarn',
+    'log.enabled',
+    'log.retention-days',
 ];
 function trimValue(value) {
     const text = String(value ?? '').trim();
@@ -52,19 +67,33 @@ export function normalizeCliUpdatePolicy(value) {
     }
     return CLI_UPDATE_POLICY_OPTIONS.includes(normalized) ? normalized : undefined;
 }
+export function normalizeProxyProvider(value) {
+    const normalized = trimValue(value);
+    if (!normalized) {
+        return undefined;
+    }
+    return PROXY_PROVIDER_OPTIONS.includes(normalized) ? normalized : undefined;
+}
 function cloneSettings(config) {
     return {
         ...(config.settings?.locale ? { locale: trimValue(config.settings.locale) } : {}),
+        init: config.settings?.init ? { ...config.settings.init } : undefined,
         update: config.settings?.update ? { ...config.settings.update } : undefined,
         license: config.settings?.license ? { ...config.settings.license } : undefined,
         docker: config.settings?.docker ? { ...config.settings.docker } : undefined,
         bin: config.settings?.bin ? { ...config.settings.bin } : undefined,
+        proxy: config.settings?.proxy ? { ...config.settings.proxy } : undefined,
+        log: config.settings?.log ? { ...config.settings.log } : undefined,
     };
 }
 function pruneSettings(config) {
     if (config.settings && !trimValue(config.settings.locale)) {
         delete config.settings.locale;
     }
+    const init = config.settings?.init;
+    if (init && !trimValue(init.defaultUiHost) && !trimValue(init.defaultApiHost)) {
+        delete config.settings?.init;
+    }
     const update = config.settings?.update;
     if (update && !normalizeCliUpdatePolicy(update.policy)) {
         delete config.settings?.update;
@@ -78,15 +107,31 @@ function pruneSettings(config) {
         delete config.settings?.docker;
     }
     const bin = config.settings?.bin;
-    if (bin && !trimValue(bin.docker) && !trimValue(bin.git) && !trimValue(bin.yarn)) {
+    if (bin &&
+        !trimValue(bin.docker) &&
+        !trimValue(bin.caddy) &&
+        !trimValue(bin.git) &&
+        !trimValue(bin.nginx) &&
+        !trimValue(bin.yarn)) {
         delete config.settings?.bin;
     }
+    const proxy = config.settings?.proxy;
+    if (proxy && !trimValue(proxy.nbCliRoot) && !trimValue(proxy.upstreamHost)) {
+        delete config.settings?.proxy;
+    }
+    const log = config.settings?.log;
+    if (log && typeof log.enabled !== 'boolean' && (!Number.isInteger(log.retentionDays) || log.retentionDays < 0)) {
+        delete config.settings?.log;
+    }
     if (config.settings &&
         !config.settings.locale &&
+        !config.settings.init &&
         !config.settings.update &&
         !config.settings.license &&
         !config.settings.docker &&
-        !config.settings.bin) {
+        !config.settings.bin &&
+        !config.settings.proxy &&
+        !config.settings.log) {
         delete config.settings;
     }
 }
@@ -94,6 +139,10 @@ export function getExplicitCliConfigValue(config, key) {
     switch (key) {
         case 'locale':
             return trimValue(config.settings?.locale);
+        case 'default-ui-host':
+            return trimValue(config.settings?.init?.defaultUiHost);
+        case 'default-api-host':
+            return trimValue(config.settings?.init?.defaultApiHost);
         case 'update.policy':
             return normalizeCliUpdatePolicy(config.settings?.update?.policy);
         case 'license.pkg-url':
@@ -104,10 +153,24 @@ export function getExplicitCliConfigValue(config, key) {
             return trimValue(config.settings?.docker?.containerPrefix);
         case 'bin.docker':
             return trimValue(config.settings?.bin?.docker);
+        case 'bin.caddy':
+            return trimValue(config.settings?.bin?.caddy);
         case 'bin.git':
             return trimValue(config.settings?.bin?.git);
+        case 'bin.nginx':
+            return trimValue(config.settings?.bin?.nginx);
+        case 'proxy.nb-cli-root':
+            return trimValue(config.settings?.proxy?.nbCliRoot);
+        case 'proxy.upstream-host':
+            return trimValue(config.settings?.proxy?.upstreamHost);
         case 'bin.yarn':
             return trimValue(config.settings?.bin?.yarn);
+        case 'log.enabled':
+            return typeof config.settings?.log?.enabled === 'boolean' ? String(config.settings?.log?.enabled) : undefined;
+        case 'log.retention-days':
+            return Number.isInteger(config.settings?.log?.retentionDays)
+                ? String(config.settings?.log?.retentionDays)
+                : undefined;
     }
 }
 export function getEffectiveCliConfigValue(config, key) {
@@ -118,6 +181,10 @@ export function getEffectiveCliConfigValue(config, key) {
     switch (key) {
         case 'locale':
             return resolveCliLocale(undefined, { configuredLocale: trimValue(config.settings?.locale) });
+        case 'default-ui-host':
+            return '127.0.0.1';
+        case 'default-api-host':
+            return '127.0.0.1';
         case 'update.policy':
             return explicit ?? DEFAULT_UPDATE_POLICY;
         case 'license.pkg-url':
@@ -128,10 +195,22 @@ export function getEffectiveCliConfigValue(config, key) {
             return trimValue(config.name) || DEFAULT_DOCKER_CONTAINER_PREFIX;
         case 'bin.docker':
             return DEFAULT_DOCKER_BIN;
+        case 'bin.caddy':
+            return DEFAULT_CADDY_BIN;
         case 'bin.git':
             return DEFAULT_GIT_BIN;
+        case 'bin.nginx':
+            return DEFAULT_NGINX_BIN;
+        case 'proxy.nb-cli-root':
+            return explicit ?? resolveCliHomeRoot();
+        case 'proxy.upstream-host':
+            return explicit ?? DEFAULT_PROXY_HOST;
         case 'bin.yarn':
             return DEFAULT_YARN_BIN;
+        case 'log.enabled':
+            return explicit ?? String(DEFAULT_LOG_ENABLED);
+        case 'log.retention-days':
+            return explicit ?? String(DEFAULT_LOG_RETENTION_DAYS);
     }
 }
 export function normalizeCliConfigValue(key, value) {
@@ -156,6 +235,19 @@ export function normalizeCliConfigValue(key, value) {
         }
         return policy;
     }
+    if (key === 'log.retention-days') {
+        const retentionDays = Number.parseInt(normalized, 10);
+        if (!Number.isInteger(retentionDays) || retentionDays < 0) {
+            throw new Error(`Config key "${key}" must be a non-negative integer.`);
+        }
+        return String(retentionDays);
+    }
+    if (key === 'log.enabled') {
+        if (normalized !== 'true' && normalized !== 'false') {
+            throw new Error(`Config key "${key}" must be either "true" or "false".`);
+        }
+        return normalized;
+    }
     return normalized;
 }
 export async function loadCliConfig(options = {}) {
@@ -185,6 +277,18 @@ export async function setCliConfigValue(key, value, options = {}) {
         case 'locale':
             config.settings.locale = normalized;
             break;
+        case 'default-ui-host':
+            config.settings.init = {
+                ...(config.settings.init ?? {}),
+                defaultUiHost: normalized,
+            };
+            break;
+        case 'default-api-host':
+            config.settings.init = {
+                ...(config.settings.init ?? {}),
+                defaultApiHost: normalized,
+            };
+            break;
         case 'update.policy':
             config.settings.update = {
                 ...(config.settings.update ?? {}),
@@ -215,18 +319,54 @@ export async function setCliConfigValue(key, value, options = {}) {
                 docker: normalized,
             };
             break;
+        case 'bin.caddy':
+            config.settings.bin = {
+                ...(config.settings.bin ?? {}),
+                caddy: normalized,
+            };
+            break;
         case 'bin.git':
             config.settings.bin = {
                 ...(config.settings.bin ?? {}),
                 git: normalized,
             };
             break;
+        case 'bin.nginx':
+            config.settings.bin = {
+                ...(config.settings.bin ?? {}),
+                nginx: normalized,
+            };
+            break;
+        case 'proxy.nb-cli-root':
+            config.settings.proxy = {
+                ...(config.settings.proxy ?? {}),
+                nbCliRoot: normalized,
+            };
+            break;
+        case 'proxy.upstream-host':
+            config.settings.proxy = {
+                ...(config.settings.proxy ?? {}),
+                upstreamHost: normalized,
+            };
+            break;
         case 'bin.yarn':
             config.settings.bin = {
                 ...(config.settings.bin ?? {}),
                 yarn: normalized,
             };
             break;
+        case 'log.enabled':
+            config.settings.log = {
+                ...(config.settings.log ?? {}),
+                enabled: normalized === 'true',
+            };
+            break;
+        case 'log.retention-days':
+            config.settings.log = {
+                ...(config.settings.log ?? {}),
+                retentionDays: Number.parseInt(normalized, 10),
+            };
+            break;
     }
     pruneSettings(config);
     await saveAuthConfig(config, scope);
@@ -244,6 +384,16 @@ export async function deleteCliConfigValue(key, options = {}) {
         case 'locale':
             delete config.settings.locale;
             break;
+        case 'default-ui-host':
+            if (config.settings.init) {
+                delete config.settings.init.defaultUiHost;
+            }
+            break;
+        case 'default-api-host':
+            if (config.settings.init) {
+                delete config.settings.init.defaultApiHost;
+            }
+            break;
         case 'update.policy':
             if (config.settings.update) {
                 delete config.settings.update.policy;
@@ -269,16 +419,46 @@ export async function deleteCliConfigValue(key, options = {}) {
                 delete config.settings.bin.docker;
             }
             break;
+        case 'bin.caddy':
+            if (config.settings.bin) {
+                delete config.settings.bin.caddy;
+            }
+            break;
         case 'bin.git':
             if (config.settings.bin) {
                 delete config.settings.bin.git;
             }
             break;
+        case 'bin.nginx':
+            if (config.settings.bin) {
+                delete config.settings.bin.nginx;
+            }
+            break;
+        case 'proxy.nb-cli-root':
+            if (config.settings.proxy) {
+                delete config.settings.proxy.nbCliRoot;
+            }
+            break;
+        case 'proxy.upstream-host':
+            if (config.settings.proxy) {
+                delete config.settings.proxy.upstreamHost;
+            }
+            break;
         case 'bin.yarn':
             if (config.settings.bin) {
                 delete config.settings.bin.yarn;
             }
             break;
+        case 'log.enabled':
+            if (config.settings.log) {
+                delete config.settings.log.enabled;
+            }
+            break;
+        case 'log.retention-days':
+            if (config.settings.log) {
+                delete config.settings.log.retentionDays;
+            }
+            break;
     }
     pruneSettings(config);
     await saveAuthConfig(config, scope);
@@ -287,6 +467,12 @@ export async function deleteCliConfigValue(key, options = {}) {
 export async function resolveDockerNetworkName(options = {}) {
     return await getCliConfigValue('docker.network', options);
 }
+export async function resolveDefaultUiHost(options = {}) {
+    return await getCliConfigValue('default-ui-host', options);
+}
+export async function resolveDefaultApiHost(options = {}) {
+    return await getCliConfigValue('default-api-host', options);
+}
 export async function resolveDockerContainerPrefix(options = {}) {
     return await getCliConfigValue('docker.container-prefix', options);
 }
@@ -295,7 +481,9 @@ export async function resolveLicensePkgUrlFromConfig(options = {}) {
 }
 const CONFIGURABLE_COMMAND_KEYS = {
     docker: 'bin.docker',
+    caddy: 'bin.caddy',
     git: 'bin.git',
+    nginx: 'bin.nginx',
     yarn: 'bin.yarn',
 };
 export function isConfigurableCommandName(value) {

package/dist/lib/cli-entry-error.js

@@ -42,3 +42,11 @@ export function formatCliEntryError(error, argv) {
         `If \`${attemptedCommand}\` should be a runtime command from your NocoBase app, check whether the connected app exposes it, then retry the command.`,
     ].join('\n');
 }
+export function appendDiagnosticLogPath(message, logFile) {
+    const normalizedMessage = String(message ?? '').trim();
+    const normalizedLogFile = String(logFile ?? '').trim();
+    if (!normalizedLogFile) {
+        return normalizedMessage;
+    }
+    return [normalizedMessage, `Diagnostic log: ${normalizedLogFile}`].filter(Boolean).join('\n\n');
+}

package/dist/lib/command-log.js

@@ -0,0 +1,284 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { resolveCliHomeDir } from './cli-home.js';
+import { DEFAULT_LOG_ENABLED, DEFAULT_LOG_RETENTION_DAYS, getCliConfigValue } from './cli-config.js';
+const ACTIVE_LOG_FILE_ENV = 'NB_CLI_ACTIVE_LOG_FILE';
+const ACTIVE_META_FILE_ENV = 'NB_CLI_ACTIVE_META_FILE';
+const LOG_DIR_ENV = 'NB_CLI_LOG_DIR';
+const LOG_DISABLED_ENV = 'NB_CLI_LOG_DISABLED';
+const ANSI_ESCAPE_PATTERN = new RegExp(String.raw `\u001B\[[0-?]*[ -/]*[@-~]`, 'g');
+const CLEANUP_STATE_FILE = '.cleanup-state.json';
+const CLEANUP_INTERVAL_MS = 12 * 60 * 60 * 1000;
+function isTruthyEnvFlag(value) {
+    const normalized = String(value ?? '').trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+function pad(value) {
+    return String(value).padStart(2, '0');
+}
+function formatDateParts(date) {
+    const year = date.getFullYear();
+    const month = pad(date.getMonth() + 1);
+    const day = pad(date.getDate());
+    const hour = pad(date.getHours());
+    const minute = pad(date.getMinutes());
+    const second = pad(date.getSeconds());
+    return {
+        dayKey: `${year}-${month}-${day}`,
+        timestampKey: `${year}${month}${day}-${hour}${minute}${second}`,
+    };
+}
+function sanitizeFileNameSegment(value) {
+    const normalized = value
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+    return normalized || 'command';
+}
+function resolveSessionDirName(sessionId) {
+    const trimmed = String(sessionId ?? '').trim();
+    if (!trimmed) {
+        return 'no-session';
+    }
+    return sanitizeFileNameSegment(trimmed);
+}
+export function stripAnsi(value) {
+    return value.replace(ANSI_ESCAPE_PATTERN, '');
+}
+export function shouldEnableCommandLog(env = process.env) {
+    return !isTruthyEnvFlag(env[LOG_DISABLED_ENV]);
+}
+export function resolveCommandLogDir(env = process.env) {
+    if (!shouldEnableCommandLog(env)) {
+        return undefined;
+    }
+    const configured = String(env[LOG_DIR_ENV] ?? '').trim();
+    if (configured) {
+        return path.resolve(configured);
+    }
+    return path.join(resolveCliHomeDir(), 'logs');
+}
+export function getActiveCommandLogFile(env = process.env) {
+    const value = String(env[ACTIVE_LOG_FILE_ENV] ?? '').trim();
+    return value || undefined;
+}
+function readActiveCommandMetaFile(env = process.env) {
+    const value = String(env[ACTIVE_META_FILE_ENV] ?? '').trim();
+    return value || undefined;
+}
+export function hasActiveCommandLog(env = process.env) {
+    return Boolean(getActiveCommandLogFile(env));
+}
+export function sanitizeArgv(argv) {
+    const sensitiveFlags = new Set(['--token', '--access-token', '--password', '--secret']);
+    const sanitized = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (sensitiveFlags.has(token)) {
+            sanitized.push(token);
+            if (index + 1 < argv.length) {
+                sanitized.push('***');
+                index += 1;
+            }
+            continue;
+        }
+        const matched = token.match(/^(--(?:token|access-token|password|secret))=(.*)$/);
+        if (matched) {
+            sanitized.push(`${matched[1]}=***`);
+            continue;
+        }
+        sanitized.push(token);
+    }
+    return sanitized;
+}
+export function getCommandLogCommandId(argv) {
+    const positional = argv.filter((token) => token && !token.startsWith('-'));
+    if (positional.length === 0) {
+        return 'command';
+    }
+    const commandPath = positional[0] === 'api' ? positional.slice(0, 3) : positional.slice(0, 2);
+    return sanitizeFileNameSegment(commandPath.join('-'));
+}
+function parseDateDirName(name) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(name)) {
+        return undefined;
+    }
+    const parsed = new Date(`${name}T00:00:00.000Z`);
+    return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+}
+async function readCleanupState(filePath) {
+    try {
+        return JSON.parse(await fsp.readFile(filePath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+async function writeCleanupState(filePath, state) {
+    await fsp.writeFile(filePath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+async function resolveCommandLogRetentionDays() {
+    const configured = await getCliConfigValue('log.retention-days').catch(() => String(DEFAULT_LOG_RETENTION_DAYS));
+    const parsed = Number.parseInt(String(configured).trim(), 10);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        return DEFAULT_LOG_RETENTION_DAYS;
+    }
+    return parsed;
+}
+async function resolveCommandLogEnabled() {
+    const configured = await getCliConfigValue('log.enabled').catch(() => String(DEFAULT_LOG_ENABLED));
+    const normalized = String(configured).trim().toLowerCase();
+    if (normalized === 'false') {
+        return false;
+    }
+    if (normalized === 'true') {
+        return true;
+    }
+    return DEFAULT_LOG_ENABLED;
+}
+async function cleanupCommandLogs(rootDir, retentionDays, now = new Date()) {
+    if (retentionDays === 0) {
+        return;
+    }
+    const entries = await fsp.readdir(rootDir, { withFileTypes: true }).catch(() => []);
+    const cutoff = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+    cutoff.setUTCDate(cutoff.getUTCDate() - retentionDays + 1);
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const dirDate = parseDateDirName(entry.name);
+        if (!dirDate || dirDate >= cutoff) {
+            continue;
+        }
+        await fsp.rm(path.join(rootDir, entry.name), { recursive: true, force: true });
+    }
+}
+async function maybeCleanupCommandLogs(rootDir, env = process.env) {
+    await fsp.mkdir(rootDir, { recursive: true });
+    const stateFile = path.join(rootDir, CLEANUP_STATE_FILE);
+    const state = await readCleanupState(stateFile);
+    const lastCleanupAt = Date.parse(String(state.lastCleanupAt ?? ''));
+    if (!Number.isNaN(lastCleanupAt) && Date.now() - lastCleanupAt < CLEANUP_INTERVAL_MS) {
+        return;
+    }
+    const retentionDays = await resolveCommandLogRetentionDays();
+    await cleanupCommandLogs(rootDir, retentionDays);
+    await writeCleanupState(stateFile, { lastCleanupAt: new Date().toISOString() });
+}
+async function writeMetaFile(filePath, meta) {
+    await fsp.mkdir(path.dirname(filePath), { recursive: true });
+    await fsp.writeFile(filePath, `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
+}
+function writeMetaFileSync(filePath, meta) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
+}
+export async function initCommandLogSession(options) {
+    const env = options.env ?? process.env;
+    if (!shouldEnableCommandLog(env)) {
+        return undefined;
+    }
+    const enabled = await resolveCommandLogEnabled().catch(() => DEFAULT_LOG_ENABLED);
+    if (!enabled) {
+        return undefined;
+    }
+    const rootDir = resolveCommandLogDir(env);
+    if (!rootDir) {
+        return undefined;
+    }
+    await maybeCleanupCommandLogs(rootDir, env).catch(() => undefined);
+    const startedAt = options.startedAt ?? new Date();
+    const { dayKey, timestampKey } = formatDateParts(startedAt);
+    const commandId = getCommandLogCommandId(options.argv);
+    const fileStem = `${timestampKey}-${commandId}-${options.pid ?? process.pid}`;
+    const sessionDirName = resolveSessionDirName(options.sessionId);
+    const logDir = path.join(rootDir, dayKey, sessionDirName);
+    const logFile = path.join(logDir, `${fileStem}.log`);
+    const metaFile = path.join(logDir, `${fileStem}.meta.json`);
+    const meta = {
+        command: commandId,
+        argv: sanitizeArgv(options.argv),
+        cwd: options.cwd,
+        pid: options.pid ?? process.pid,
+        ppid: options.ppid ?? process.ppid,
+        sessionId: options.sessionId,
+        startedAt: startedAt.toISOString(),
+        logFile,
+        cliVersion: options.cliVersion,
+        nodeVersion: options.nodeVersion,
+        platform: options.platform,
+        interactive: options.interactive,
+        verbose: options.verbose,
+    };
+    await fsp.mkdir(logDir, { recursive: true });
+    await fsp.writeFile(logFile, '', 'utf8');
+    await writeMetaFile(metaFile, meta);
+    env[ACTIVE_LOG_FILE_ENV] = logFile;
+    env[ACTIVE_META_FILE_ENV] = metaFile;
+    return {
+        logFile,
+        metaFile,
+        meta,
+    };
+}
+export function finalizeCommandLogSessionSync(session, options = {}) {
+    if (!session) {
+        return;
+    }
+    const endedAt = options.endedAt ?? new Date();
+    const startedAtMs = Date.parse(session.meta.startedAt);
+    const nextMeta = {
+        ...session.meta,
+        endedAt: endedAt.toISOString(),
+        durationMs: Number.isNaN(startedAtMs) ? undefined : Math.max(0, endedAt.getTime() - startedAtMs),
+        exitCode: options.exitCode ?? session.meta.exitCode,
+        signal: options.signal ?? session.meta.signal,
+        errorMessage: options.errorMessage ?? session.meta.errorMessage,
+    };
+    writeMetaFileSync(session.metaFile, nextMeta);
+    session.meta = nextMeta;
+}
+export function appendCommandLogChunk(chunk, env = process.env) {
+    const logFile = getActiveCommandLogFile(env);
+    if (!logFile) {
+        return;
+    }
+    const text = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8');
+    if (!text) {
+        return;
+    }
+    fs.appendFileSync(logFile, stripAnsi(text), 'utf8');
+}
+export function installCommandLogWriteHooks(env = process.env) {
+    if (!hasActiveCommandLog(env)) {
+        return undefined;
+    }
+    const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+    const originalStderrWrite = process.stderr.write.bind(process.stderr);
+    process.stdout.write = ((chunk, encoding, callback) => {
+        appendCommandLogChunk(chunk, env);
+        return originalStdoutWrite(chunk, encoding, callback);
+    });
+    process.stderr.write = ((chunk, encoding, callback) => {
+        appendCommandLogChunk(chunk, env);
+        return originalStderrWrite(chunk, encoding, callback);
+    });
+    return () => {
+        process.stdout.write = originalStdoutWrite;
+        process.stderr.write = originalStderrWrite;
+    };
+}
+export function getActiveCommandMetaFile(env = process.env) {
+    return readActiveCommandMetaFile(env);
+}

package/dist/lib/docker-env-file.js

@@ -8,15 +8,23 @@
  */
 import { access } from 'node:fs/promises';
 import { resolveConfiguredEnvPath } from './cli-home.js';
+import { inferConfiguredAppPathFromLegacyConfig } from './env-paths.js';
 function trimValue(value) {
     const text = String(value ?? '').trim();
     return text || undefined;
 }
-export function defaultDockerEnvFilePath(envName) {
+function appendDotEnvPath(basePath) {
+    return `${basePath.replace(/[\\/]+$/, '')}/.env`;
+}
+export function defaultDockerEnvFilePath(envName, config) {
+    const appPath = inferConfiguredAppPathFromLegacyConfig(config ?? {});
+    if (appPath) {
+        return appendDotEnvPath(appPath);
+    }
     return `${envName}/.env`;
 }
 export function resolveConfiguredDockerEnvFilePath(envName, config) {
-    return trimValue(config?.envFile) || defaultDockerEnvFilePath(envName);
+    return trimValue(config?.envFile) || defaultDockerEnvFilePath(envName, config);
 }
 export function hasExplicitDockerEnvFile(config) {
     return Boolean(trimValue(config?.envFile));