@detergent-software/atk 9.2.0-dev.4 → 9.2.0-dev.6

package/build/commands/install.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, Text, useApp } from 'ink';
-import { useCallback, useEffect, useRef, useState } from 'react';
+import { Fragment, useCallback, useEffect, useRef, useState } from 'react';
 import { z } from 'zod';
 import { CrossScopeWarning, DryRunBanner, ErrorView, InstallSummary, MultiSelectList, Spinner, } from '../components/index.js';
 import { useCommand } from '../hooks/useCommand.js';
@@ -11,6 +11,7 @@ import { loadConfig } from '../lib/config.js';
 import { crossScopeNotice, findCrossScopeInstalls } from '../lib/cross-scope.js';
 import { errorGuidance, errorMessage } from '../lib/errors.js';
 import { isInstalledForTool } from '../lib/installed-for-tool.js';
+import { InstallerError } from '../lib/installer.js';
 import { addAssetToLockfile, findInstalledAsset, identityKey, readLockfile, upgradeToDirectInstall, withLockfileErrorHandling, writeLockfile, } from '../lib/lockfile.js';
 import { executeInstallPlanForTools, withoutKeptDependencies } from '../lib/multi-tool-install.js';
 import { addNotice } from '../lib/notices.js';
@@ -18,7 +19,7 @@ import { formatOrgName, isBareOrgScope, parseBundleSpec, resolveActiveOrg } from
 import { renderJson, useNonInteractive } from '../lib/output.js';
 import { argument, option } from '../lib/pastel/index.js';
 import { fetchRegistry, findAsset, findAssetsByName, findBundle, findBundleMember, getAssetsByOrg, isDeprecated, isLatestAlias, } from '../lib/registry.js';
-import { resolveBundleInstallPlan, resolveInstallPlan, resolveMultipleInstallPlans, ResolverError, } from '../lib/resolver.js';
+import { resolveBundleInstallPlan, resolveInstallPlan, resolveMultipleInstallPlans, ResolverError, resolveTargetsInstallPlan, } from '../lib/resolver.js';
 import { scopeLabel } from '../lib/scope.js';
 import { resolvePlacingTools } from '../lib/tool-resolver.js';
 import { parseNameVersion } from '../lib/version.js';
@@ -36,7 +37,7 @@ export const options = z.object({
         .default(false)
         .describe(option({
         alias: 'a',
-        description: 'Install every asset from an org scope without prompting (for `atk install @org`; required with --json or no terminal)',
+        description: 'Install every asset from an org scope without prompting (for `atk install @org`; required with --json, no terminal, or other names)',
     })),
     dryRun: z
         .boolean()
@@ -108,7 +109,8 @@ export const options = z.object({
         description: 'Alias for --all: install every asset from an org scope without prompting',
     })),
 });
