@vltpkg/cli-sdk 1.0.0-rc.3 → 1.0.0-rc.30

package/dist/commands/profile.d.ts

@@ -0,0 +1,13 @@
+import type { JSONField } from '@vltpkg/types';
+import type { CommandFn, CommandUsage } from '../index.ts';
+export declare const usage: CommandUsage;
+export type ProfileData = Record<string, JSONField>;
+export type ProfileResult = ProfileData | {
+    property: string;
+    value: JSONField;
+};
+export declare const views: {
+    readonly human: (result: ProfileResult) => string;
+    readonly json: (r: ProfileResult) => ProfileResult;
+};
+export declare const command: CommandFn<ProfileResult>;

package/dist/commands/profile.js

@@ -0,0 +1,104 @@
+import { error } from '@vltpkg/error-cause';
+import { RegistryClient } from '@vltpkg/registry-client';
+import { commandUsage } from "../config/usage.js";
+export const usage = () => commandUsage({
+    command: 'profile',
+    usage: '<command> [<args>]',
+    description: `Get or set profile properties for the authenticated user
+                  on the configured registry.`,
+    subcommands: {
+        get: {
+            usage: '[<property>]',
+            description: 'Display profile information. Optionally pass a property name to get a single value.',
+        },
+        set: {
+            usage: '<property> <value>',
+            description: 'Set a profile property to the given value.',
+        },
+    },
+    options: {
+        registry: {
+            value: '<url>',
+            description: 'Registry URL to query for profile info.',
+        },
+        identity: {
+            value: '<name>',
+            description: 'Identity namespace used to look up auth tokens.',
+        },
+        otp: {
+            description: 'Provide an OTP to use when updating profile properties.',
+            value: '<otp>',
+        },
+    },
+});
+const stringify = (v) => typeof v === 'string' ? v
+    : typeof v === 'number' || typeof v === 'boolean' ? `${v}`
+        : v === null ? 'null'
+            : JSON.stringify(v);
+export const views = {
+    human: result => {
+        if ('property' in result) {
+            return stringify(result.value);
+        }
+        return Object.entries(result)
+            .map(([k, v]) => `${k}: ${stringify(v)}`)
+            .join('\n');
+    },
+    json: r => r,
+};
+export const command = async (conf) => {
+    const [sub, ...args] = conf.positionals;
+    switch (sub) {
+        case 'get':
+            return getProfile(conf, args);
+        case 'set':
+            return setProfile(conf, args);
+        default: {
+            throw error('Invalid profile subcommand', {
+                found: sub,
+                validOptions: ['get', 'set'],
+                code: 'EUSAGE',
+            });
+        }
+    }
+};
+const getProfile = async (conf, args) => {
+    const rc = new RegistryClient(conf.options);
+    const registryUrl = new URL(conf.options.registry);
+    const url = new URL('-/npm/v1/user', registryUrl);
+    const response = await rc.request(url, { useCache: false });
+    const data = response.json();
+    const [property] = args;
+    if (property) {
+        if (!(property in data)) {
+            throw error('Property not found in profile', {
+                found: property,
+                validOptions: Object.keys(data),
+                code: 'EUSAGE',
+            });
+        }
+        return { property, value: data[property] };
+    }
+    return data;
+};
+const setProfile = async (conf, args) => {
+    const [property, ...rest] = args;
+    const value = rest.join(' ');
+    if (!property || !value) {
+        throw error('set requires a property name and value', {
+            code: 'EUSAGE',
+        });
+    }
+    const rc = new RegistryClient(conf.options);
+    const registryUrl = new URL(conf.options.registry);
+    const url = new URL('-/npm/v1/user', registryUrl);
+    const response = await rc.request(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ [property]: value }),
+        otp: conf.options.otp,
+        useCache: false,
+    });
+    const data = response.json();
+    return { property, value: data[property] };
+};

package/dist/{esm/commands → commands}/publish.d.ts

@@ -9,7 +9,7 @@ export type CommandResultSingle = {
     shasum?: string;
     integrity?: string;
     size: number;
-    access: string;
+    access?: string;
     unpackedSize: number;
     files: string[];
 };
