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

package/dist/commands/run-exec.d.ts

@@ -0,0 +1,5 @@
+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 command: CommandFn<ExecResult>;

package/dist/commands/run-exec.js

@@ -0,0 +1,40 @@
+import { runExec, runExecFG } from '@vltpkg/run';
+import { commandUsage } from "../config/usage.js";
+import { ExecCommand } from "../exec-command.js";
+export { views } from "../exec-command.js";
+export const usage = () => commandUsage({
+    command: 'run-exec',
+    usage: '[command ...]',
+    description: `If the first argument is a defined script in package.json, then this is
+                  equivalent to \`vlt run\`.
+
+                  If not, then this is equivalent to \`vlt exec\`.`,
+    options: {
+        scope: {
+            value: '<query>',
+            description: 'Filter execution targets using a DSS query.',
+        },
+        workspace: {
+            value: '<path|glob>',
+            description: 'Limit execution to matching workspace paths or globs.',
+        },
+        'workspace-group': {
+            value: '<name>',
+            description: 'Limit execution to named workspace groups.',
+        },
+        recursive: {
+            description: 'Run across all selected workspaces.',
+        },
+        'if-present': {
+            description: 'When running across multiple packages, only include packages with matching scripts.',
+        },
+        bail: {
+            description: 'When running across multiple workspaces, stop on first failure.',
+        },
+        'script-shell': {
+            value: '<program>',
+            description: 'Shell to use when executing package.json scripts.',
+        },
+    },
+});
+export const command = async (conf) => await new ExecCommand(conf, runExec, runExecFG).run();

package/dist/commands/run.d.ts

@@ -0,0 +1,5 @@
+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 command: CommandFn<ExecResult>;

package/dist/commands/run.js

@@ -0,0 +1,62 @@
+import { run, runFG } from '@vltpkg/run';
+import { commandUsage } from "../config/usage.js";
+import { ExecCommand } from "../exec-command.js";
+export { views } from "../exec-command.js";
+export const usage = () => commandUsage({
+    command: 'run',
+    usage: '<script> [args ...]',
+    description: `Run a script defined in 'package.json', passing along any extra
+                  arguments. Note that vlt config values must be specified *before*
+                  the script name, because everything after that is handed off to
+                  the script process.`,
+    options: {
+        scope: {
+            value: '<query>',
+            description: 'Filter execution targets using a DSS query.',
+        },
+        workspace: {
+            value: '<path|glob>',
+            description: 'Limit execution to matching workspace paths or globs.',
+        },
+        'workspace-group': {
+            value: '<name>',
+            description: 'Limit execution to named workspace groups.',
+        },
+        recursive: {
+            description: 'Run across all selected workspaces.',
+        },
+        'if-present': {
+            description: 'When running across multiple packages, only include packages with matching scripts.',
+        },
+        bail: {
+            description: 'When running across multiple workspaces, stop on first failure.',
+        },
+        'script-shell': {
+            value: '<program>',
+            description: 'Shell to use when executing package.json scripts.',
+        },
+    },
+});
+class RunCommand extends ExecCommand {
+    constructor(conf) {
+        super(conf, run, runFG);
+    }
+    // do not provide the interactive shell arg, just do nothing
+    // so that it falls back up to the noArgsSingle() method
+    defaultArg0() { }
+    noArgsSingle() {
+        // called when there's no arg0, with a single workspace or root
+        const cwd = this.getCwd();
+        const { scripts = {} } = this.conf.options.packageJson.read(cwd);
+        return scripts;
+    }
+    noArgsMulti() {
+        const scripts = {};
+        for (const { label, manifest } of this.getTargets()) {
+            if (manifest.scripts)
+                scripts[label] = manifest.scripts;
+        }
+        return scripts;
+    }
+}
+export const command = async (conf) => await new RunCommand(conf).run();

package/dist/commands/token.d.ts

@@ -0,0 +1,3 @@
+import type { CommandFn, CommandUsage } from '../index.ts';
+export declare const usage: CommandUsage;
+export declare const command: CommandFn<void>;

package/dist/commands/token.js

