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

package/dist/commands/pack.js

@@ -0,0 +1,205 @@
+import { writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+import assert from 'node:assert';
+import { run } from '@vltpkg/run';
+import { commandUsage } from "../config/usage.js";
+import { packTarball } from "../pack-tarball.js";
+import prettyBytes from 'pretty-bytes';
+import { actual } from '@vltpkg/graph';
+import { Query } from '@vltpkg/query';
+import { error } from '@vltpkg/error-cause';
+import { createHostContextsMap } from "../query-host-contexts.js";
+import { minimatch } from 'minimatch';
+export const usage = () => commandUsage({
+    command: 'pack',
+    usage: '',
+    description: `Create a tarball from a package in the current directory or specified folder.
+    
+    The tarball will be saved to the current directory with the name
+    <name>-<version>.tgz.`,
+    options: {
+        'dry-run': {
+            description: 'Show what would be packed without creating a tarball',
+        },
+        scope: {
+            value: '<query>',
+            description: 'Filter packages to pack using a DSS query selector.',
+        },
+        workspace: {
+            value: '<path|glob>',
+            description: 'Limit pack targets to matching workspaces.',
+        },
+        'workspace-group': {
+            value: '<name>',
+            description: 'Limit pack targets to workspace groups.',
+        },
+        recursive: {
+            description: 'Pack all workspaces in the monorepo.',
+        },
+    },
+});
+export const views = {
+    human: results => {
+        const item = (r) => {
+            const lines = [
+                `📦 Package: ${r.id}`,
+                `📄 File: ${r.filename}`,
+                `📁 ${r.files.length} Files`,
+                ...r.files.map(f => `  - ${f}`),
+                `📊 Package Size: ${prettyBytes(r.size)}`,
+                `📂 Unpacked Size: ${prettyBytes(r.unpackedSize)}`,
+            ];
+            if (r.shasum)
+                lines.push(`🔒 Shasum: ${r.shasum}`);
+            if (r.integrity)
+                lines.push(`🔐 Integrity: ${r.integrity}`);
+            return lines.join('\n');
+        };
+        return Array.isArray(results) ?
+            results.map(item).join('\n\n')
+            : item(results);
+    },
+    json: r => r,
+};
+/**
+ * Resolve a scope query string to workspace locations using the DSS query system.
+ */
+const scopeLocations = async (queryString, conf) => {
+    const { options, projectRoot } = conf;
+    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,
+    });
+    const locations = [];
+    for (const node of nodes) {
+        const { location } = node.toJSON();
+        assert(location, error(`node ${node.id} has no location`, {
+            found: node,
+        }));
+        locations.push(resolve(projectRoot, location));
+    }
+    return locations;
+};
+export const command = async (conf) => {
+    const { 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 = [];
+    let single = null;
+    if (queryString) {
+        locations.push(...(await scopeLocations(queryString, conf)));
+    }
+    else if (paths?.length || groups?.length || recursive) {
+        for (const workspace of options.monorepo ?? []) {
+            // When specific workspace paths are set (including auto-inferred from cwd),
+            // filter to only matching workspaces. Without this, all monorepo workspaces
+            // would be operated on even when only one was specified.
+            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 if (options.monorepo) {
+        const cwd = process.cwd();
+        if (cwd === projectRoot) {
+            for (const workspace of options.monorepo) {
+                locations.push(workspace.fullpath);
+            }
+        }
+        else {
+            const ws = options.monorepo.get(cwd);
+            if (ws) {
+                locations.push(ws.fullpath);
+            }
+            else {
+                const rel = relative(projectRoot, cwd).replaceAll('\\', '/');
+                locations.push(...(await scopeLocations(`:path("${rel}")`, conf)));
+            }
+        }
+    }
+    else {
+        single = options.packageJson.find(process.cwd()) ?? projectRoot;
+    }
+    if (single) {
+        return commandSingle(single, conf);
+    }
+    assert(locations.length > 0, error('No workspaces or query results found'));
+    const results = [];
+    for (const location of locations) {
+        results.push(await commandSingle(location, conf));
+    }
+    return results;
+};
+export const commandSingle = async (location, conf) => {
+    const manifestPath = conf.options.packageJson.find(location);
+    assert(manifestPath, 'No package.json found');
+    const manifestDir = dirname(manifestPath);
+    const manifest = conf.options.packageJson.read(manifestDir);
+    const isDryRun = conf.options['dry-run'];
+    const runOptions = {
+        cwd: manifestDir,
+        projectRoot: conf.projectRoot,
+        packageJson: conf.options.packageJson,
+        manifest,
+        ignoreMissing: true,
+        ignorePrePost: true,
+    };
+    await run({
+        ...runOptions,
+        arg0: 'prepack',
+    });
+    await run({
+        ...runOptions,
+        arg0: 'prepare',
+    });
+    // Re-read the manifest after lifecycle scripts, which may have modified package.json.
+    const updatedManifest = conf.options.packageJson.read(manifestDir, {
+        reload: true,
+    });
+    const { name, version, filename, tarballData, unpackedSize, files, integrity, shasum, } = await packTarball(updatedManifest, manifestDir, conf);
+    if (!isDryRun) {
+        await writeFile(join(manifestDir, filename), tarballData);
+    }
+    await run({
+        ...runOptions,
+        arg0: 'postpack',
+    });
+    return {
+        id: `${name}@${version}`,
+        name,
+        version,
+        filename,
+        files,
+        size: tarballData.length,
+        unpackedSize,
+        shasum,
+        integrity,
+    };
+};

package/dist/commands/ping.d.ts

@@ -0,0 +1,17 @@
+import type { CommandFn, CommandUsage } from '../index.ts';
+export declare const usage: CommandUsage;
+type PingResult = {
+    registry: string;
+    alias?: string;
+    status: 'ok' | 'error';
+    time: number;
+    statusCode?: number;
+    error?: string;
+};
+type CommandResult = PingResult | PingResult[];
+export declare const views: {
+    readonly human: (r: CommandResult) => string;
+    readonly json: (r: CommandResult) => CommandResult;
+};
+export declare const command: CommandFn<CommandResult>;
+export {};

package/dist/commands/ping.js

@@ -0,0 +1,114 @@
+import { RegistryClient } from '@vltpkg/registry-client';
+import { error } from '@vltpkg/error-cause';
+import { commandUsage } from "../config/usage.js";
+export const usage = () => commandUsage({
+    command: 'ping',
+    usage: ['', '[<registry-alias>]'],
+    description: `Ping configured registries to verify connectivity
+                  and check registry health.
+
+                  By default, pings all configured registries including
+                  the default registry.
+
+                  If a registry alias is provided, ping only that specific
+                  registry. Registry aliases are configured via the
+                  \`registries\` field in vlt.json or with the
+                  \`--registries\` option.`,
+    options: {
+        registry: {
+            value: '<url>',
+            description: 'The default registry URL to ping.',
+        },
+        registries: {
+            value: '<alias=url>',
+            description: 'Named registry aliases to ping.',
+        },
+    },
+});
+const formatPingResult = (r) => {
+    const prefix = r.alias ? `${r.alias} (${r.registry})` : r.registry;
+    if (r.status === 'ok') {
+        return `Ping successful: ${prefix} (${r.time}ms)`;
+    }
+    else {
+        return `Ping failed: ${prefix} - ${r.error}`;
+    }
+};
+export const views = {
+    human: r => {
+        if (Array.isArray(r)) {
+            return r.map(formatPingResult).join('\n');
+        }
+        return formatPingResult(r);
+    },
+    json: r => r,
+};
+const pingRegistry = async (rc, registry, alias) => {
+    const url = new URL('-/ping?write=true', registry);
+    const start = Date.now();
+    try {
+        const response = await rc.request(url, { useCache: false });
+        const time = Date.now() - start;
+        if (response.statusCode >= 200 && response.statusCode < 300) {
+            return {
+                registry,
+                alias,
+                status: 'ok',
+                time,
+                statusCode: response.statusCode,
+            };
+        }
+        else {
+            return {
+                registry,
+                alias,
+                status: 'error',
+                time,
+                statusCode: response.statusCode,
+                error: `Registry returned status ${response.statusCode}`,
+            };
+        }
+    }
+    catch (err) {
+        const time = Date.now() - start;
+        return {
+            registry,
+            alias,
+            status: 'error',
+            time,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+};
+export const command = async (conf) => {
+    const rc = new RegistryClient(conf.options);
+    const registryAlias = conf.positionals[0];
+    if (registryAlias) {
+        // Ping a specific registry by alias
+        const registries = conf.options.registries;
+        const registry = registries[registryAlias];
+        if (!registry) {
+            const availableAliases = Object.keys(registries);
+            throw error('Unknown registry alias', {
+                found: registryAlias,
+                wanted: availableAliases.length > 0 ? availableAliases : undefined,
+            });
+        }
+        return await pingRegistry(rc, registry, registryAlias);
+    }
+    else {
+        // Ping all configured registries
+        const registries = conf.options.registries;
+        const results = [];
+        // Always ping the default registry first
+        results.push(await pingRegistry(rc, conf.options.registry, 'default'));
+        // Then ping all configured registry aliases
+        for (const [alias, registry] of Object.entries(registries)) {
+            // Skip if it's the same as the default registry
+            if (registry !== conf.options.registry) {
+                results.push(await pingRegistry(rc, registry, alias));
+            }
+        }
+        return results;
+    }
+};

package/dist/commands/pkg.d.ts

@@ -0,0 +1,6 @@
+import type { CommandFn, CommandUsage } from '../index.ts';
+export declare const views: {
+    readonly human: (results: unknown, _: import("../view.ts").ViewOptions, config: import("../config/index.ts").ParsedConfig) => string;
+};
+export declare const usage: CommandUsage;
+export declare const command: CommandFn;

package/dist/commands/pkg.js

@@ -0,0 +1,232 @@
+import assert from 'node:assert';
+import { resolve } from 'node:path';
+import * as dotProp from '@vltpkg/dot-prop';
+import { error } from '@vltpkg/error-cause';
+import { init } from '@vltpkg/init';
+import { actual, GraphModifier, VIRTUAL_ROOT_ID } from '@vltpkg/graph';
+import { Query } from '@vltpkg/query';
+import { SecurityArchive } from '@vltpkg/security-archive';
+import { views as initViews } from "./init.js";
+import { commandUsage } from "../config/usage.js";
+import { createHostContextsMap } from "../query-host-contexts.js";
+import { minimatch } from 'minimatch';
+export const views = {
+    human: (results, _, config) => {
+        // `vlt pkg init` is an alias for `vlt init`
+        // use the same output handling
+        if (config.positionals[0] === 'init') {
+            return initViews.human(results);
+        }
+        // When `get` is run with a single arg and it returns a string,
+        // just print items separated by newlines
+        if (Array.isArray(results) && typeof results[0] === 'string') {
+            return results.join('\n');
+        }
+        return JSON.stringify(results, null, 2);
+    },
+};
+export const usage = () => commandUsage({
+    command: 'pkg',
+    usage: '[<command>] [<args>]',
+    description: 'Get or manipulate package.json values',
+    subcommands: {
+        get: {
+            usage: '[<key>]',
+            description: 'Get a single value',
+        },
+        init: {
+            usage: '',
+            description: 'Initialize a new package.json file in the current directory',
+        },
+        pick: {
+            usage: '[<key> [<key> ...]]',
+            description: 'Get multiple values or the entire package',
+        },
+        set: {
+            usage: '<key>=<value> [<key>=<value> ...]',
+            description: 'Set one or more key value pairs',
+        },
+        delete: {
+            usage: '<key> [<key> ...]',
+            description: 'Delete one or more keys from the package',
+        },
+    },
+    examples: {
+        'set "array[1].key=value"': {
+            description: 'Set a value on an object inside an array',
+        },
+        'set "array[]=value"': {
+            description: 'Append a value to an array',
+        },
+    },
+    options: {
+        scope: {
+            value: '<query>',
+            description: 'Filter package.json targets using a DSS query.',
+        },
+        workspace: {
+            value: '<path|glob>',
+            description: 'Limit package.json targets to matching workspaces.',
+        },
+        'workspace-group': {
+            value: '<name>',
+            description: 'Limit package.json targets to workspace groups.',
+        },
+        recursive: {
+            description: 'Operate across all workspaces in the current monorepo.',
+        },
+    },
+});
+export const command = async (conf) => {
+    const [sub, ...args] = conf.positionals;
+    if (sub === 'init') {
+        return await init({ cwd: process.cwd() });
+    }
+    assert(sub, error('pkg command requires a subcommand', {
+        code: 'EUSAGE',
+        validOptions: ['get', 'pick', 'set', 'rm', 'init'],
+    }));
+    const { 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 = [];
+    let single = null;
+    if (queryString) {
+        const modifiers = GraphModifier.maybeLoad(options);
+        const mainManifest = options.packageJson.maybeRead(projectRoot);
+        let graph;
+        let securityArchive;
+        if (mainManifest) {
+            graph = actual.load({
+                ...options,
+                mainManifest,
+                modifiers,
+                monorepo: options.monorepo,
+                loadManifests: false,
+            });
+            securityArchive =
+                Query.hasSecuritySelectors(queryString) ?
+                    await SecurityArchive.start({
+                        nodes: [...graph.nodes.values()],
+                    })
+                    : undefined;
+        }
+        const hostContexts = await createHostContextsMap(conf);
+        const edges = graph?.edges ?? new Set();
+        const nodes = graph?.nodes ?
+            new Set(graph.nodes.values())
+            : /* c8 ignore next */ new Set();
+        const importers = graph?.importers ?? new Set();
+        const query = new Query({
+            edges,
+            nodes,
+            importers,
+            securityArchive,
+            hostContexts,
+        });
+        const { nodes: resultNodes } = await query.search(queryString, {
+            signal: new AbortController().signal,
+        });
+        for (const node of resultNodes) {
+            const location = node.location;
+            assert(location, error(`node ${node.id} has no location`, {
+                found: node,
+            }));
+            if (node.id !== VIRTUAL_ROOT_ID) {
+                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 {
+        single = options.packageJson.find(process.cwd()) ?? projectRoot;
+    }
+    if (single) {
+        return commandSingle(single, sub, args, conf);
+    }
+    assert(locations.length > 0, error('No matching package found using scope', {
+        found: queryString || 'workspace selection',
+    }));
+    const results = [];
+    for (const location of locations) {
+        results.push(await commandSingle(location, sub, args, conf));
+    }
+    return results;
+};
+const commandSingle = async (location, sub, args, conf) => {
+    const pkg = conf.options.packageJson;
+    const manifest = pkg.read(location);
+    switch (sub) {
+        case 'get':
+            return get(manifest, args);
+        case 'pick':
+            return pick(manifest, args);
+        case 'set':
+            return set(manifest, location, pkg, args);
+        case 'rm':
+        case 'remove':
+        case 'unset':
+        case 'delete':
+            return rm(manifest, location, pkg, args);
+        default: {
+            throw error('Unrecognized pkg command', {
+                code: 'EUSAGE',
+                found: sub,
+                validOptions: ['get', 'set', 'rm'],
+            });
+        }
+    }
+};
+const get = (manifest, args) => {
+    const noArg = () => error('get requires not more than 1 argument. use `pick` to get more than 1.', { code: 'EUSAGE' }, noArg);
+    if (args.length === 1) {
+        const [key] = args;
+        assert(key, noArg());
+        return dotProp.get(manifest, key);
+    }
+    assert(args.length === 0, noArg());
+    return pick(manifest, args);
+};
+const pick = (manifest, args) => {
+    return args.length ?
+        args.reduce((acc, key) => dotProp.set(acc, key, dotProp.get(manifest, key)), {})
+        : manifest;
+};
+const set = (manifest, location, pkg, args) => {
+    assert(args.length >= 1, error('set requires arguments', { code: 'EUSAGE' }));
+    const res = args.reduce((acc, p) => {
+        const index = p.indexOf('=');
+        assert(index !== -1, error('set arguments must contain `=`', {
+            code: 'EUSAGE',
+        }));
+        return dotProp.set(acc, p.substring(0, index), p.substring(index + 1));
+    }, manifest);
+    pkg.write(location, res);
+};
+const rm = (manifest, location, pkg, args) => {
+    assert(args.length >= 1, error('rm requires arguments', { code: 'EUSAGE' }));
+    const res = args.reduce((acc, key) => {
+        dotProp.del(acc, key);
+        return acc;
+    }, manifest);
+    pkg.write(location, res);
+    return {
+        manifest: res,
+        location,
+    };
+};

package/dist/commands/publish.d.ts

@@ -0,0 +1,21 @@
+import type { CommandFn, CommandUsage } from '../index.ts';
+export declare const usage: CommandUsage;
+export type CommandResultSingle = {
+    id: string;
+    name: string;
+    version: string;
+    tag: string;
+    registry: string;
+    shasum?: string;
+    integrity?: string;
+    size: number;
+    access?: string;
+    unpackedSize: number;
+    files: string[];
+};
+export type CommandResult = CommandResultSingle | CommandResultSingle[];
+export declare const views: {
+    readonly human: (results: CommandResult) => string;
+    readonly json: (r: CommandResult) => CommandResult;
+};
+export declare const command: CommandFn<CommandResult>;