-export const args = z.tuple([
+export const args = z
+    .tuple([
     z
         .string()
         .optional()
@@ -116,12 +118,19 @@ export const args = z.tuple([
         description: 'Asset, bundle, or org scope to install (supports name@version and @org)',
         name: 'target',
     })),
-]);
-export default function Install({ args: [rawName], options: { adopt, all, dryRun, force, json, org, pin, projectRoot, refresh, tool, user, yes }, }) {
+])
+    .rest(z.string().describe(argument({
+    description: 'More assets, bundles or org scopes to install with the first, as one plan (name@version, @org/name, @org with --all)',
+    name: 'targets',
+})));
+export default function Install({ args: [rawName, ...more], options: { adopt, all, dryRun, force, json, org, pin, projectRoot, refresh, tool, user, yes }, }) {
     // No argument provided — delegate to sync behavior
     if (!rawName) {
         return _jsx(Sync, { options: { dryRun, force, json, projectRoot, refresh, tool, user } });
     }
+    if (more.length > 0) {
+        return (_jsx(InstallAssets, { adopt: adopt, all: all || yes, dryRun: dryRun, force: force, json: json, org: org, pin: pin, projectRoot: projectRoot, specs: [rawName, ...more], tool: tool, user: user }));
+    }
     if (isBareOrgScope(rawName)) {
         const orgName = rawName.slice(1);
         return (_jsx(InstallOrg, { cliOrg: org, dryRun: dryRun, force: force, json: json, orgName: orgName, pin: pin, projectRoot: projectRoot, skipPicker: all || yes, tool: tool, user: user }));
@@ -265,16 +274,8 @@ function InstallAsset({ adopt, dryRun, force, json, org: cliOrg, pin, projectRoo
         // through to a misleading "asset not found".
         if (!indexBundle && (registry.bundles ?? []).some((b) => b.name === name)) {
             const assetExists = findAsset(registry, name, undefined, undefined, org);
-            if (!assetExists) {
-                if (inlineOrg) {
-                    throw new Error(`Bundle '${name}' not found in org '${inlineOrg}'.`);
-                }
-                const orgScopes = (registry.bundles ?? [])
-                    .filter((b) => b.name === name && b.org)
-                    .map((b) => `@${b.org}/${name}`);
-                throw new Error(`Bundle '${name}' not found in the registry.` +
-                    (orgScopes.length > 0 ? ` Did you mean ${orgScopes.join(' or ')}?` : ''));
-            }
+            if (!assetExists)
+                throw otherScopeBundleError(registry, name, inlineOrg);
         }
         // With no active org, `info` opens the only org asset of a bare name, but install doesn't
         // switch scopes on its own: it names the spec that installs that asset.
@@ -352,26 +353,7 @@ function InstallAsset({ adopt, dryRun, force, json, org: cliOrg, pin, projectRoo
                 };
                 // Bundle installation flow — check if already installed for ALL tools
                 if (!force) {
-                    const bundleAssets = bundle.assets ?? [];
-                    // When no configured tool takes any member, fall through so the installer says why.
-                    const allInstalledForAllTools = tools.every(({ adapter: toolAdapter }) => members.length > 0 &&
-                        bundleAssets.every((ref) => {
-                            const found = findBundleMember(registry, bundle, ref);
-                            if (!found)
-                                return false;
-                            // A tool that doesn't take this member (its type, or a hook for other tools) has
-                            // nothing to check.
-                            if (!placesAsset(toolAdapter, found.asset.type, found.versionData.tools))
-                                return true;
-                            const installed = findInstalledAsset(before, ref.name, ref.type, found.asset.org);
-                            if (!installed)
-                                return false;
-                            if (requiredBundleVersion && !isFromBundleVersion(installed, bundle, requiredBundleVersion)) {
-                                return false;
-                            }
-                            return isInstalledForTool(installed, toolAdapter, projectDir);
-                        }));
-                    if (allInstalledForAllTools) {
+                    if (isBundleInPlace(registry, bundle, before, { members, projectDir, requiredBundleVersion, tools })) {
                         // Adopting a bundle that is in place only records its origin on the members with none:
                         // their files, versions and pins stay as they are. Another bundle's member stays its.
                         const outside = membersOutsideBundle(before, members, bundle);
@@ -502,16 +484,302 @@ function InstallAsset({ adopt, dryRun, force, json, org: cliOrg, pin, projectRoo
         return (_jsxs(Box, { flexDirection: 'column', children: [_jsxs(Text, { color: 'green', children: ["\u2713 ", _jsx(Text, { bold: true, children: data.name }), " (v", data.version, ") is now a direct install", where, "."] }), _jsx(Text, { dimColor: true, children: "It will no longer be auto-removed when its parent is uninstalled." })] }));
     }
     if (data.outcome === 'dry-run-install') {
-        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'install', count: data.plan.totalCount, tools: data.tools, where: label }), _jsx(Text, { children: " " }), data.plan.entries.map((entry) => (_jsxs(Text, { children: ['  ', entry.reason === 'dependency' ? (_jsxs(Text, { color: 'cyan', children: [formatOrgName(entry.asset.org, entry.asset.name), ' ', _jsxs(Text, { dimColor: true, children: ["(", entry.asset.type, ") v", entry.version, " \u2014 dependency"] })] })) : (_jsxs(Text, { children: [_jsx(Text, { bold: true, children: formatOrgName(entry.asset.org, entry.asset.name) }), _jsxs(Text, { dimColor: true, children: [' ', "(", entry.asset.type, ") v", entry.version] })] }))] }, identityKey(entry.asset)))), _jsx(CrossScopeWarning, { installs: data.crossScope ?? [] })] }));
+        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'install', count: data.plan.totalCount, tools: data.tools, where: label }), _jsx(Text, { children: " " }), _jsx(PlanEntryLines, { plan: data.plan }), _jsx(CrossScopeWarning, { installs: data.crossScope ?? [] })] }));
     }
     if (data.outcome === 'dry-run-bundle') {
-        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'install', count: data.plan.totalCount, tools: data.tools, where: label }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsxs(Text, { bold: true, color: 'magenta', children: ["Bundle: ", data.bundleName] }), _jsxs(Text, { dimColor: true, children: [" v", data.version] })] }), _jsx(Text, { children: " " }), data.plan.entries.map((entry) => (_jsxs(Text, { children: ['  ', entry.reason === 'dependency' ? (_jsxs(Text, { color: 'cyan', children: [formatOrgName(entry.asset.org, entry.asset.name), ' ', _jsxs(Text, { dimColor: true, children: ["(", entry.asset.type, ") v", entry.version, " \u2014 dependency"] })] })) : (_jsxs(Text, { children: [_jsx(Text, { bold: true, children: formatOrgName(entry.asset.org, entry.asset.name) }), _jsxs(Text, { dimColor: true, children: [' ', "(", entry.asset.type, ") v", entry.version] })] }))] }, identityKey(entry.asset)))), _jsx(BundleReportLines, { bundleName: data.bundleName, dryRun: true, report: data }), _jsx(CrossScopeWarning, { installs: data.crossScope ?? [] })] }));
+        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'install', count: data.plan.totalCount, tools: data.tools, where: label }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsxs(Text, { bold: true, color: 'magenta', children: ["Bundle: ", data.bundleName] }), _jsxs(Text, { dimColor: true, children: [" v", data.version] })] }), _jsx(Text, { children: " " }), _jsx(PlanEntryLines, { plan: data.plan }), _jsx(BundleReportLines, { bundleName: data.bundleName, dryRun: true, report: data }), _jsx(CrossScopeWarning, { installs: data.crossScope ?? [] })] }));
     }
     if (data.outcome === 'deprecated') {
         return (_jsxs(Box, { flexDirection: 'column', children: [_jsxs(Text, { color: 'yellow', children: ["Warning: \"", data.name, "\" is deprecated \u2014 ", data.reason] }), data.replacement && (_jsxs(Text, { children: ["Consider using", ' ', _jsx(Text, { bold: true, color: 'cyan', children: data.replacement }), ' ', "instead."] })), _jsx(Text, { dimColor: true, children: "Use --force to install anyway." })] }));
     }
     return (_jsxs(Box, { flexDirection: 'column', children: [data.toolResults.map(({ results, skipped, tool: toolName, warnings }) => (_jsx(InstallSummary, { results: results, skipped: skipped, tools: [toolName], warnings: warnings, where: label }, toolName))), _jsx(CrossScopeWarning, { installs: data.crossScope ?? [] })] }));
 }
