@vltpkg/cli-sdk 1.4.0 → 1.6.0

package/dist/allow-skills.d.ts

@@ -0,0 +1,36 @@
+import type { UnmatchedPattern, UnscannedSkills } from '@vltpkg/graph';
+import type { WhichConfig } from '@vltpkg/vlt-json';
+import type { LoadedConfig } from './config/index.ts';
+/** An `allow-skills` query stored in a config file. */
+export type StoredAllowSkills = {
+    query: string;
+    which: WhichConfig;
+};
+/**
+ * Outcome of saving `--allow-skills` after install/update. `stored`
+ * set: another query is stored and was kept.
+ */
+export type AllowSkillsSave = {
+    query: string;
+    stored?: StoredAllowSkills;
+};
+/**
+ * The top-level `allow-skills` of the project vlt.json, else the user
+ * one. A project `null` or `''` drops the user's.
+ */
+export declare const storedAllowSkills: (conf: Pick<LoadedConfig, "layers">) => StoredAllowSkills | undefined;
+/** The file's name in messages. */
+export declare const configLabel: (which: WhichConfig) => string;
+/**
+ * After a successful install/update: save an explicit `--allow-skills`
+ * to the project vlt.json, unless another query is stored.
+ */
+export declare const saveAllowSkills: (conf: LoadedConfig) => Promise<AllowSkillsSave | undefined>;
+/** Warnings for `:skill()` patterns that matched nothing. */
+export declare const unmatchedLines: (unmatched?: UnmatchedPattern[]) => string[];
+/** Skills left out: their packages have no security data. */
+export declare const unscannedLines: ({ unscanned, unscannedReason, }: UnscannedSkills) => string[];
+/** `allow-skills` saved to a config file. */
+export declare const savedLine: (query: string, which: WhichConfig) => string;
+/** `--allow-skills` not saved: another query is stored. */
+export declare const keptLine: (s: StoredAllowSkills) => string;

package/dist/allow-skills.js

@@ -0,0 +1,49 @@
+/**
+ * The top-level `allow-skills` of the project vlt.json, else the user
+ * one. A project `null` or `''` drops the user's.
+ */
+export const storedAllowSkills = (conf) => {
+    const { project, user } = conf.layers;
+    const p = project?.['allow-skills'];
+    if (p)
+        return { query: p, which: 'project' };
+    if (project && 'allow-skills' in project)
+        return undefined;
+    const u = user?.['allow-skills'];
+    return u ? { query: u, which: 'user' } : undefined;
+};
+/** The file's name in messages. */
+export const configLabel = (which) => which === 'user' ? 'user vlt.json' : 'vlt.json';
+/**
+ * After a successful install/update: save an explicit `--allow-skills`
+ * to the project vlt.json, unless another query is stored.
+ */
+export const saveAllowSkills = async (conf) => {
+    const query = conf.explicit['allow-skills'];
+    if (!query || query === ':not(*)')
+        return undefined;
+    const stored = storedAllowSkills(conf);
+    if (stored?.query === query)
+        return undefined;
+    if (stored)
+        return { query, stored };
+    await conf.addConfigToFile('project', { 'allow-skills': query });
+    return { query };
+};
+/** Warnings for `:skill()` patterns that matched nothing. */
+export const unmatchedLines = (unmatched = []) => unmatched.map(({ pattern, skills }) => `⚠️ No skill matches "${pattern}"; ${!skills ? 'no installed package matches its selector'
+    : skills.length ?
+        `the selected packages ship: ${skills.join(', ')}`
+        : 'the selected packages ship no skills'}`);
+/** Skills left out: their packages have no security data. */
+export const unscannedLines = ({ unscanned = [], unscannedReason, }) => unscanned.length ?
+    [
+        `⏳ ${unscanned.length} skill${unscanned.length === 1 ? '' : 's'} left out, ${unscannedReason === 'timeout' ?
+            'security data timed out'
+            : 'Socket has not scanned their packages yet'}: ${unscanned.join(', ')}. Try again later.`,
+    ]
+    : [];
+/** `allow-skills` saved to a config file. */
+export const savedLine = (query, which) => `Saved allow-skills="${query}" to ${configLabel(which)}`;
+/** `--allow-skills` not saved: another query is stored. */
+export const keptLine = (s) => `allow-skills is already set (${configLabel(s.which)}): "${s.query}"; not replaced. Run vlt skills link to change it, or edit ${configLabel(s.which)}`;

