@nocobase/cli 2.1.0-beta.44.test.3 → 2.1.0-beta.44.test.4

package/dist/lib/run-npm.js

@@ -1,393 +0,0 @@
-/**
- * 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.
- */
-/**
- * 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 os from 'node:os';
-import path from 'node:path';
-import spawn from 'cross-spawn';
-import { translateCli } from './cli-locale.js';
-import { resolveConfiguredCommandName } from './cli-config.js';
-const FORWARDED_SIGNALS = ['SIGINT', 'SIGTERM'];
-const PROCESS_TIMEOUT_FORCE_KILL_DELAY_MS = 1000;
-const MISSING_COMMAND_SPECS = {
-    docker: {
-        displayName: 'Docker',
-        configKey: 'bin.docker',
-    },
-    caddy: {
-        displayName: 'Caddy',
-        configKey: 'bin.caddy',
-    },
-    git: {
-        displayName: 'Git',
-        configKey: 'bin.git',
-    },
-    nginx: {
-        displayName: 'Nginx',
-        configKey: 'bin.nginx',
-    },
-    yarn: {
-        displayName: 'Yarn',
-        configKey: 'bin.yarn',
-    },
-};
-async function resolveCommandName(name) {
-    return await resolveConfiguredCommandName(name);
-}
-function createMissingCommandError(name, label, error) {
-    const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : undefined;
-    if (code !== 'ENOENT') {
-        return undefined;
-    }
-    if (!Object.prototype.hasOwnProperty.call(MISSING_COMMAND_SPECS, name)) {
-        return undefined;
-    }
-    const spec = MISSING_COMMAND_SPECS[name];
-    return new Error(translateCli('commands.shared.missingCommand', { action: label, displayName: spec.displayName, configKey: spec.configKey }, {
-        fallback: `Couldn't run \`${label}\` because the ${spec.displayName} executable could not be found. Install ${spec.displayName} or update \`nb config set ${spec.configKey} <path>\` and try again.`,
-    }));
-}
-function pathExists(candidate) {
-    try {
-        return Boolean(candidate) && fs.statSync(candidate) !== undefined;
-    }
-    catch {
-        return false;
-    }
-}
-function isDirectory(candidate) {
-    try {
-        return Boolean(candidate) && fs.statSync(candidate).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-function hasLocalNocoBaseBinary(candidate) {
-    return (pathExists(path.join(candidate, 'node_modules', '.bin', 'nocobase-v1')) ||
-        pathExists(path.join(candidate, 'node_modules', '.bin', 'nocobase-v1.cmd')));
-}
-export function resolveCwd(cwd) {
-    const next = cwd ?? process.cwd();
-    if (path.isAbsolute(next)) {
-        return next;
-    }
-    return path.resolve(process.cwd(), next);
-}
-export function resolveProjectCwd(cwd) {
-    const normalizedCwd = typeof cwd === 'string' && cwd.trim() === '' ? undefined : cwd;
-    const fallback = resolveCwd(normalizedCwd);
-    const hasExplicitInput = normalizedCwd !== undefined;
-    if (hasExplicitInput && !pathExists(fallback)) {
-        throw new Error(`The specified --cwd does not exist: ${fallback}`);
-    }
-    if (hasExplicitInput && !isDirectory(fallback)) {
-        throw new Error(`The specified --cwd is not a directory: ${fallback}`);
-    }
-    let current = hasExplicitInput ? fallback : process.cwd();
-    while (!hasLocalNocoBaseBinary(current)) {
-        const parent = path.dirname(current);
-        if (parent === current) {
-            if (hasExplicitInput) {
-                throw new Error(`Couldn't find a NocoBase source project from --cwd: ${fallback}`);
-            }
-            return fallback;
-        }
-        current = parent;
-    }
-    return current;
-}
-export async function run(name, args, options) {
-    const cwd = resolveCwd(options?.cwd);
-    const label = options?.errorName ?? name;
-    const command = await resolveCommandName(name);
-    return await new Promise((resolve, reject) => {
-        const child = spawn(command, [...args], {
-            stdio: options?.stdio ?? 'inherit',
-            cwd,
-            env: {
-                ...process.env,
-                ...options?.env,
-            },
-            windowsHide: process.platform === 'win32',
-        });
-        if (options?.stdio === 'pipe') {
-            child.stdout?.setEncoding('utf8');
-            child.stderr?.setEncoding('utf8');
-            if (options.onStdout) {
-                child.stdout?.on('data', (chunk) => {
-                    options.onStdout?.(String(chunk));
-                });
-            }
-            if (options.onStderr) {
-                child.stderr?.on('data', (chunk) => {
-                    options.onStderr?.(String(chunk));
-                });
-            }
-        }
-        const cleanupSignalForwarding = forwardSignalsToChild(child);
-        const timeoutController = attachProcessTimeout(child, options?.timeoutMs);
-        child.once('error', (error) => {
-            timeoutController.cleanup();
-            cleanupSignalForwarding();
-            reject(createMissingCommandError(name, label, error) ?? error);
-        });
-        child.once('close', (code, signal) => {
-            timeoutController.cleanup();
-            cleanupSignalForwarding();
-            if (timeoutController.didTimeout()) {
-                reject(new Error(`${label} timed out after ${options?.timeoutMs}ms`));
-                return;
-            }
-            if (code === 0) {
-                resolve();
-                return;
-            }
-            if (signal) {
-                reject(new Error(`${label} exited due to signal ${signal}`));
-                return;
-            }
-            reject(new Error(`${label} exited with code ${code}`));
-        });
-    });
-}
-function attachProcessTimeout(child, timeoutMs) {
-    if (!timeoutMs || timeoutMs <= 0) {
-        return {
-            cleanup: () => undefined,
-            didTimeout: () => false,
-        };
-    }
-    let didTimeout = false;
-    let forceKillTimer;
-    const isChildRunning = () => child.exitCode === null && child.signalCode === null;
-    const terminateChild = (signal) => {
-        if (!isChildRunning()) {
-            return;
-        }
-        try {
-            child.kill(signal);
-        }
-        catch {
-            // Ignore kill errors here and let the child close/error handlers surface the failure.
-        }
-    };
-    const timeoutTimer = setTimeout(() => {
-        didTimeout = true;
-        terminateChild('SIGTERM');
-        forceKillTimer = setTimeout(() => {
-            terminateChild('SIGKILL');
-        }, PROCESS_TIMEOUT_FORCE_KILL_DELAY_MS);
-        forceKillTimer.unref?.();
-    }, timeoutMs);
-    timeoutTimer.unref?.();
-    return {
-        cleanup: () => {
-            clearTimeout(timeoutTimer);
-            if (forceKillTimer) {
-                clearTimeout(forceKillTimer);
-            }
-        },
-        didTimeout: () => didTimeout,
-    };
-}
-function forwardSignalsToChild(child) {
-    let forwardedSignalCount = 0;
-    const listeners = new Map();
-    const isChildRunning = () => child.exitCode === null && child.signalCode === null;
-    for (const signal of FORWARDED_SIGNALS) {
-        const listener = () => {
-            if (!isChildRunning()) {
-                return;
-            }
-            const nextSignal = forwardedSignalCount > 0 ? 'SIGKILL' : signal;
-            forwardedSignalCount += 1;
-            try {
-                child.kill(nextSignal);
-            }
-            catch {
-                // Ignore kill errors here and let the child close/error handlers surface the failure.
-            }
-        };
-        listeners.set(signal, listener);
-        process.on(signal, listener);
-    }
-    return () => {
-        for (const [signal, listener] of listeners) {
-            process.off(signal, listener);
-        }
-    };
-}
-export async function commandSucceeds(name, args, options) {
-    const cwd = resolveCwd(options?.cwd);
-    const label = options?.errorName ?? name;
-    const command = await resolveCommandName(name);
-    return await new Promise((resolve, reject) => {
-        const child = spawn(command, [...args], {
-            cwd,
-            env: {
-                ...process.env,
-                ...options?.env,
-            },
-            stdio: 'ignore',
-            windowsHide: process.platform === 'win32',
-        });
-        const timeoutController = attachProcessTimeout(child, options?.timeoutMs);
-        child.once('error', (error) => {
-            timeoutController.cleanup();
-            const missingCommandError = createMissingCommandError(name, label, error);
-            if (missingCommandError) {
-                reject(missingCommandError);
-                return;
-            }
-            resolve(false);
-        });
-        child.once('close', (code) => {
-            timeoutController.cleanup();
-            if (timeoutController.didTimeout()) {
-                resolve(false);
-                return;
-            }
-            resolve(code === 0);
-        });
-    });
-}
-export async function commandOutput(name, args, options) {
-    const cwd = resolveCwd(options?.cwd);
-    const label = options?.errorName ?? name;
-    const command = await resolveCommandName(name);
-    return await new Promise((resolve, reject) => {
-        const child = spawn(command, [...args], {
-            cwd,
-            env: {
-                ...process.env,
-                ...options?.env,
-            },
-            stdio: ['ignore', 'pipe', 'pipe'],
-            windowsHide: process.platform === 'win32',
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.setEncoding('utf8');
-        child.stderr.setEncoding('utf8');
-        child.stdout.on('data', (chunk) => {
-            stdout += chunk;
-        });
-        child.stderr.on('data', (chunk) => {
-            stderr += chunk;
-        });
-        const timeoutController = attachProcessTimeout(child, options?.timeoutMs);
-        child.once('error', (error) => {
-            timeoutController.cleanup();
-            reject(createMissingCommandError(name, label, error) ?? error);
-        });
-        child.once('close', (code, signal) => {
-            timeoutController.cleanup();
-            if (timeoutController.didTimeout()) {
-                reject(new Error(`${label} timed out after ${options?.timeoutMs}ms`));
-                return;
-            }
-            if (code === 0) {
-                resolve(stdout.trim());
-                return;
-            }
-            if (signal) {
-                reject(new Error(`${label} exited due to signal ${signal}`));
-                return;
-            }
-            const details = stderr.trim() || stdout.trim();
-            reject(new Error(details ? `${label} exited with code ${code}: ${details}` : `${label} exited with code ${code}`));
-        });
-    });
-}
-async function readCommandOutputFile(filePath) {
-    try {
-        return await fsp.readFile(filePath, 'utf8');
-    }
-    catch {
-        return '';
-    }
-}
-export async function commandOutputViaFile(name, args, options) {
-    const cwd = resolveCwd(options?.cwd);
-    const label = options?.errorName ?? name;
-    const command = await resolveCommandName(name);
-    const captureDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'nocobase-cli-output-'));
-    const stdoutPath = path.join(captureDir, 'stdout.log');
-    const stderrPath = path.join(captureDir, 'stderr.log');
-    const stdoutHandle = await fsp.open(stdoutPath, 'w');
-    const stderrHandle = await fsp.open(stderrPath, 'w');
-    try {
-        const result = await new Promise((resolve, reject) => {
-            const child = spawn(command, [...args], {
-                cwd,
-                env: {
-                    ...process.env,
-                    ...options?.env,
-                },
-                stdio: ['ignore', stdoutHandle.fd, stderrHandle.fd],
-                windowsHide: process.platform === 'win32',
-            });
-            const timeoutController = attachProcessTimeout(child, options?.timeoutMs);
-            child.once('error', (error) => {
-                timeoutController.cleanup();
-                reject(createMissingCommandError(name, label, error) ?? error);
-            });
-            child.once('close', (code, signal) => {
-                timeoutController.cleanup();
-                if (timeoutController.didTimeout()) {
-                    reject(new Error(`${label} timed out after ${options?.timeoutMs}ms`));
-                    return;
-                }
-                resolve({ code, signal });
-            });
-        });
-        await stdoutHandle.close();
-        await stderrHandle.close();
-        const stdout = await readCommandOutputFile(stdoutPath);
-        const stderr = await readCommandOutputFile(stderrPath);
-        if (result.code === 0) {
-            return stdout.trim();
-        }
-        if (result.signal) {
-            throw new Error(`${label} exited due to signal ${result.signal}`);
-        }
-        const details = stderr.trim() || stdout.trim();
-        throw new Error(details ? `${label} exited with code ${result.code}: ${details}` : `${label} exited with code ${result.code}`);
-    }
-    finally {
-        await Promise.allSettled([stdoutHandle.close(), stderrHandle.close()]);
-        await fsp.rm(captureDir, { recursive: true, force: true });
-    }
-}
-/** Run `yarn` with the given argument list, inheriting stdio (errors label as `npm` for compatibility). */
-export function runNpm(args, options) {
-    return run('yarn', [...args], { ...options, errorName: 'npm' });
-}
-export function runNocoBaseCommand(args, options) {
-    const cwd = resolveProjectCwd(options?.cwd);
-    const localBin = path.join(cwd, 'node_modules', '.bin');
-    return run('nocobase-v1', [...args], {
-        ...options,
-        cwd,
-        errorName: 'nocobase command',
-        env: {
-            PATH: `${localBin}${path.delimiter}${process.env.PATH ?? ''}`,
-            ...options?.env,
-        },
-    });
-}

package/dist/lib/runtime-env-vars.js

@@ -1,32 +0,0 @@
-/**
- * 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 { resolveBuiltinDbConnection } from './builtin-db.js';
-function put(out, key, value) {
-    if (value === undefined || value === null) {
-        return;
-    }
-    out[key] = String(value);
-}
-export async function buildRuntimeEnvVars(runtime) {
-    const config = runtime.env.config ?? {};
-    const out = {
-        ...runtime.env.envVars,
-    };
-    if (runtime.kind !== 'local' && runtime.kind !== 'docker') {
-        return out;
-    }
-    if (!config.builtinDb) {
-        return out;
-    }
-    const connection = await resolveBuiltinDbConnection(runtime);
-    put(out, 'DB_DIALECT', connection.dbDialect);
-    put(out, 'DB_HOST', connection.dbHost);
-    put(out, 'DB_PORT', connection.dbPort);
-    return out;
-}