+/**
+ * `atk install a b@1.2.0 @org/c my-bundle @org --all`: the named assets, the bundles' members and
+ * the orgs' assets resolved together (shared dependencies once, one version per asset) and
+ * installed as one plan, so a failure rolls the whole run back, as an `@org` install does. Every
+ * name is checked before anything is written. An asset already in place for every tool is left out
+ * of the plan, and one installed only as a dependency becomes direct once the install succeeds. A
+ * bundle is left out when all of it is in place, as when it is installed alone; its members get
+ * its origin unless they are named themselves ({@link resolveTargetsInstallPlan}).
+ */
+function InstallAssets({ adopt, all, dryRun, force, json, org: cliOrg, pin, projectRoot, specs, tool, user, }) {
+    const { json: effectiveJson } = useNonInteractive(json);
+    const { fields, resolve, resolved } = useResolvedScope({ projectRoot, user });
+    const state = useCommand(async (progress) => {
+        const flags = { dryRun, force, pin, projectRoot, tool, user };
+        if (adopt) {
+            throw new Error('--adopt records a bundle as the owner of its members, so it works with one bundle only.');
+        }
+        // No picker opens halfway through a run, so an org among names takes all its assets, and
+        // only when asked to. A dry run shows them all, as `atk install @org --dry-run` does.
+        const orgScopes = [...new Set(specs.filter(isBareOrgScope))];
+        if (orgScopes.length > 0 && !all && !dryRun) {
+            throw new InstallerError(`${orgScopes.join(', ')} among other names installs every asset in ` +
+                `${orgScopes.length === 1 ? 'it' : 'them'}, so it needs --all (-a). ` +
+                `To choose ${orgScopes.length === 1 ? 'its' : 'their'} assets, install ${orgScopes.length === 1 ? 'it' : 'each'} alone.`, { code: 'selection_required', command: installCommandFor(`${specs.join(' ')} --all`, flags) });
+        }
+        const { root: projectDir, scope: installScope } = await resolve();
+        progress('Loading configuration...');
+        const config = await loadConfig();
+        const tools = await resolvePlacingTools(tool, projectDir);
+        const toolNames = tools.map((t) => t.tool);
+        progress('Fetching registry...');
+        const registry = await fetchRegistry({ force: true });
+        const currentLockfile = await readLockfile(projectDir);
+        // Every name is checked before anything is resolved or written. The targets keep the order
+        // they were named in, which decides the origin of a member two bundles share.
+        const deprecated = [];
+        const emptyOrgs = [];
+        const orgs = [];
+        const targets = [];
+        const deprecationOf = (name, deprecation) => {
+            if (deprecation.deprecated && !force) {
+                deprecated.push(`"${name}" (${deprecation.reason}${deprecation.replacement ? `; use ${deprecation.replacement}` : ''})`);
+            }
+        };
+        for (const spec of new Set(specs)) {
+            if (isBareOrgScope(spec)) {
+                const orgName = spec.slice(1);
+                const orgAssets = getAssetsByOrg(registry, orgName);
+                if (orgAssets.length === 0)
+                    emptyOrgs.push(spec);
+                orgs.push({ count: orgAssets.length, org: orgName });
+                for (const { name, type } of orgAssets) {
+                    targets.push({
+                        fromOrg: true,
+                        kind: 'asset',
+                        name,
+                        org: orgName,
+                        spec: formatOrgName(orgName, name),
+                        type,
+                    });
+                }
+                continue;
+            }
+            const { name: parsedName, version } = parseNameVersion(spec);
+            const { name: nameFromOrg, org: inlineOrg } = parseBundleSpec(parsedName);
+            const name = inlineOrg ? nameFromOrg : parsedName;
+            const org = resolveActiveOrg(inlineOrg ?? cliOrg, currentLockfile.org, config.org);
+            const indexBundle = findBundle(registry, name, inlineOrg);
+            if (indexBundle) {
+                const bundle = await bundleAtRequestedVersion(indexBundle, version, progress);
+                const earlier = targets.find((t) => t.kind === 'bundle' && t.bundle.name === name && t.bundle.org === indexBundle.org);
+                if (earlier) {
+                    // A bundle installs at one version, as an asset does.
+                    if (earlier.bundle.version !== bundle.version) {
+                        throw new ResolverError(`Bundle "${formatOrgName(bundle.org, name)}" is named at two versions: ${earlier.bundle.version} ` +
+                            `(${earlier.spec}) and ${bundle.version} (${spec}). A bundle installs at one version.`);
+                    }
+                    continue;
+                }
+                deprecationOf(name, isDeprecated(registry, name, undefined, indexBundle.org));
+                targets.push({ bundle, kind: 'bundle', spec, ...(version ? { version } : {}) });
+                continue;
+            }
+            const asset = findAsset(registry, name, undefined, undefined, org)?.asset;
+            if (!asset && (registry.bundles ?? []).some((b) => b.name === name)) {
+                throw otherScopeBundleError(registry, name, inlineOrg);
+            }
+            deprecationOf(name, isDeprecated(registry, name, asset?.type, asset ? asset.org : inlineOrg));
+            targets.push({ kind: 'asset', name, ...(org ? { org } : {}), spec, ...(version ? { version } : {}) });
+        }
+        if (emptyOrgs.length > 0) {
+            throw new ResolverError(`No assets found for ${emptyOrgs.join(', ')}. Nothing was installed.`);
+        }
+        if (deprecated.length > 0) {
+            throw new ResolverError(`Deprecated: ${deprecated.join(', ')}. Nothing was installed.`, {
+                hint: 'Use --force to install them anyway.',
+            });
+        }
+        // A name every targeted tool already has in place is left out of the plan, as it is for one name.
+        const assets = [];
+        const bundles = [];
+        const upgrades = [];
+        const toInstall = [];
+        const adoptCommandFor = ({ bundle, version }) => installCommandFor(formatOrgName(bundle.org, bundle.name) + (version ? `@${version}` : ''), {
+            adopt: true,
+            force: false,
+            pin: false,
+            projectRoot,
+            tool,
+            user,
+        });
+        for (const request of targets) {
+            if (request.kind === 'bundle') {
+                const { bundle, version } = request;
+                const members = bundleMembers(registry, bundle, tools);
+                const requiredBundleVersion = version && !isLatestAlias(version) ? bundle.version : undefined;
+                if (force ||
+                    !isBundleInPlace(registry, bundle, currentLockfile, { members, projectDir, requiredBundleVersion, tools })) {
+                    toInstall.push(request);
+                    continue;
+                }
+                bundles.push({
+                    name: bundle.name,
+                    ...(bundle.org ? { org: bundle.org } : {}),
+                    outcome: 'already-installed',
+                    version: bundle.version,
+                    ...bundleReport(membersOutsideBundle(currentLockfile, members, bundle), [], {
+                        adoptCommand: adoptCommandFor(request),
+                        bundle,
+                    }),
+                });
+                continue;
+            }
+            const match = findAsset(registry, request.name, request.type, request.version, request.org);
+            const existing = match
+                ? findInstalledAsset(currentLockfile, request.name, match.asset.type, match.asset.org)
+                : undefined;
+            const supportingTools = existing && match ? tools.filter((t) => placesAsset(t.adapter, existing.type, match.versionData.tools)) : [];
+            const inPlace = !force &&
+                existing !== undefined &&
+                supportingTools.length > 0 &&
+                supportingTools.every((t) => isInstalledForTool(existing, t.adapter, projectDir)) &&
+                (!request.version || request.version === existing.version);
+            if (!inPlace) {
+                toInstall.push(request);
+                continue;
+            }
+            if (assets.some((a) => identityKey(a) === identityKey(existing)))
+                continue;
+            const dependency = (existing.installReason ?? 'direct') === 'dependency';
+            if (dependency)
+                upgrades.push(existing);
+            assets.push({
+                name: existing.name,
+                ...(existing.org ? { org: existing.org } : {}),
+                outcome: dependency ? 'upgraded-to-direct' : 'already-installed',
+                type: existing.type,
+                version: existing.version,
+            });
+        }
+        progress('Resolving dependencies...');
+        const plan = resolveTargetsInstallPlan(registry, toInstall.map((request) => request.kind === 'bundle'
+            ? { bundle: request.bundle, kind: 'bundle' }
+            : {
+                ...(request.fromOrg ? { fromOrg: true } : {}),
+                kind: 'asset',
+                name: request.name,
+                ...(request.org ? { org: request.org } : {}),
+                ...(request.type ? { type: request.type } : {}),
+                ...(request.version ? { version: request.version } : {}),
+            }));
+        // The named and the org's assets the plan installs, in plan order.
+        const requested = new Set(toInstall.flatMap((request) => {
+            if (request.kind === 'bundle')
+                return [];
+            const match = findAsset(registry, request.name, request.type, request.version, request.org);
+            return match ? [identityKey(match.asset)] : [];
+        }));
+        const installed = plan.entries
+            .filter((entry) => entry.reason === 'direct' && requested.has(identityKey(entry.asset)))
+            .map((entry) => ({
+            name: entry.asset.name,
+            ...(entry.asset.org ? { org: entry.asset.org } : {}),
+            outcome: 'installed',
+            type: entry.asset.type,
+            version: entry.version,
+        }));
+        const report = [...installed, ...assets];
+        const crossScope = (resolvedPlan, installedAt) => crossScopeOf(resolvedPlan, { installedAt, json: effectiveJson, scope: installScope, tools: toolNames });
+        // Each bundle in the plan, in the order named, then the ones left out; and the orgs.
+        const targetsField = (lockfile, planned) => {
+            const installedBundles = toInstall.flatMap((request) => {
+                if (request.kind !== 'bundle')
+                    return [];
+                const { bundle } = request;
+                const members = bundleMembers(registry, bundle, tools);
+                // A dry run writes nothing, so the members it leaves outside the bundle are read from the plan.
+                const kept = [
+                    ...membersOutsideBundle(lockfile, members, bundle),
+                    ...(planned ? plannedOutsideBundle(plan, lockfile, members, bundle) : []),
+                ];
+                return [
+                    {
+                        name: bundle.name,
+                        ...(bundle.org ? { org: bundle.org } : {}),
+                        outcome: 'installed',
+                        version: bundle.version,
+                        ...bundleReport(kept, [], { adoptCommand: adoptCommandFor(request), bundle }),
+                    },
+                ];
+            });
+            const named = [...installedBundles, ...bundles];
+            return { ...(named.length > 0 ? { bundles: named } : {}), ...(orgs.length > 0 ? { orgs } : {}) };
+        };
+        // A dry run says so even when every name is in place, and writes nothing (not even an upgrade).
+        if (dryRun) {
+            return {
+                assets: report,
+                ...targetsField(currentLockfile, true),
+                outcome: 'dry-run-install',
+                plan: withoutKeptDependencies(plan, currentLockfile, tools, {
+                    onProgress: progress,
+                    projectDir,
+                    scope: installScope,
+                }),
+                tools: toolNames,
+                ...(await crossScope(plan)),
+            };
+        }
+        return await withLockfileErrorHandling(projectDir, async () => {
+            const toolResults = plan.entries.length > 0
+                ? await executeInstallPlanForTools(plan, tools, {
+                    force,
+                    onProgress: progress,
+                    onTool: (toolName) => progress(`Installing for ${toolName}...`),
+                    pin,
+                    projectDir,
+                    scope: installScope,
+                })
+                : [];
+            // After the install, so a failed one leaves even the install reasons as they were.
+            if (upgrades.length > 0) {
+                let lockfile = await readLockfile(projectDir);
+                for (const { name, org, type } of upgrades)
+                    lockfile = upgradeToDirectInstall(lockfile, name, type, org);
+                await writeLockfile(projectDir, lockfile);
+            }
+            if (plan.entries.length === 0) {
+                return { assets: report, ...targetsField(currentLockfile, false), outcome: 'already-installed' };
+            }
+            return {
+                assets: report,
+                ...targetsField(await readLockfile(projectDir), false),
+                outcome: 'installed',
+                toolResults,
+                ...(await crossScope(plan, projectDir)),
+            };
+        });
+    }, [adopt, all, cliOrg, dryRun, force, pin, specs.join(' '), tool]);
+    if (state.status === 'loading') {
+        return _jsx(Spinner, { message: state.message });
+    }
+    if (state.status === 'error') {
+        if (effectiveJson) {
+            return renderJson({
+                ...(state.code ? { code: state.code } : {}),
+                ...(state.command ? { command: state.command } : {}),
+                ...(state.hint ? { hint: state.hint } : {}),
+                message: state.message,
+                outcome: 'error',
+                ...fields,
+            });
+        }
+        return _jsx(ErrorView, { command: state.command, hint: state.hint, message: state.message });
+    }
+    const { data } = state;
+    const label = resolved && scopeLabel(resolved);
+    if (effectiveJson) {
+        return renderJson({ ...data, ...fields });
+    }
+    if (data.outcome === 'dry-run-install') {
+        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'install', count: data.plan.totalCount, tools: data.tools, where: label }), _jsx(Text, { children: " " }), _jsx(PlanEntryLines, { plan: data.plan }), _jsx(NamedAssetLines, { assets: data.assets, dryRun: true, where: label }), _jsx(TargetLines, { bundles: data.bundles, dryRun: true, orgs: data.orgs, where: label }), _jsx(CrossScopeWarning, { installs: data.crossScope ?? [] })] }));
+    }
+    return (_jsxs(Box, { flexDirection: 'column', children: [data.outcome === 'installed' &&
+                data.toolResults.map(({ results, skipped, tool: toolName, warnings }) => (_jsx(InstallSummary, { results: results, skipped: skipped, tools: [toolName], warnings: warnings, where: label }, toolName))), _jsx(NamedAssetLines, { assets: data.assets, where: label }), _jsx(TargetLines, { bundles: data.bundles, orgs: data.orgs, where: label }), data.outcome === 'installed' && _jsx(CrossScopeWarning, { installs: data.crossScope ?? [] })] }));
+}
 /** `atk install <spec>` with the run's own flags, for a command an error suggests. */
 function installCommandFor(spec, { adopt, dryRun, force, pin, projectRoot, tool, user }) {
     return [
@@ -758,7 +1026,7 @@ function InstallOrg({ cliOrg, dryRun, force, json, orgName, pin, projectRoot, sk
                 ...fields,
             });
         }
-        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'install', count: state.plan.totalCount, tools: state.tools, where: label }), _jsx(Text, { children: " " }), _jsx(Text, { children: _jsxs(Text, { bold: true, color: 'magenta', children: ["Org: @", orgName] }) }), _jsx(Text, { children: " " }), state.plan.entries.map((entry) => (_jsxs(Text, { children: ['  ', entry.reason === 'dependency' ? (_jsxs(Text, { color: 'cyan', children: [formatOrgName(entry.asset.org, entry.asset.name), ' ', _jsxs(Text, { dimColor: true, children: ["(", entry.asset.type, ") v", entry.version, " \u2014 dependency"] })] })) : (_jsxs(Text, { children: [_jsx(Text, { bold: true, children: formatOrgName(entry.asset.org, entry.asset.name) }), _jsxs(Text, { dimColor: true, children: [' ', "(", entry.asset.type, ") v", entry.version] })] }))] }, identityKey(entry.asset)))), _jsx(CrossScopeWarning, { installs: state.crossScope ?? [] })] }));
+        return (_jsxs(Box, { flexDirection: 'column', children: [_jsx(DryRunBanner, { action: 'install', count: state.plan.totalCount, tools: state.tools, where: label }), _jsx(Text, { children: " " }), _jsx(Text, { children: _jsxs(Text, { bold: true, color: 'magenta', children: ["Org: @", orgName] }) }), _jsx(Text, { children: " " }), _jsx(PlanEntryLines, { plan: state.plan }), _jsx(CrossScopeWarning, { installs: state.crossScope ?? [] })] }));
     }
     if (state.phase === 'done') {
         if (effectiveJson) {
@@ -774,6 +1042,31 @@ function InstallOrg({ cliOrg, dryRun, force, json, orgName, pin, projectRoot, sk
     }
     return null;
 }
+/**
+ * Whether every member of the bundle is in place for every tool that takes it (with
+ * `requiredBundleVersion`, recorded as this bundle at that version). False when no tool takes any
+ * member, so the installer says why.
+ */
+function isBundleInPlace(registry, bundle, lockfile, { members, projectDir, requiredBundleVersion, tools, }) {
+    const bundleAssets = bundle.assets ?? [];
+    return tools.every(({ adapter: toolAdapter }) => members.length > 0 &&
+        bundleAssets.every((ref) => {
+            const found = findBundleMember(registry, bundle, ref);
+            if (!found)
+                return false;
+            // A tool that doesn't take this member (its type, or a hook for other tools) has
+            // nothing to check.
+            if (!placesAsset(toolAdapter, found.asset.type, found.versionData.tools))
+                return true;
+            const installed = findInstalledAsset(lockfile, ref.name, ref.type, found.asset.org);
+            if (!installed)
+                return false;
+            if (requiredBundleVersion && !isFromBundleVersion(installed, bundle, requiredBundleVersion)) {
+                return false;
+            }
+            return isInstalledForTool(installed, toolAdapter, projectDir);
+        }));
+}
 /** Whether a lockfile asset was installed as part of this bundle (name, org) at this version. */
 function isFromBundleVersion(installed, bundle, version) {
     const origin = installed.bundleOrigin;
@@ -798,4 +1091,55 @@ function membersOutsideBundle(lockfile, members, bundle) {
         return [{ ...(origin ? { bundle: origin } : {}), ...member }];
     });
 }
+/** The names a run of several left out of its plan: already installed, or made a direct install. */
+function NamedAssetLines({ assets, dryRun = false, where, }) {
+    const inScope = where ? ` in ${where}` : '';
+    return (_jsx(_Fragment, { children: assets
+            .filter((a) => a.outcome !== 'installed')
+            .map((a) => (_jsxs(Text, { children: [a.outcome === 'upgraded-to-direct' ? _jsx(Text, { color: 'green', children: "\u2713" }) : _jsx(Text, { color: 'yellow', children: "!" }), ' ', _jsx(Text, { bold: true, children: formatOrgName(a.org, a.name) }), " (v", a.version, ")", ' ', a.outcome === 'upgraded-to-direct'
+                    ? `${dryRun ? 'would become' : 'is now'} a direct install${inScope}.`
+                    : `is already installed${inScope}.`] }, identityKey(a)))) }));
+}
+/**
+ * The error for a bundle name that only another scope has, when no asset can claim the name
+ * either, instead of a misleading "asset not found".
+ */
+function otherScopeBundleError(registry, name, inlineOrg) {
+    if (inlineOrg) {
+        return new Error(`Bundle '${name}' not found in org '${inlineOrg}'.`);
+    }
+    const orgScopes = (registry.bundles ?? []).filter((b) => b.name === name && b.org).map((b) => `@${b.org}/${name}`);
+    return new Error(`Bundle '${name}' not found in the registry.` +
+        (orgScopes.length > 0 ? ` Did you mean ${orgScopes.join(' or ')}?` : ''));
+}
+/** A plan's entries, each with its type and version, its dependencies marked. */
+function PlanEntryLines({ plan }) {
+    return (_jsx(_Fragment, { children: plan.entries.map((entry) => (_jsxs(Text, { children: ['  ', entry.reason === 'dependency' ? (_jsxs(Text, { color: 'cyan', children: [formatOrgName(entry.asset.org, entry.asset.name), ' ', _jsxs(Text, { dimColor: true, children: ["(", entry.asset.type, ") v", entry.version, " \u2014 dependency"] })] })) : (_jsxs(Text, { children: [_jsx(Text, { bold: true, children: formatOrgName(entry.asset.org, entry.asset.name) }), _jsxs(Text, { dimColor: true, children: [' ', "(", entry.asset.type, ") v", entry.version] })] }))] }, identityKey(entry.asset)))) }));
+}
+/**
+ * The members not installed yet that the plan installs without the bundle's origin: named on their
+ * own, or with another bundle named before it. A dry run reports them as an install would.
+ */
+function plannedOutsideBundle(plan, lockfile, members, bundle) {
+    return members.flatMap((member) => {
+        if (findInstalledAsset(lockfile, member.name, member.type, member.org))
+            return [];
+        const entry = plan.entries.find((e) => identityKey(e.asset) === identityKey(member));
+        const origin = entry?.bundleOrigin;
+        if (!entry || (origin?.name === bundle.name && origin.org === bundle.org))
+            return [];
+        return [{ ...(origin ? { bundle: origin } : {}), ...member }];
+    });
+}
+/**
+ * The bundles and orgs a run of several names had among them: what it did with each bundle, the
+ * bundle's members outside it, and how many assets each org brought.
+ */
+function TargetLines({ bundles = [], dryRun = false, orgs = [], where, }) {
+    const inScope = where ? ` in ${where}` : '';
+    return (_jsxs(_Fragment, { children: [bundles.map((bundle) => {
+                const spec = formatOrgName(bundle.org, bundle.name);
+                return (_jsxs(Fragment, { children: [bundle.outcome === 'already-installed' ? (_jsxs(Text, { children: [_jsx(Text, { color: 'yellow', children: "!" }), " Bundle ", _jsx(Text, { bold: true, children: spec }), " is already fully installed (v", bundle.version, ")", inScope, "."] })) : (_jsxs(Text, { children: [_jsx(Text, { color: 'green', children: "\u2713" }), " Bundle ", _jsx(Text, { bold: true, children: spec }), " v", bundle.version, ' ', dryRun ? 'would be installed' : 'installed', inScope, "."] })), _jsx(BundleReportLines, { bundleName: spec, dryRun: dryRun, report: bundle })] }, spec));
+            }), orgs.map(({ count, org }) => (_jsxs(Text, { children: [_jsxs(Text, { bold: true, color: 'magenta', children: ["Org: @", org] }), _jsxs(Text, { dimColor: true, children: [' ', "\u2014 all ", count, " asset", count !== 1 ? 's' : ''] })] }, org)))] }));
+}
 //# sourceMappingURL=install.js.map