package/dist/commands/build.d.ts

@@ -1,8 +1,20 @@
 import type { BuildResult } from '@vltpkg/graph';
+import type { GlobalBins } from '../global.ts';
 import type { CommandFn, CommandUsage } from '../index.ts';
+export type BuildCommandResult = BuildResult & {
+    global?: GlobalBins;
+};
 export declare const views: {
-    readonly human: (result: BuildResult) => string;
-    readonly json: (result: BuildResult) => {
+    readonly human: (result: BuildCommandResult) => string;
+    readonly json: (result: BuildCommandResult) => {
+        global?: GlobalBins | undefined;
+        message: string;
+        skipped?: {
+            id: import("@vltpkg/dep-id").DepID;
+            name: string;
+            version: string | undefined;
+        }[] | undefined;
+        skippedReason?: "timeout" | "unscanned" | undefined;
         success: {
             id: import("@vltpkg/dep-id").DepID;
             name: string;
@@ -13,7 +25,6 @@ export declare const views: {
             name: string;
             version: string | undefined;
         }[];
-        message: string;
     };
 };
 export declare const needsRegistry = true;
@@ -22,4 +33,4 @@ export declare const usage: CommandUsage;
  * Build command implementation. Runs any required "postinstall"
  * lifecycle scripts and binary linking.
  */
-export declare const command: CommandFn<BuildResult>;
+export declare const command: CommandFn<BuildCommandResult>;

package/dist/commands/build.js

@@ -1,40 +1,55 @@
-import { build } from '@vltpkg/graph';
+import { actual, build } from '@vltpkg/graph';
 import { error } from '@vltpkg/error-cause';
 import { commandUsage } from "../config/usage.js";
+import { globalBinsLines, linkGlobalBins } from "../global.js";
+import { resolveGlobalBinDir } from "../global-bin-dir.js";
 import { isErrorWithCause } from '@vltpkg/types';
+const skippedMessage = (count, reason) => `${count} package${count === 1 ? '' : 's'} not built, ${reason === 'unscanned' ?
+    'Socket has not scanned them yet'
+    : 'security data timed out'}. Run "vlt build" again later.`;
 export const views = {
     human: (result) => {
         const successCount = result.success.length;
         const failureCount = result.failure.length;
+        const skippedCount = result.skipped?.length ?? 0;
         const messages = [];
         if (successCount > 0) {
             messages.push(`🔨 Built ${successCount} package${successCount === 1 ? '' : 's'} successfully.`);
         }
-        else {
+        else if (!skippedCount) {
             messages.push('📦 All packages are already built.');
         }
         if (failureCount > 0) {
             messages.push(`🔎 ${failureCount} optional package${ /* c8 ignore next */failureCount === 1 ? '' : 's'} failed to build.`);
         }
+        if (skippedCount > 0) {
+            messages.push(`⏳ ${skippedMessage(skippedCount, result.skippedReason)}`);
+        }
+        if (result.global)
+            messages.push(...globalBinsLines(result.global));
         return messages.join('\n');
     },
     json: (result) => {
-        const successList = result.success.map(node => ({
-            id: node.id,
-            name: node.name,
-            version: node.version,
-        }));
-        const failureList = result.failure.map(node => ({
+        const toJSON = (node) => ({
             id: node.id,
             name: node.name,
             version: node.version,
-        }));
+        });
+        const successList = result.success.map(toJSON);
+        const failureList = result.failure.map(toJSON);
+        const skippedList = result.skipped?.map(toJSON) ?? [];
         return {
             success: successList,
             failure: failureList,
+            ...(skippedList.length ?
+                { skipped: skippedList, skippedReason: result.skippedReason }
+                : {}),
             message: successList.length > 0 ?
                 `Built ${successList.length} package${successList.length === 1 ? '' : 's'}.`
-                : 'No packages needed building.',
+                : skippedList.length ?
+                    skippedMessage(skippedList.length, result.skippedReason)
+                    : 'No packages needed building.',
+            ...(result.global ? { global: result.global } : null),
         };
     },
 };
@@ -58,6 +73,9 @@ export const usage = () => commandUsage({
             value: '<query>',
             description: 'Query selector to filter packages using DSS syntax.',
         },
+        global: {
+            description: 'Build packages installed in the global project.',
+        },
     },
 });
 const isGraphRunError = (error) => typeof error === 'object' &&
@@ -71,6 +89,8 @@ const isGraphRunError = (error) => typeof error === 'object' &&
  */
 export const command = async (conf) => {
     const { options, projectRoot } = conf;
+    const binDir = conf.globalRoot ? await resolveGlobalBinDir(conf) : undefined;
+    let result;
     try {
         // Get target from option or first positional, default to all scripts
         const targetOption = conf.get('target');
@@ -79,7 +99,7 @@ export const command = async (conf) => {
             targetPositional ||
             ':scripts:not(:built):not(:malware)';
         // Run the build process using the graph build function
-        const result = await build({
+        result = await build({
             ...options,
             projectRoot,
             packageJson: options.packageJson,
@@ -87,7 +107,6 @@ export const command = async (conf) => {
             scurry: options.scurry,
             target,
         });
-        return result;
     }
     catch (cause) {
         const graphRunError = isErrorWithCause(cause) && isGraphRunError(cause.cause) ?
@@ -99,4 +118,23 @@ export const command = async (conf) => {
         }
         throw error('Build failed', { cause });
     }
+    if (!binDir)
+        return result;
+    // relink global bins, targets may be new
+    const graph = actual.load({
+        ...options,
+        projectRoot,
+        mainManifest: options.packageJson.read(projectRoot),
+        monorepo: options.monorepo,
+        scurry: options.scurry,
+        loadManifests: true,
+    });
+    const global = await linkGlobalBins(graph, {
+        projectRoot,
+        scurry: options.scurry,
+        force: options.force,
+        binDir,
+        fallback: () => resolveGlobalBinDir(conf, { selfUnwritable: true }),
+    });
+    return { ...result, global };
 };

package/dist/commands/ci.d.ts

@@ -1,11 +1,11 @@
 import type { CommandFn, CommandUsage } from '../index.ts';
 import type { InstallResult } from './install.ts';
-export type CIResult = Pick<InstallResult, 'buildQueue' | 'graph'>;
+export type CIResult = Pick<InstallResult, 'buildQueue' | 'graph' | 'skills'>;
 export declare const needsRegistry = true;
 export declare const needsNpmRegistry = true;
 export declare const usage: CommandUsage;
 export declare const views: {
     readonly json: (i: CIResult) => import("@vltpkg/graph").LockfileData;
-    readonly human: import("../view.ts").LazyView<InstallResult>;
+    readonly human: import("../view.ts").LazyView<Partial<InstallResult>>;
 };
 export declare const command: CommandFn<CIResult>;

package/dist/commands/ci.js

@@ -1,5 +1,6 @@
 import { install } from '@vltpkg/graph';
 import { commandUsage } from "../config/usage.js";
+import { warnIgnoredWorkspaces } from "../migrate-workspaces.js";
 import { lazyView } from "../view.js";
 export const needsRegistry = true;
 export const needsNpmRegistry = true;
@@ -22,6 +23,10 @@ export const usage = () => commandUsage({
             value: '<query>',
             description: 'Filter which packages are allowed to run lifecycle scripts using DSS query syntax.',
         },
+        'allow-skills': {
+            value: '<query>',
+            description: "Link agent skills of packages matching this DSS query into the project's agent skill dirs.",
+        },
         'lockfile-only': {
             description: 'Only update lockfile and package.json files; skip node_modules operations.',
         },
@@ -32,15 +37,18 @@ export const views = {
     human: lazyView(async () => (await import('./install/reporter.ts')).InstallReporter),
 };
 export const command = async (conf) => {
+    warnIgnoredWorkspaces(conf);
     const ciOptions = {
         ...conf.options,
         // same default as install: no scripts
         allowScripts: conf.get('allow-scripts') ?? ':not(*)',
+        allowSkills: conf.get('allow-skills'),
+        skillsDirs: conf.get('skills-dir'),
         expectLockfile: true,
         frozenLockfile: true,
         cleanInstall: true,
         lockfileOnly: conf.options['lockfile-only'],
     };
-    const { buildQueue, graph } = await install(ciOptions);
-    return { buildQueue, graph };
+    const { buildQueue, graph, skills } = await install(ciOptions);
+    return { buildQueue, graph, ...(skills ? { skills } : null) };
 };

package/dist/commands/create.d.ts

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

package/dist/commands/create.js

@@ -1,10 +1,10 @@
 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";
+import { prettyPath } from "../shell.js";
 export { views } from "../exec-command.js";
 export const needsRegistry = true;
 export const usage = () => commandUsage({
@@ -47,8 +47,7 @@ export const usage = () => commandUsage({
         },
     },
 });
-const HOME = homedir();
-export const prettyPath = (path) => path.startsWith(HOME) ? `~${path.substring(HOME.length)}` : path;
+export { prettyPath };
 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)}

package/dist/commands/exec.d.ts

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

package/dist/commands/exec.js

@@ -1,11 +1,11 @@
 import { exec, execFG } from '@vltpkg/run';
 import * as vlx from '@vltpkg/vlx';
-import { homedir } from 'node:os';
 import { env, platform } from 'node:process';
 import { createInterface } from 'node:readline/promises';
 import { commandUsage } from "../config/usage.js";
 import { ExecCommand } from "../exec-command.js";
 import { styleTextStdout } from "../output.js";
+import { prettyPath } from "../shell.js";
 export { views } from "../exec-command.js";
 export const needsRegistry = true;
 export const needsNpmRegistry = true;
@@ -113,8 +113,7 @@ export const usage = () => commandUsage({
         },
     },
 });
-const HOME = homedir();
-export const prettyPath = (path) => path.startsWith(HOME) ? `~${path.substring(HOME.length)}` : path;
+export { prettyPath };
 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)}