@@ -0,0 +1,39 @@
+import { error } from '@vltpkg/error-cause';
+import { deleteToken, setToken } from '@vltpkg/registry-client';
+import { commandUsage } from "../config/usage.js";
+import { readPassword } from "../read-password.js";
+export const usage = () => commandUsage({
+    command: 'token',
+    usage: ['add', 'rm'],
+    description: `Explicitly add or remove tokens in the vlt keychain`,
+    options: {
+        registry: {
+            value: '<url>',
+            description: 'Registry URL to manage tokens for.',
+        },
+        identity: {
+            value: '<name>',
+            description: 'Identity namespace used to store auth tokens.',
+        },
+    },
+});
+export const command = async (conf) => {
+    const reg = new URL(conf.options.registry).origin;
+    switch (conf.positionals[0]) {
+        case 'add': {
+            await setToken(reg, `Bearer ${await readPassword('Paste bearer token: ')}`, conf.options.identity);
+            break;
+        }
+        case 'rm': {
+            await deleteToken(reg, conf.options.identity);
+            break;
+        }
+        default: {
+            throw error('Invalid token subcommand', {
+                found: conf.positionals[0],
+                validOptions: ['add', 'rm'],
+                code: 'EUSAGE',
+            });
+        }
+    }
+};

package/dist/commands/uninstall.d.ts

@@ -0,0 +1,15 @@
+import type { Graph } from '@vltpkg/graph';
+import type { CommandFn, CommandUsage } from '../index.ts';
+import { InstallReporter } from './install/reporter.ts';
+export type UninstallResult = {
+    /**
+     * The resulting graph structure at the end of an uninstall.
+     */
+    graph: Graph;
+};
+export declare const usage: CommandUsage;
+export declare const views: {
+    readonly json: (i: UninstallResult) => import("@vltpkg/graph").LockfileData;
+    readonly human: typeof InstallReporter;
+};
+export declare const command: CommandFn<UninstallResult>;

package/dist/commands/uninstall.js

@@ -0,0 +1,39 @@
+import { uninstall } from '@vltpkg/graph';
+import { commandUsage } from "../config/usage.js";
+import { parseRemoveArgs } from "../parse-add-remove-args.js";
+import { InstallReporter } from "./install/reporter.js";
+export const usage = () => commandUsage({
+    command: 'uninstall',
+    usage: '[package ...]',
+    description: `The opposite of \`vlt install\`. Removes deps and updates
+                  vlt-lock.json and package.json appropriately.`,
+    options: {
+        workspace: {
+            value: '<path|glob>',
+            description: 'Limit uninstall targets to matching workspaces.',
+        },
+        'workspace-group': {
+            value: '<name>',
+            description: 'Limit uninstall targets to workspace groups.',
+        },
+        'allow-scripts': {
+            value: '<query>',
+            description: 'Filter which packages are allowed to run lifecycle scripts using DSS query syntax.',
+        },
+    },
+});
+export const views = {
+    json: i => i.graph.toJSON(),
+    human: InstallReporter,
+};
+export const command = async (conf) => {
+    const { monorepo, scurry } = conf.options;
+    const { remove } = parseRemoveArgs(conf, scurry, monorepo);
+    /* c8 ignore start */
+    const allowScripts = conf.get('allow-scripts') ?
+        String(conf.get('allow-scripts'))
+        : ':not(*)';
+    /* c8 ignore stop */
+    const { graph } = await uninstall({ ...conf.options, allowScripts }, remove);
+    return { graph };
+};

package/dist/commands/update.d.ts

@@ -0,0 +1,13 @@
+import type { CommandFn, CommandUsage } from '../index.ts';
+import { InstallReporter } from './install/reporter.ts';
+import type { InstallResult } from './install.ts';
+export declare const usage: CommandUsage;
+export declare const views: {
+    readonly json: (i: InstallResult) => {
+        graph: import("@vltpkg/graph").LockfileData;
+        buildQueue?: import("@vltpkg/dep-id").DepID[] | undefined;
+        message?: string | undefined;
+    };
+    readonly human: typeof InstallReporter;
+};
+export declare const command: CommandFn<InstallResult>;

package/dist/commands/update.js

