@vltpkg/cli-sdk 1.0.0-rc.22 → 1.0.0-rc.24

package/dist/commands/config.js

@@ -0,0 +1,429 @@
+import assert from 'node:assert';
+import * as dotProp from '@vltpkg/dot-prop';
+import { error } from '@vltpkg/error-cause';
+import { commandUsage } from "../config/usage.js";
+import { get, set, edit, list, del } from '@vltpkg/config';
+import { load, find } from '@vltpkg/vlt-json';
+export const views = {
+    human: results => {
+        // Handle string arrays (like list output)
+        if (Array.isArray(results) && typeof results[0] === 'string') {
+            return results.join('\n');
+        }
+        // For all other values (primitives, objects, arrays), use JSON formatting like vlt pkg
+        return JSON.stringify(results, null, 2);
+    },
+};
+export const usage = () => commandUsage({
+    command: 'config',
+    usage: '[<command>] [<args>]',
+    description: 'Get or manipulate vlt configuration values',
+    options: {
+        config: {
+            value: '<all | user | project>',
+            description: 'Specify which configuration to show or operate on.',
+        },
+    },
+    subcommands: {
+        get: {
+            usage: '[<key>] [--config=<all | user | project>]',
+            description: 'Get a single config value. Use --config to specify which config to read from.',
+        },
+        pick: {
+            usage: '[<key> [<key> ...]] [--config=<all | user | project>]',
+            description: 'Get multiple config values or all configuration. Use --config to specify which config to read from.',
+        },
+        list: {
+            usage: '[--config=<all | user | project>]',
+            description: 'Print configuration settings. --config=all shows merged config (default), --config=user shows only user config, --config=project shows only project config.',
+        },
+        set: {
+            usage: '<key>=<value> [<key>=<value> ...] [--config=<all | user | project>]',
+            description: `Set config values. By default (or with --config=all), these are
+                      written to the project config file, \`vlt.json\`
+                      in the root of the project. To set things for all
+                      projects, run with \`--config=user\`.`,
+        },
+        delete: {
+            usage: '<key> [<key> ...] [--config=<all | user | project>]',
+            description: `Delete the named config fields. If no values remain in
+                      the config file, delete the file as well. By default
+                      (or with --config=all), operates on the \`vlt.json\` file in
+                      the root of the current project. To delete a config field from
+                      the user config file, specify \`--config=user\`.`,
+        },
+        edit: {
+            usage: '[--config=<all | user | project>]',
+            description: 'Edit the configuration file. By default (or with --config=all), edits the project config file.',
+        },
+        location: {
+            usage: '[--config=<user | project>]',
+            description: 'Show the file path of the configuration file. Defaults to project config.',
+        },
+    },
+});
+export const command = async (conf) => {
+    const [sub] = conf.positionals;
+    assert(sub, error('config command requires a subcommand', {
+        code: 'EUSAGE',
+        validOptions: [
+            'get',
+            'pick',
+            'set',
+            'delete',
+            'list',
+            'edit',
+            'location',
+        ],
+    }));
+    switch (sub) {
+        case 'set':
+            return configSet(conf);
+        case 'get':
+            return configGet(conf);
+        case 'pick':
+            return configPick(conf);
+        case 'ls':
+        case 'list':
+            return configList(conf);
+        case 'edit':
+            return configEdit(conf);
+        case 'location':
+            return configLocation(conf);
+        case 'del':
+        case 'delete':
+        case 'rm':
+        case 'remove':
+        case 'unset':
+            return configDelete(conf);
+        default: {
+            throw error('Unrecognized config command', {
+                code: 'EUSAGE',
+                found: sub,
+                validOptions: [
+                    'get',
+                    'pick',
+                    'set',
+                    'delete',
+                    'list',
+                    'edit',
+                    'location',
+                ],
+            });
+        }
+    }
+};
+// Enhanced get function that supports multiple keys (falls back to pick behavior)
+const configGet = async (conf) => {
+    const keys = conf.positionals.slice(1);
+    const configOption = conf.get('config');
+    // If no keys provided, show all config (like pkg get with no args)
+    if (keys.length === 0) {
+        return configPick(conf);
+    }
+    // If exactly one key, get the value based on --config option
+    if (keys.length === 1) {
+        const key = keys[0];
+        if (!key) {
+            throw error('Key is required', { code: 'EUSAGE' });
+        }
+        switch (configOption) {
+            case 'all': {
+                // Default behavior - get from merged/consolidated config (like original get function)
+                const result = await get(conf);
+                return result;
+            }
+            case 'user': {
+                return getUserConfigValue(key);
+            }
+            case 'project': {
+                return getProjectConfigValue(key);
+            }
+            default: {
+                // Fallback to merged config
+                const result = await get(conf);
+                return result;
+            }
+        }
+    }
+    // Multiple keys: use pick behavior
+    return configPick(conf);
+};
+// New pick function for getting multiple config values (like vlt pkg pick)
+const configPick = async (conf) => {
+    const keys = conf.positionals.slice(1);
+    const configOption = conf.get('config');
+    // If no keys provided, return entire config object based on --config option (like vlt pkg pick)
+    if (keys.length === 0) {
+        switch (configOption) {
+            case 'all':
+                // For 'all', return the merged config as a serializable object
+                return getSerializableConfig(conf);
+            case 'user': {
+                // Return entire user config object
+                const userConfig = getUserConfigObject();
+                return userConfig /* c8 ignore next */ ?? {};
+            }
+            case 'project': {
+                // Return entire project config object
+                const projectConfig = getProjectConfigObject();
+                return projectConfig /* c8 ignore next */ ?? {};
+            }
+        }
+    }
+    // Multiple keys: build an object with the requested keys (like vlt pkg pick)
+    const result = {};
+    for (const key of keys) {
+        if (!key) /* c8 ignore next */
+            continue;
+        switch (configOption) {
+            case 'all':
+                // Get from merged config (default behavior)
+                result[key] = await get(Object.assign(Object.create(Object.getPrototypeOf(conf)), conf, {
+                    positionals: ['get', key],
+                }));
+                break;
+            case 'user':
+                result[key] = getUserConfigValue(key);
+                break;
+            case 'project':
+                result[key] = getProjectConfigValue(key);
+                break;
+        }
+    }
+    return result;
+};
+// Enhanced list function that respects --config option
+const configList = (conf) => {
+    const configOption = conf.get('config');
+    switch (configOption) {
+        case 'all':
+            // Default behavior - show merged config
+            return list(conf);
+        case 'user':
+            // Show only user config
+            return getUserConfigList();
+        case 'project':
+            // Show only project config
+            return getProjectConfigList();
+        default:
+            // Fallback to merged config
+            return list(conf);
+    }
+};
+// Convert RecordPairs to string array in key=value format
+const configToStringArray = (config) => {
+    const result = [];
+    for (const [key, value] of Object.entries(config)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            // Handle array values (like registries)
+            for (const item of value) {
+                if (typeof item === 'string') {
+                    result.push(`${key}=${item}`);
+                }
+            }
+        }
+        else if (typeof value === 'object') {
+            // Handle object values
+            for (const [subKey, subValue] of Object.entries(value)) {
+                if (subValue !== undefined && subValue !== null) {
+                    result.push(`${key}.${subKey}=${String(subValue)}`);
+                }
+            }
+        }
+        else {
+            // Handle primitive values
+            let stringValue;
+            if (typeof value === 'string') {
+                stringValue = value;
+            }
+            else if (typeof value === 'number' ||
+                typeof value === 'boolean') {
+                stringValue = String(value);
+            }
+            else {
+                stringValue = '[object]';
+            }
+            result.push(`${key}=${stringValue}`);
+        }
+    }
+    return result.sort();
+};
+// Get user config as key=value pairs
+const getUserConfigList = () => {
+    try {
+        const userConfig = load('config', (x, file) => {
+            if (x !== null &&
+                typeof x === 'object' &&
+                !Array.isArray(x)) {
+                return;
+            }
+            throw new Error(`Invalid config in ${file}`);
+        }, 'user');
+        if (!userConfig)
+            return /* c8 ignore next */ [];
+        return configToStringArray(userConfig);
+    }
+    catch (_err) {
+        return [];
+    }
+};
+// Get project config as key=value pairs
+const getProjectConfigList = () => {
+    try {
+        const projectConfig = load('config', (x, file) => {
+            if (x !== null &&
+                typeof x === 'object' &&
+                !Array.isArray(x)) {
+                return;
+            }
+            throw new Error(`Invalid config in ${file}`);
+        }, 'project');
+        if (!projectConfig)
+            return /* c8 ignore next */ [];
+        return configToStringArray(projectConfig);
+    }
+    catch (_err) {
+        return [];
+    }
+};
+// Get the entire user config object
+const getUserConfigObject = () => {
+    try {
+        const userConfig = load('config', (x, file) => {
+            if (x !== null &&
+                typeof x === 'object' &&
+                !Array.isArray(x)) {
+                return;
+            }
+            throw new Error(`Invalid config in ${file}`);
+        }, 'user');
+        if (!userConfig || typeof userConfig !== 'object')
+            /* c8 ignore next */
+            return;
+        return userConfig;
+    }
+    catch (_err) {
+        return;
+    }
+};
+// Get a specific value from user config
+const getUserConfigValue = (key) => {
+    const userConfig = getUserConfigObject();
+    if (!userConfig)
+        return;
+    // Use dotProp.get like vlt pkg get does
+    return dotProp.get(userConfig, key);
+};
+// Get the entire project config object
+const getProjectConfigObject = () => {
+    try {
+        const projectConfig = load('config', (x, file) => {
+            if (x !== null &&
+                typeof x === 'object' &&
+                !Array.isArray(x)) {
+                return;
+            }
+            throw new Error(`Invalid config in ${file}`);
+        }, 'project');
+        if (!projectConfig || typeof projectConfig !== 'object')
+            /* c8 ignore next */
+            return;
+        return projectConfig;
+    }
+    catch (_err) {
+        return;
+    }
+};
+// Get a specific value from project config
+const getProjectConfigValue = (key) => {
+    const projectConfig = getProjectConfigObject();
+    if (!projectConfig)
+        return;
+    // Use dotProp.get like vlt pkg get does
+    return dotProp.get(projectConfig, key);
+};
+// Helper function to get the effective config option for write operations
+const getWriteConfigOption = (conf) => {
+    const configOption = conf.get('config');
+    if (configOption === 'all') {
+        // For write operations, 'all' defaults to 'project'
+        return 'project';
+    }
+    return configOption;
+};
+// Wrapper for set command that handles --config option appropriately
+const configSet = async (conf) => {
+    const effectiveConfig = getWriteConfigOption(conf);
+    // Temporarily modify the config value for the set operation
+    const originalGet = conf.get;
+    conf.get = ((key) => {
+        if (key === 'config') {
+            return effectiveConfig;
+        }
+        return originalGet.call(conf, key);
+    });
+    try {
+        return await set(conf);
+    }
+    finally {
+        // Restore the original get method
+        conf.get = originalGet;
+    }
+};
+// Wrapper for delete command that handles --config option appropriately
+const configDelete = async (conf) => {
+    const effectiveConfig = getWriteConfigOption(conf);
+    // Temporarily modify the config value for the delete operation
+    const originalGet = conf.get;
+    conf.get = ((key) => {
+        if (key === 'config') {
+            return effectiveConfig;
+        }
+        return originalGet.call(conf, key);
+    });
+    try {
+        return await del(conf);
+    }
+    finally {
+        // Restore the original get method
+        conf.get = originalGet;
+    }
+};
+// Wrapper for edit command that handles --config option appropriately
+const configEdit = async (conf) => {
+    const effectiveConfig = getWriteConfigOption(conf);
+    // Temporarily modify the config value for the edit operation
+    const originalGet = conf.get;
+    conf.get = ((key) => {
+        if (key === 'config') {
+            return effectiveConfig;
+        }
+        return originalGet.call(conf, key);
+    });
+    try {
+        return await edit(conf);
+    }
+    finally {
+        // Restore the original get method
+        conf.get = originalGet;
+    }
+};
+// Get a serializable config object from LoadedConfig (without circular references)
+const getSerializableConfig = (conf) => {
+    // Use the list function which calls recordsToPairs to get a clean config object
+    return list(conf);
+};
+// Location command that shows config file paths
+const configLocation = (conf) => {
+    const configOption = conf.get('config');
+    // For location command, default to 'project' when 'all' is specified
+    // since there's no single "all" file to show
+    const effectiveConfig = configOption === 'all' ? 'project' : configOption;
+    // Get the config file path
+    const configPath = find(effectiveConfig);
+    return configPath;
+};