package/dist/commands/init.js

@@ -4,7 +4,7 @@ import { minimatch } from 'minimatch';
 import { init } from '@vltpkg/init';
 import { install } from '@vltpkg/graph';
 import { load, save } from '@vltpkg/vlt-json';
-import { assertWSConfig, resolveWSConfig, splitNegatedPatterns, } from '@vltpkg/workspaces';
+import { assertWSConfig, migratableWSConfig, resolveWSConfig, splitNegatedPatterns, } from '@vltpkg/workspaces';
 import { commandUsage } from "../config/usage.js";
 export const usage = () => commandUsage({
     command: 'init',
@@ -57,14 +57,15 @@ export const command = async (conf) => {
     if (conf.values.workspace?.length) {
         // the *effective* config, which may come from the root package.json
         // rather than vlt.json
-        const { config: parsedWSConfig, source } = resolveWSConfig(conf.options.projectRoot, conf.options.packageJson);
+        const resolved = resolveWSConfig(conf.options.projectRoot, conf.options.packageJson);
+        const parsedWSConfig = resolved.config;
         // what gets written back to vlt.json. The raw vlt.json value is
         // reused as-is so its existing shape is preserved. When the
         // definitions live in package.json or pnpm-workspace.yaml instead,
         // seed vlt.json with them first -- otherwise adding a `workspaces`
         // field here would shadow every workspace already declared there.
         const workspacesConfig = load('workspaces', assertWSConfig) ??
-            (source ? Object.values(parsedWSConfig).flat() : undefined);
+            migratableWSConfig(resolved);
         const results = [];
         const addToConfig = [];
         // create a new package.json file for every workspace

package/dist/commands/install/reporter.d.ts

@@ -3,7 +3,7 @@ import type { InstallResult } from '../install.ts';
 export declare class InstallReporter extends ViewClass {
     #private;
     start(): void;
-    done(_result: InstallResult, { time }: {
+    done(_result: Partial<InstallResult>, { time }: {
         time: number;
     }): Promise<undefined>;
     error(err: unknown): void;

package/dist/commands/install/reporter.js

@@ -4,7 +4,11 @@ import Spinner from 'ink-spinner';
 import { createElement as $, Fragment, useEffect, useState, } from 'react';
 import { ViewClass } from "../../view.js";
 import { asError } from '@vltpkg/types';
+import { isSelfUpdateArgs, selfUpdateLines, } from "../../self-update.js";
 import { persistedEntries } from "../../persist-spec-config.js";
+import { keptLine, savedLine, unmatchedLines, unscannedLines, } from "../../allow-skills.js";
+import { globalBinsLines } from "../../global.js";
+import { offerPathSetup } from "../../shell-setup/index.js";
 const labels = {
     build: 'resolving dependencies',
     actual: '',
@@ -74,26 +78,108 @@ const App = ({ trailer }) => {
 };
 export class InstallReporter extends ViewClass {
     #instance = null;
+    #plain = false;
     start() {
+        // Ink measures the terminal on every render, and when stdout has no
+        // width (a pipe, a CI log) it does so by spawning `tput cols` and
+        // `tput lines`: thousands of processes over one install. Give a
+        // non-TTY stdout the width Ink would fall back to anyway, so the
+        // output is the same and nothing is spawned.
+        if (!process.stdout.isTTY) {
+            // only a sane COLUMNS counts; -1 or Infinity would be truthy
+            const cols = Number(process.env.COLUMNS);
+            process.stdout.columns ||=
+                Number.isInteger(cols) && cols > 0 ? cols : 80;
+        }
+        // npm may write to the terminal: no live view
+        if (isSelfUpdateArgs(this.config)) {
+            this.#plain = true;
+            return;
+        }
         this.#instance = render($(App));
     }
     async done(_result, { time }) {
-        let out = `Done in ${time}ms`;
+        const { self } = _result;
+        let out = self && !_result.graph ? '' : `Done in ${time}ms`;
         // prints a very complete message explaining users the next steps
         // in case there are packages to be built
+        const g = _result.global ? ' -g' : '';
         if (_result.buildQueue?.length) {
             out += `\n\n📦 ${_result.buildQueue.length} packages have install scripts defined & were not fully built\n`;
-            out += '🔎 Run `vlt query :scripts` to list them\n';
-            out +=
-                '🔨 Run `vlt build` to run all required scripts to build installed packages.\n';
+            out += `🔎 Run \`vlt query${g} :scripts\` to list them\n`;
+            out += `🔨 Run \`vlt build${g}\` to run all required scripts to build installed packages.\n`;
+        }
+        if (self) {
+            for (const l of selfUpdateLines(self))
+                out += out ? `\n${l}` : l;
+        }
+        if (_result.global) {
+            // the self-update line says why
+            const bins = self?.status === 'updated' && self.case === 'bootstrap' ?
+                { ..._result.global, notWritable: undefined }
+                : _result.global;
+            for (const l of globalBinsLines(bins))
+                out += `\n${l}`;
+        }
+        const { linked = [], removed = [], conflicts = [], skipped = [], gitignore = [], unmatched = [], } = _result.skills ?? {};
+        const s = (n) => (n === 1 ? '' : 's');
+        const skills = [];
+        if (linked.length) {
+            // one per skill, linked in any number of dirs
+            const n = new Set(linked.map(r => `${r.id}\0${r.skill}`)).size;
+            const dirs = [...new Set(linked.map(r => r.dir))].join(', ');
+            skills.push(`🔗 Linked ${n} agent skill${s(n)} into ${dirs}`);
+        }
+        if (removed.length) {
+            skills.push(`🧹 Removed ${removed.length} stale skill link${s(removed.length)}: ${removed.join(', ')}`);
         }
+        if (conflicts.length) {
+            skills.push(`⚠️ ${conflicts.length} skill link${s(conflicts.length)} skipped, path in use or taken by another package: ${conflicts.join(', ')}`);
+        }
+        skills.push(...unmatchedLines(unmatched));
+        if (skipped.length) {
+            skills.push(`⚠️ Skipped ${skipped.join(', ')}`);
+        }
+        if (gitignore.length) {
+            skills.push(`⚠️ Could not update ${gitignore.join(', ')}`);
+        }
+        skills.push(...unscannedLines(_result.skills ?? {}));
+        if (skills.length)
+            out += `\n${skills.join('\n')}\n`;
         const saved = _result.persistedConfig;
         if (saved) {
             for (const e of persistedEntries(saved.values)) {
                 out += `\nSaved ${e} to ${saved.which} vlt.json`;
             }
         }
-        this.#instance?.rerender($(App, { trailer: out }));
+        const migrated = _result.migratedWorkspaces;
+        if (migrated) {
+            out += `\nSaved workspaces from ${migrated.source} to vlt.json`;
+        }
+        const a = _result.allowSkills;
+        if (a?.stored)
+            out += `\n${keptLine(a.stored)}`;
+        else if (a)
+            out += `\n${savedLine(a.query, 'project')}`;
+        // failed: npm already said why
+        if (!out)
+            return undefined;
+        if (this.#plain)
+            this.#instance = render($(Text, null, out));
+        else
+            this.#instance?.rerender($(App, { trailer: out }));
+        if (_result.global) {
+            await offerPathSetup(_result.global, {
+                globalDir: this.config.projectRoot,
+                yes: !!this.config.get('yes'),
+                noModifyPath: !!this.config.get('no-modify-path'),
+                // ink owns the terminal until unmounted
+                beforeOutput: () => {
+                    this.#instance?.unmount();
+                    this.#instance = null;
+                },
+            });
+        }
         return undefined;
     }
     error(err) {

package/dist/commands/install.d.ts

@@ -1,6 +1,10 @@
+import type { AllowSkillsSave } from '../allow-skills.ts';
+import type { GlobalBins } from '../global.ts';
+import type { SelfUpdate } from '../self-update.ts';
+import type { MigratedWorkspaces } from '../migrate-workspaces.ts';
 import type { SpecConfigPersistPlan } from '../persist-spec-config.ts';
 import type { DepID } from '@vltpkg/dep-id';
-import type { Diff, Graph } from '@vltpkg/graph';
+import type { Diff, Graph, LinkSkillsResult } from '@vltpkg/graph';
 import type { CommandFn, CommandUsage } from '../index.ts';
 /**
  * The resulting object of an install operation. To be used by the view impl.
@@ -22,12 +26,54 @@ export type InstallResult = {
      * Spec config from the cli / env that was saved to a config file.
      */
     persistedConfig?: SpecConfigPersistPlan;
+    /**
+     * Workspaces saved to vlt.json from package.json or pnpm-workspace.yaml.
+     */
+    migratedWorkspaces?: MigratedWorkspaces;
+    /**
+     * Agent skill links added or removed.
+     */
+    skills?: LinkSkillsResult;
+    /**
+     * `--allow-skills` saved to vlt.json, or kept because another query
+     * is stored.
+     */
+    allowSkills?: AllowSkillsSave;
+    /**
+     * Bins linked by a `--global` install.
+     */
+    global?: GlobalBins;
+    /**
+     * `vlt install -g vlt`
+     */
+    self?: SelfUpdate;
+};
+/** self-update handed off or nothing to do */
+export type InstallCommandResult = InstallResult | {
+    self: SelfUpdate;
 };
 export declare const needsRegistry = true;
 export declare const needsNpmRegistry = true;
 export declare const usage: CommandUsage;
 export declare const views: {
-    readonly json: (i: InstallResult) => {
+    readonly json: (i: InstallCommandResult) => {
+        self: SelfUpdate;
+    } | {
+        self?: SelfUpdate | undefined;
+        global?: GlobalBins | undefined;
+        allowSkills?: AllowSkillsSave | undefined;
+        skills?: {
+            unscanned?: string[];
+            unscannedReason?: "timeout" | "unscanned";
+            removed: string[];
+            conflicts: string[];
+            dirs: string[];
+            skipped?: string[];
+            gitignore?: string[];
+            unmatched?: import("@vltpkg/graph").UnmatchedPattern[];
+            linked: string[];
+        } | undefined;
+        migratedWorkspaces?: MigratedWorkspaces | undefined;
         persistedConfig?: SpecConfigPersistPlan | undefined;
         buildQueue?: DepID[] | undefined;
         message?: string | undefined;
@@ -48,6 +94,6 @@ export declare const views: {
         }[];
         removed: number;
     };
-    readonly human: import("../view.ts").LazyView<InstallResult>;
+    readonly human: import("../view.ts").LazyView<Partial<InstallResult>>;
 };
-export declare const command: CommandFn<InstallResult>;
+export declare const command: CommandFn<InstallCommandResult>;