@@ -0,0 +1,46 @@
+import { update } from '@vltpkg/graph';
+import { error } from '@vltpkg/error-cause';
+import { commandUsage } from "../config/usage.js";
+import { InstallReporter } from "./install/reporter.js";
+export const usage = () => commandUsage({
+    command: 'update',
+    usage: '',
+    description: `Update dependencies to their latest in-range versions.
+                  Discards the lockfile and resolves dependencies from scratch.`,
+    options: {
+        'allow-scripts': {
+            value: '<query>',
+            description: 'Filter which packages are allowed to run lifecycle scripts using DSS query syntax.',
+        },
+    },
+});
+export const views = {
+    json: i => ({
+        ...(i.buildQueue?.length ?
+            {
+                buildQueue: i.buildQueue,
+                message: `${i.buildQueue.length} packages that will need to be built, run "vlt build" to complete the update.`,
+            }
+            : null),
+        graph: i.graph.toJSON(),
+    }),
+    human: InstallReporter,
+};
+export const command = async (conf) => {
+    // Throw error if any arguments are provided
+    if (conf.positionals.length > 0) {
+        throw error('Arguments are not yet supported for vlt update', {
+            code: 'EUSAGE',
+        });
+    }
+    /* c8 ignore start */
+    const allowScripts = conf.get('allow-scripts') ?
+        String(conf.get('allow-scripts'))
+        : ':not(*)';
+    /* c8 ignore stop */
+    const { buildQueue, graph } = await update({
+        ...conf.options,
+        allowScripts,
+    });
+    return { buildQueue, graph };
+};

package/dist/commands/version.d.ts

@@ -0,0 +1,25 @@
+import type { CommandFn, CommandUsage } from '../index.ts';
+export type VersionOptions = {
+    prereleaseId?: string;
+    commit?: boolean;
+    tag?: boolean;
+    message?: string;
+    tagMessage?: string;
+    includeNameInCommit?: boolean;
+    includeNameInTag?: boolean;
+};
+export type CommandResultSingle = {
+    name: string;
+    oldVersion: string;
+    newVersion: string;
+    dir: string;
+    committed?: string[];
+    tag?: string;
+};
+export type CommandResult = CommandResultSingle | CommandResultSingle[];
+export declare const usage: CommandUsage;
+export declare const views: {
+    readonly json: (result: CommandResult) => CommandResult;
+    readonly human: (results: CommandResult) => string;
+};
+export declare const command: CommandFn<CommandResult>;

package/dist/commands/version.js