@@ -19,4 +19,3 @@ export declare const views: {
     readonly json: (r: CommandResult) => CommandResult;
 };
 export declare const command: CommandFn<CommandResult>;
-//# sourceMappingURL=publish.d.ts.map

package/dist/{esm/commands → commands}/publish.js

@@ -1,5 +1,5 @@
 import { error } from '@vltpkg/error-cause';
-import { RegistryClient } from '@vltpkg/registry-client';
+import { RegistryClient, oidc, registryBase, } from '@vltpkg/registry-client';
 import { run } from '@vltpkg/run';
 import { commandUsage } from "../config/usage.js";
 import { packTarball } from "../pack-tarball.js";
@@ -10,6 +10,7 @@ import prettyBytes from 'pretty-bytes';
 import { actual } from '@vltpkg/graph';
 import { Query } from '@vltpkg/query';
 import { createHostContextsMap } from "../query-host-contexts.js";
+import { minimatch } from 'minimatch';
 export const usage = () => commandUsage({
     command: 'publish',
     usage: '',
@@ -35,6 +36,24 @@ export const usage = () => commandUsage({
                     The directory must exist and nothing will be copied to it.`,
             value: '<path>',
         },
+        'dry-run': {
+            description: 'Show what would be published without actually publishing.',
+        },
+        scope: {
+            value: '<query>',
+            description: 'Filter packages to publish using a DSS query selector.',
+        },
+        workspace: {
+            value: '<path|glob>',
+            description: 'Limit publish targets to matching workspaces.',
+        },
+        'workspace-group': {
+            value: '<name>',
+            description: 'Limit publish targets to workspace groups.',
+        },
+        recursive: {
+            description: 'Publish all workspaces in the monorepo.',
+        },
     },
 });
 export const views = {
@@ -102,6 +121,15 @@ export const command = async (conf) => {
     }
     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);
         }
     }
@@ -118,14 +146,26 @@ export const command = async (conf) => {
     }
     return results;
 };
+const getPublishConfig = (manifest) => {
+    const pc = manifest
+        .publishConfig;
+    if (pc && typeof pc === 'object') {
+        return pc;
+    }
+    return undefined;
+};
 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);
     assert(!manifest.private, error('Package has been marked as private'));
-    const { tag = 'latest', access, registry, 'dry-run': dry = false, otp, } = conf.options;
-    const registryUrl = new URL(registry);
+    const { 'dry-run': dry = false, otp } = conf.options;
+    const publishConfig = getPublishConfig(manifest);
+    const tag = publishConfig?.tag ?? conf.options.tag;
+    const access = publishConfig?.access ?? conf.options.access;
+    const registry = publishConfig?.registry ?? conf.options.registry;
+    const registryUrl = new URL(registryBase(registry));
     const runOptions = {
         cwd: manifestDir,
         projectRoot: conf.projectRoot,
@@ -150,7 +190,11 @@ const commandSingle = async (location, conf) => {
         ...runOptions,
         arg0: 'prepare',
     });
-    const { name, version, tarballName, tarballData, unpackedSize, files, integrity, shasum, } = await packTarball(manifest, manifestDir, conf);
+    // 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, tarballName, tarballData, unpackedSize, files, integrity, shasum, resolvedManifest, } = await packTarball(updatedManifest, manifestDir, conf);
     await run({
         ...runOptions,
         arg0: 'postpack',
@@ -162,17 +206,17 @@ const commandSingle = async (location, conf) => {
     const publishMetadata = {
         _id: name,
         name,
-        description: manifest.description || '',
+        description: resolvedManifest.description || '',
         'dist-tags': {
             [tag]: version,
         },
         versions: {
             [version]: {
-                ...manifest,
+                ...resolvedManifest,
                 _id: `${name}@${version}`,
                 _nodeVersion: process.versions.node,
                 dist: {
-                    ...manifest.dist,
+                    ...resolvedManifest.dist,
                     integrity,
                     shasum,
                     tarball: new URL(`${name}/-/${tarballName}`, registryUrl)
@@ -180,7 +224,7 @@ const commandSingle = async (location, conf) => {
                 },
             },
         },
-        access,
+        ...(access ? { access } : {}),
         _attachments: {
             [tarballName]: {
                 content_type: 'application/octet-stream',
@@ -190,6 +234,12 @@ const commandSingle = async (location, conf) => {
         },
     };
     const rc = new RegistryClient(conf.options);
+    // Attempt OIDC token exchange for CI environments (GitHub Actions, GitLab, CircleCI).
+    // This is always optional — failures are silent and won't affect local publishing.
+    await oidc({
+        packageName: name,
+        registry: registryUrl.href,
+    });
     const publishUrl = new URL(name.startsWith('@') ? name.replace('/', '%2F') : name, registryUrl);
     if (!dry) {
         let response;
@@ -213,8 +263,10 @@ const commandSingle = async (location, conf) => {
         }
         if (response.statusCode !== 200 && response.statusCode !== 201) {
             let extraMsg = '';
-            // special case 404 errors to provide a better hint to the user
-            if (response.statusCode === 404) {
+            if (response.statusCode === 409) {
+                extraMsg = `.\n⚠️ ${name}@${version} already exists in the registry. Bump the version and try again.`;
+            }
+            else if (response.statusCode === 404) {
                 extraMsg =
                     ".\n⚠️ Make sure you're logged in and have access to publish the package.";
             }
@@ -233,7 +285,7 @@ const commandSingle = async (location, conf) => {
         name,
         version,
         tag,
-        access,
+        ...(access ? { access } : {}),
         registry: registryUrl.origin,
         integrity,
         shasum,
@@ -242,4 +294,3 @@ const commandSingle = async (location, conf) => {
         files,
     };
 };
-//# sourceMappingURL=publish.js.map

package/dist/{esm/commands → commands}/query.d.ts

@@ -1,5 +1,6 @@
 import { humanReadableOutput, jsonOutput, mermaidOutput } from '@vltpkg/graph';
 import type { HumanReadableOutputGraph, JSONOutputGraph, MermaidOutputGraph } from '@vltpkg/graph';
+import { MermaidImageView } from '../mermaid-image-view.ts';
 import type { CommandFn, CommandUsage } from '../index.ts';
 export declare const usage: CommandUsage;
 type QueryResult = JSONOutputGraph & MermaidOutputGraph & HumanReadableOutputGraph & {
@@ -9,8 +10,9 @@ export declare const views: {
     readonly json: typeof jsonOutput;
     readonly mermaid: typeof mermaidOutput;
     readonly human: typeof humanReadableOutput;
-    readonly gui: ({ queryString }: QueryResult, _: import("../view.ts").ViewOptions, conf: import("../config/index.ts").ParsedConfig) => Promise<void>;
+    readonly count: (result: QueryResult) => number;
+    readonly svg: typeof MermaidImageView;
+    readonly png: typeof MermaidImageView;
 };
 export declare const command: CommandFn<QueryResult>;
 export {};
-//# sourceMappingURL=query.d.ts.map

package/dist/{esm/commands → commands}/query.js

@@ -1,18 +1,18 @@
 import { actual, asNode, humanReadableOutput, jsonOutput, mermaidOutput, GraphModifier, } from '@vltpkg/graph';
 import { error } from '@vltpkg/error-cause';
-import LZString from 'lz-string';
 import { Query } from '@vltpkg/query';
+import { createDiffFilesProvider } from "../query-diff-files.js";
 import { SecurityArchive } from '@vltpkg/security-archive';
-import { startGUI } from "../start-gui.js";
 import { commandUsage } from "../config/usage.js";
 import { createHostContextsMap } from "../query-host-contexts.js";
+import { MermaidImageView } from "../mermaid-image-view.js";
 export const usage = () => commandUsage({
     command: 'query',
     usage: [
         '',
-        '<query> --view=<human | json | mermaid | gui>',
+        '<query> --view=<human | json | mermaid | svg | png | count>',
         '<query> --expect-results=<comparison string>',
-        '--target=<query> --view=<human | json | mermaid | gui>',
+        '--target=<query> --view=<human | json | mermaid | svg | png | count>',
     ],
     description: `List installed dependencies matching the provided query.
 
@@ -68,8 +68,8 @@ export const usage = () => commandUsage({
             description: 'Query selector to filter packages using DSS syntax.',
         },
         view: {
-            value: '[human | json | mermaid | gui]',
-            description: 'Output format. Defaults to human-readable or json if no tty.',
+            value: '[human | json | mermaid | svg | png | count]',
+            description: 'Output format. Defaults to human-readable or json if no tty. Use svg or png to render the dependency graph as an image and open it. Count outputs the number of dependency relationships in the result.',
         },
     },
 });
@@ -96,9 +96,9 @@ export const views = {
     json: jsonOutput,
     mermaid: mermaidOutput,
     human: humanReadableOutput,
-    gui: async ({ queryString }, _, conf) => {
-        await startGUI(conf, `/explore/${LZString.compressToEncodedURIComponent(queryString)}/overview`);
-    },
+    count: (result) => result.edges.length,
+    svg: MermaidImageView,
+    png: MermaidImageView,
 };
 export const command = async (conf) => {
     const modifiers = GraphModifier.maybeLoad(conf.options);
@@ -127,6 +127,7 @@ export const command = async (conf) => {
     const scopeQueryString = conf.get('scope');
     const queryString = targetQueryString || positionalQueryString;
     const hostContexts = await createHostContextsMap(conf);
+    const diffFiles = createDiffFilesProvider(conf.options.projectRoot);
     const importers = new Set();
     const scopeIDs = [];
     // Handle --scope option to add scope nodes as importers
@@ -146,6 +147,7 @@ export const command = async (conf) => {
             importers,
             securityArchive,
             hostContexts,
+            diffFiles,
         });
         const { nodes: resultNodes } = await scopeQuery.search(scopeQueryString, {
             signal: new AbortController().signal,
@@ -185,6 +187,7 @@ export const command = async (conf) => {
         importers: importers_,
         securityArchive,
         hostContexts,
+        diffFiles,
     });
     const query = queryString ||
         (graph ? defaultProjectQueryString : defaultLocalScopeQueryString);
@@ -211,4 +214,3 @@ export const command = async (conf) => {
                 : defaultLocalScopeQueryString),
     };
 };
-//# sourceMappingURL=query.js.map

package/dist/commands/repo.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 {};

package/dist/commands/repo.js

@@ -0,0 +1,157 @@
+import { error } from '@vltpkg/error-cause';
+import { PackageInfoClient } from '@vltpkg/package-info';
+import { Spec } from '@vltpkg/spec';
+import { urlOpen } from '@vltpkg/url-open';
+import { actual } from '@vltpkg/graph';
+import { Query } from '@vltpkg/query';
+import { SecurityArchive } from '@vltpkg/security-archive';
+import { createHostContextsMap } from "../query-host-contexts.js";
+import { commandUsage } from "../config/usage.js";
+import hostedGitInfo from 'hosted-git-info';
+const { fromUrl: hostedGitInfoFromUrl } = hostedGitInfo;
+export const usage = () => commandUsage({
+    command: 'repo',
+    usage: ['[<spec>]', '[--target=<query>]'],
+    description: `Open repository page for a package in a web browser.
+                  Reads repository information from package.json or fetches
+                  manifest data for the specified package.`,
+    options: {
+        target: {
+            value: '<query>',
+            description: 'Query selector to filter packages using DSS syntax.',
+        },
+    },
+    examples: {
+        '': {
+            description: 'Open repo for the current package (reads local package.json)',
+        },
+        'abbrev@2.0.0': {
+            description: 'Open repo for a specific package version',
+        },
+        '--target=":root > *"': {
+            description: 'List repository URLs for all direct dependencies',
+        },
+    },
+});
+export const views = {
+    human: r => {
+        if (Array.isArray(r)) {
+            let msg = 'Multiple package repositories found:\n';
+            msg += r.map(item => `• ${item.name}: ${item.url}`).join('\n');
+            return msg;
+        }
+        return '';
+    },
+    json: r => r,
+};
+const getUrlFromManifest = (manifest) => {
+    const { name, repository, homepage } = manifest;
+    if (!name) {
+        throw error('No package name found');
+    }
+    let url;
+    // Check repository field first
+    if (repository) {
+        const repoUrl = typeof repository === 'string' ? repository
+            : typeof repository === 'object' && 'url' in repository ?
+                repository.url
+                : /* c8 ignore next */ undefined;
+        if (repoUrl) {
+            const info = hostedGitInfoFromUrl(repoUrl.replace(/^git\+/, ''));
+            if (info?.browse && typeof info.browse === 'function') {
+                url = info.browse();
+            }
+            else {
+                // Use the raw URL if hosted-git-info can't parse it
+                url = repoUrl.replace(/^git\+/, '');
+            }
+        }
+    }
+    // Fall back to homepage
+    if (!url && homepage) {
+        url = homepage;
+    }
+    // Fallback to vlt.io package page
+    if (!url) {
+        url = `https://vlt.io/explore/npm/${name}/overview`;
+    }
+    return url;
+};
+export const command = async (conf) => {
+    const { projectRoot, packageJson } = conf.options;
+    const targetOption = conf.get('target');
+    // Handle --target query
+    if (targetOption) {
+        const mainManifest = packageJson.maybeRead(projectRoot);
+        if (!mainManifest) {
+            throw error('No package.json found in project root', {
+                path: projectRoot,
+            });
+        }
+        const graph = actual.load({
+            ...conf.options,
+            mainManifest,
+            monorepo: conf.options.monorepo,
+            loadManifests: true,
+        });
+        const securityArchive = Query.hasSecuritySelectors(targetOption) ?
+            await SecurityArchive.start({
+                nodes: [...graph.nodes.values()],
+            })
+            : undefined;
+        const hostContexts = await createHostContextsMap(conf);
+        const query = new Query({
+            nodes: new Set(graph.nodes.values()),
+            edges: graph.edges,
+            importers: graph.importers,
+            securityArchive,
+            hostContexts,
+        });
+        const { nodes } = await query.search(targetOption, {
+            signal: new AbortController().signal,
+        });
+        const results = [];
+        for (const node of nodes) {
+            if (!node.manifest)
+                continue;
+            const url = getUrlFromManifest(node.manifest);
+            results.push({
+                url,
+                name: node.name /* c8 ignore next */ ?? '(unknown)',
+            });
+        }
+        if (results.length === 0) {
+            throw error('No packages found matching target query', {
+                found: targetOption,
+            });
+        }
+        // If single result, open it
+        if (results.length === 1) {
+            const result = results[0];
+            /* c8 ignore next 3 */
+            if (!result) {
+                throw error('Unexpected empty result');
+            }
+            await urlOpen(result.url);
+            return result;
+        }
+        // Multiple results, return the list
+        return results;
+    }
+    // read the package spec from a positional argument or local package.json
+    const specArg = conf.positionals[0];
+    const manifest = conf.positionals.length === 0 ? packageJson.read(projectRoot)
+        : specArg ?
+            await new PackageInfoClient(conf.options).manifest(Spec.parseArgs(specArg, conf.options))
+            : /* c8 ignore next */ packageJson.read(projectRoot);
+    const url = getUrlFromManifest(manifest);
+    const { name } = manifest;
+    /* c8 ignore start - getUrlFromManifest already validates name */
+    if (!name) {
+        throw error('No package name found');
+    }
+    /* c8 ignore stop */
+    // Open the URL
+    await urlOpen(url);
+    return { url, name };
+};

package/dist/{esm/commands → commands}/run-exec.d.ts

@@ -3,4 +3,3 @@ import type { CommandFn, CommandUsage } from '../index.ts';
 export { views } from '../exec-command.ts';
 export declare const usage: CommandUsage;
 export declare const command: CommandFn<ExecResult>;
-//# sourceMappingURL=run-exec.d.ts.map

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/{esm/commands → commands}/run.d.ts

@@ -3,4 +3,3 @@ import type { CommandFn, CommandUsage } from '../index.ts';
 export { views } from '../exec-command.ts';
 export declare const usage: CommandUsage;
 export declare const command: CommandFn<ExecResult>;
-//# sourceMappingURL=run.d.ts.map

package/dist/{esm/commands → commands}/run.js

@@ -9,6 +9,33 @@ export const usage = () => commandUsage({
                   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) {
@@ -33,4 +60,3 @@ class RunCommand extends ExecCommand {
     }
 }
 export const command = async (conf) => await new RunCommand(conf).run();
-//# sourceMappingURL=run.js.map