package/dist/commands/create.d.ts

@@ -0,0 +1,8 @@
+import type { PromptFn } from '@vltpkg/vlx';
+import type { ExecResult } from '../exec-command.ts';
+import type { CommandFn, CommandUsage } from '../index.ts';
+export { views } from '../exec-command.ts';
+export declare const usage: CommandUsage;
+export declare const prettyPath: (path: string) => string;
+export declare const promptFn: PromptFn;
+export declare const command: CommandFn<ExecResult>;

package/dist/commands/create.js

@@ -0,0 +1,102 @@
+import { exec, execFG } from '@vltpkg/run';
+import * as vlx from '@vltpkg/vlx';
+import { homedir } from 'node:os';
+import { createInterface } from 'node:readline/promises';
+import { commandUsage } from "../config/usage.js";
+import { ExecCommand } from "../exec-command.js";
+import { styleTextStdout } from "../output.js";
+export { views } from "../exec-command.js";
+export const usage = () => commandUsage({
+    command: 'create',
+    usage: '<initializer> [args...]',
+    description: `Initialize a new project from a template package.
+
+                  Works like \`npm create\` and \`bun create\`, automatically
+                  prepending "create-" to the package name and executing it.
+
+                  For example, \`vlt create react-app my-app\` will fetch and
+                  execute the \`create-react-app\` package with the arguments
+                  \`my-app\`.
+
+                  If a satisfying instance of the create package exists in the
+                  local \`node_modules\` folder, then that will be used.
+
+                  At no point will \`vlt create\` change the locally installed
+                  dependencies. Any installs it performs is done in vlt's XDG
+                  data directory.
+    `,
+    examples: {
+        'react-app my-app': {
+            description: 'Create a new React app using create-react-app',
+        },
+        'vite my-project': {
+            description: 'Create a new Vite project using create-vite',
+        },
+        '@scope/template my-app': {
+            description: 'Create a new project using @scope/create-template',
+        },
+    },
+    options: {
+        'allow-scripts': {
+            value: '<query>',
+            description: 'Filter which packages are allowed to run lifecycle scripts using DSS query syntax.',
+        },
+        yes: {
+            description: 'Skip interactive prompts and accept defaults.',
+        },
+    },
+});
+const HOME = homedir();
+export const prettyPath = (path) => path.startsWith(HOME) ? `~${path.substring(HOME.length)}` : path;
+export const promptFn = async (pkgSpec, path, resolution) => {
+    const response = await createInterface(process.stdin, process.stdout).question(`About to install: ${styleTextStdout(['bgWhiteBright', 'black', 'bold'], String(pkgSpec))}
+from: ${styleTextStdout(['bgWhiteBright', 'black', 'bold'], resolution)}
+into: ${styleTextStdout(['bgWhiteBright', 'black', 'bold'], prettyPath(path))}
+Is this ok? (y) `);
+    process.stdin.pause();
+    return response;
+};
+export const command = async (conf) => {
+    const [initializer, ...args] = conf.positionals;
+    if (!initializer) {
+        throw new Error('Missing required argument: <initializer>\n\nUsage: vlt create <initializer> [args...]');
+    }
+    // Transform the initializer to a create-* package name
+    // e.g., "react-app" -> "create-react-app"
+    // or "@scope/template" -> "@scope/create-template"
+    let packageName;
+    if (initializer.startsWith('@')) {
+        // Handle scoped packages: @scope/name -> @scope/create-name
+        const [scope, name] = initializer.split('/');
+        packageName = name ? `${scope}/create-${name}` : `${scope}/create`;
+    }
+    else {
+        // Handle regular packages: name -> create-name
+        packageName = `create-${initializer}`;
+    }
+    /* c8 ignore start */
+    const allowScripts = conf.get('allow-scripts') ?
+        String(conf.get('allow-scripts'))
+        : ':not(*)';
+    /* c8 ignore stop */
+    const yesFlag = conf.get('yes');
+    // Resolve the create-* package using vlx. We pass the package name as
+    // a synthetic positional so vlx treats it as the command to resolve —
+    // NOT the user's args (like "app"). Without this, vlx would mistake
+    // the first user arg as the executable to spawn.
+    const arg0 = await vlx.resolve([packageName], {
+        ...conf.options,
+        query: undefined,
+        allowScripts,
+    }, yesFlag ? async () => 'y' : promptFn);
+    // Set positionals to the resolved executable and the user's args
+    if (arg0) {
+        conf.positionals = [arg0, ...args];
+    }
+    else {
+        throw new Error(`Could not resolve executable for package "${packageName}"`);
+    }
+    // Execute the create package
+    delete conf.options['script-shell'];
+    return await new ExecCommand(conf, exec, execFG).run();
+};

package/dist/commands/docs.d.ts

@@ -0,0 +1,17 @@
+import type { CommandFn, CommandUsage } from '../index.ts';
+export declare const usage: CommandUsage;
+type CommandResultSingle = {
+    url: string;
+    name: string;
+};
+type CommandResultMultiple = {
+    url: string;
+    name: string;
+}[];
+export type CommandResult = CommandResultSingle | CommandResultMultiple;
+export declare const views: {
+    readonly human: (r: CommandResult) => string;
+    readonly json: (r: CommandResult) => CommandResult;
+};
+export declare const command: CommandFn<CommandResult>;
+export {};