@datastax/ragstack-ai-cli/dist/package-manager.js

DataStax RAGStack CLI

/* eslint-disable import/no-extraneous-dependencies */
import spawn from 'cross-spawn';
import path from 'path';
import fs from "fs";
// @ts-ignore
import { detect } from "detect-package-manager";
export async function getPackageManager(applicationPath) {
    const detected = await detect({ cwd: applicationPath });
    if (detected !== 'yarn' && detected !== 'npm') {
        throw new Error('Unsupported package manager:' + detected + '. Supported package managers are npm and yarn.');
    }
    return detected;
}
export async function getRemotePackageJson(packageName) {
    return runCommand("npm", ['show', packageName, '--json'], true);
}
/**
 * Spawn a package manager installation based on user preference.
 *
 * @returns A Promise that resolves once the installation is finished.
 */
export async function install(applicationPath, packageManager) {
    return runCommand(packageManager, ['install'], false, applicationPath);
}
export async function removeDependencies(applicationPath, packageManager, dependencies) {
    const args = [];
    const depsStr = Object.keys(dependencies).map((key) => key + "@" + dependencies[key]);
    if (packageManager === 'yarn') {
        args.push('remove', ...depsStr);
    }
    else {
        args.push('uninstall', ...depsStr);
    }
    return runCommand(packageManager, args, false, applicationPath);
}
export async function addDependencies(applicationPath, packageManager, dependencies, dev) {
    const depsStr = Object.keys(dependencies).map((key) => key + "@" + dependencies[key]);
    const args = [];
    if (packageManager === 'yarn') {
        if (dev) {
            args.push('add', '-D', ...depsStr);
        }
        else {
            args.push('add', ...depsStr);
        }
    }
    else {
        if (dev) {
            args.push('install', '--save-dev', ...depsStr);
        }
        else {
            args.push('install', ...depsStr);
        }
    }
    return runCommand(packageManager, args, false, applicationPath);
}
export async function addOverrides(applicationPath, packageManager, dependencies) {
    if (packageManager === 'yarn') {
        const packageJsonPath = path.resolve(applicationPath, "package.json");
        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
        packageJson.resolutions = packageJson.resolutions || {};
        for (let dependenciesKey in dependencies) {
            // yarn berry
            packageJson.resolutions[dependenciesKey] = dependencies[dependenciesKey];
            // yarn classic
            packageJson.resolutions["**/" + dependenciesKey] = dependencies[dependenciesKey];
        }
        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
        return install(applicationPath, packageManager);
    }
    else {
        const packageJsonPath = path.resolve(applicationPath, "package.json");
        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
        packageJson.overrides = packageJson.overrides || {};
        packageJson.overrides = {
            ...packageJson.overrides,
            dependencies
        };
        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
        return install(applicationPath, packageManager);
    }
}
function runCommand(packageManager, args, catchOutput, cwd) {
    return new Promise((resolve, reject) => {
        const stdio = catchOutput ? 'pipe' : 'inherit';
        cwd = cwd || process.cwd();
        let data = "";
        let errData = "";
        const child = spawn(packageManager, args, {
            stdio,
            cwd,
            env: {
                ...process.env,
                ADBLOCK: '1',
                // we set NODE_ENV to development as pnpm skips dev
                // dependencies when production
                NODE_ENV: 'development',
                DISABLE_OPENCOLLECTIVE: '1',
            },
        });
        if (child.stdout) {
            child.stdout.on('data', function (newdata) {
                data += newdata;
            });
        }
        if (child.stderr) {
            child.stderr.on('data', function (newdata) {
                errData += newdata;
            });
        }
        child.on('close', (code) => {
            if (code !== 0) {
                console.error(errData);
                reject({ command: `${packageManager} ${args.join(' ')}` });
                return;
            }
            resolve(data.trim());
        });
    });
}