@@ -0,0 +1,252 @@
+import { inc, parse as parseVersion, versionIncrements, } from '@vltpkg/semver';
+import { is as isGit, spawn as spawn_, isClean } from '@vltpkg/git';
+import { error } from '@vltpkg/error-cause';
+import { asError } from '@vltpkg/types';
+import { commandUsage } from "../config/usage.js";
+import { dirname, resolve } from 'node:path';
+import assert from 'node:assert';
+import { actual } from '@vltpkg/graph';
+import { Query } from '@vltpkg/query';
+import { createHostContextsMap } from "../query-host-contexts.js";
+import { minimatch } from 'minimatch';
+const isValidVersionIncrement = (value) => versionIncrements.includes(value);
+const version = async (conf, increment, cwd, { 
+// Hardcode happy path options for now.
+// TODO: make these config definitions
+prereleaseId = 'pre', commit = true, tag = true, message = 'v%s', tagMessage = 'v%s', includeNameInCommit = false, includeNameInTag = false, } = {}) => {
+    assert(increment, error('Version increment argument is required', {
+        code: 'EUSAGE',
+        validOptions: versionIncrements,
+    }));
+    const manifestPath = conf.options.packageJson.find(cwd);
+    assert(manifestPath, error('No package.json found', {
+        code: 'ENOENT',
+        path: cwd,
+    }));
+    const spawn = (args, opts) => spawn_(args, { cwd: manifestDir, ...opts });
+    const manifestDir = dirname(manifestPath);
+    const manifest = conf.options.packageJson.read(manifestDir);
+    assert(manifest.name, error('No name field found in package.json', {
+        path: manifestPath,
+    }));
+    assert(manifest.version, error('No version field found in package.json', {
+        path: manifestPath,
+    }));
+    const oldVersion = manifest.version;
+    let newVersion;
+    // Check if increment is a valid semver version string
+    const parsedIncrement = parseVersion(increment);
+    if (parsedIncrement) {
+        newVersion = parsedIncrement.toString();
+    }
+    else if (isValidVersionIncrement(increment)) {
+        // Use semver increment
+        const incrementType = increment;
+        try {
+            const result = inc(oldVersion, incrementType, prereleaseId);
+            newVersion = result.toString();
+        }
+        catch (err) {
+            throw error(`Failed to increment version from ${oldVersion} with ${increment}`, { version: oldVersion, wanted: increment, cause: err });
+        }
+    }
+    else {
+        throw error(`Invalid version increment: ${increment}. Must be a valid semver version or one of: major, minor, patch, premajor, preminor, prepatch, prerelease`, {
+            found: increment,
+            validOptions: versionIncrements,
+        });
+    }
+    // Update the manifest
+    manifest.version = newVersion;
+    conf.options.packageJson.write(manifestDir, manifest);
+    const result = {
+        name: manifest.name,
+        oldVersion,
+        newVersion,
+        dir: manifestDir,
+    };
+    // Handle git operations if we're in a git repository
+    if (
+    /* c8 ignore next -- commit and tag are always true for now */
+    (commit || tag) &&
+        (await isGit({ cwd: conf.options.projectRoot }))) {
+        // Check for uncommitted changes (excluding package.json since we just modified it)
+        if (!(await isClean({ cwd: conf.options.projectRoot }))) {
+            try {
+                // Check if there are changes other than package.json
+                const gitResult = await spawn([
+                    'diff',
+                    '--name-only',
+                    'HEAD',
+                    '--',
+                    '.',
+                ]);
+                const changedFiles = gitResult.stdout
+                    .trim()
+                    .split('\n')
+                    .filter(Boolean)
+                    .map(f => resolve(conf.options.projectRoot, f));
+                const nonPackageJsonChanges = changedFiles.filter(file => file !== resolve(manifestDir, 'package.json'));
+                assert(nonPackageJsonChanges.length === 0, error('Git working directory not clean. Please commit or stash your changes first.', { found: nonPackageJsonChanges }));
+            }
+            catch (err) {
+                throw error('Git working directory not clean. Please commit or stash your changes first.', asError(err));
+            }
+        }
+        if (commit) {
+            try {
+                // Stage package.json
+                const files = ['package.json'];
+                await spawn(['add', ...files]);
+                await spawn([
+                    'commit',
+                    '-m',
+                    `${includeNameInCommit ? `${manifest.name}: ` : ''}${message.replace('%s', newVersion)}`,
+                ]);
+                result.committed = files.map(f => resolve(manifestDir, f));
+            }
+            catch (err) {
+                throw error('Failed to commit version changes', {
+                    version: newVersion,
+                    cause: err,
+                });
+            }
+        }
+        if (tag) {
+            try {
+                const tagName = (includeNameInTag ?
+                    `${manifest.name.replace('/', '-').replace('@', '')}-`
+                    : '') + `v${newVersion}`;
+                await spawn([
+                    'tag',
+                    tagName,
+                    '-m',
+                    (includeNameInTag ? `${manifest.name}: ` : '') +
+                        tagMessage.replace('%s', newVersion),
+                ]);
+                result.tag = tagName;
+            }
+            catch (err) {
+                throw error('Failed to create git tag', {
+                    version: newVersion,
+                    cause: err,
+                });
+            }
+        }
+    }
+    return result;
+};
+export const usage = () => {
+    return commandUsage({
+        command: 'version',
+        usage: '[<newversion> | major | minor | patch | premajor | preminor | prepatch | prerelease]',
+        description: `Bump a package's version.
+
+    Run in a package directory to bump the version and write the new data back to package.json.
+
+    The \`<newversion>\` argument should be a valid semver string or a valid increment type (one of patch, minor, major, prepatch, preminor, premajor, prerelease).
+
+    If run in a git repository, it will also create a version commit and tag.`,
+        options: {
+            scope: {
+                value: '<query>',
+                description: 'Filter version bump targets using a DSS query.',
+            },
+            workspace: {
+                value: '<path|glob>',
+                description: 'Limit version bump targets to matching workspaces.',
+            },
+            'workspace-group': {
+                value: '<name>',
+                description: 'Limit version bump targets to workspace groups.',
+            },
+            recursive: {
+                description: 'Run version bump across all workspaces in the monorepo.',
+            },
+        },
+    });
+};
+export const views = {
+    json: result => result,
+    human: results => {
+        const item = (result) => {
+            let output = `${result.name}: v${result.newVersion}`;
+            if (result.committed) {
+                output += ` +commit`;
+            }
+            if (result.tag) {
+                output += ` +tag`;
+            }
+            return output;
+        };
+        return Array.isArray(results) ?
+            results.map(item).join('\n')
+            : item(results);
+    },
+};
+export const command = async (conf) => {
+    const { positionals, options, projectRoot } = conf;
+    const queryString = conf.get('scope');
+    const paths = conf.get('workspace');
+    const groups = conf.get('workspace-group');
+    const recursive = conf.get('recursive');
+    const locations = [];
+    if (queryString) {
+        const mainManifest = options.packageJson.maybeRead(projectRoot);
+        let graph;
+        if (mainManifest) {
+            graph = actual.load({
+                ...options,
+                mainManifest,
+                monorepo: options.monorepo,
+                loadManifests: false,
+            });
+        }
+        const hostContexts = await createHostContextsMap(conf);
+        const query = new Query({
+            /* c8 ignore next */
+            nodes: graph ? new Set(graph.nodes.values()) : new Set(),
+            edges: graph?.edges ?? new Set(),
+            importers: graph?.importers ?? new Set(),
+            securityArchive: undefined,
+            hostContexts,
+        });
+        const { nodes } = await query.search(queryString, {
+            signal: new AbortController().signal,
+        });
+        for (const node of nodes) {
+            const location = node.location;
+            assert(location, error(`node ${node.id} has no location`, {
+                found: node,
+            }));
+            locations.push(resolve(node.projectRoot, location));
+        }
+    }
+    else if (paths?.length || groups?.length || recursive) {
+        for (const workspace of options.monorepo ?? []) {
+            if (paths?.length) {
+                const matches = paths.some((p) => workspace.path === p ||
+                    workspace.name === p ||
+                    workspace.fullpath === p ||
+                    resolve(projectRoot, p) === workspace.fullpath ||
+                    minimatch(workspace.path, p));
+                if (!matches)
+                    continue;
+            }
+            locations.push(workspace.fullpath);
+        }
+    }
+    else {
+        const cwd = options.packageJson.find(process.cwd()) ?? projectRoot;
+        return version(conf, positionals[0], cwd);
+    }
+    assert(locations.length > 0, error('No workspaces or query results found'));
+    const results = [];
+    for (const location of locations) {
+        results.push(await version(conf, positionals[0], location, {
+            includeNameInCommit: true,
+            includeNameInTag: true,
+        }));
+    }
+    return results;
+};

package/dist/commands/view.d.ts

@@ -0,0 +1,22 @@
+import type { Manifest, Packument } from '@vltpkg/types';
+import type { PackageReportData } from '@vltpkg/security-archive';
+import type { CommandFn, CommandUsage } from '../index.ts';
+import type { ViewOptions } from '../view.ts';
+export declare const usage: CommandUsage;
+export type ViewResult = {
+    /** The full packument data from the registry */
+    packument: Packument;
+    /** The resolved manifest for the requested version */
+    manifest: Manifest;
+    /** Security report data, if available */
+    security?: PackageReportData;
+    /** The specific field value if a field was requested */
+    fieldValue?: unknown;
+    /** The field path that was requested */
+    fieldPath?: string;
+};
+export declare const views: {
+    readonly human: (result: ViewResult, _options: ViewOptions, _conf: import("../config/index.ts").ParsedConfig) => string;
+    readonly json: (result: ViewResult, _options: ViewOptions, _conf: import("../config/index.ts").ParsedConfig) => unknown;
+};
+export declare const command: CommandFn<ViewResult>;