@slats/claude-assets-sync 0.2.0 → 0.3.1

package/dist/commands/runCli/utils/resolveScopeAlias.mjs

@@ -0,0 +1,67 @@
+import { existsSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { join, resolve, dirname } from 'node:path';
+import { logger } from '../../../utils/logger.mjs';
+import { resolvePackage } from './resolvePackage.mjs';
+
+async function resolveScopeAlias(scope, rootCwd) {
+    const packagesRoot = findPackagesRoot(rootCwd);
+    if (!packagesRoot) {
+        logger.error(`cannot locate a monorepo root with a "packages/" directory starting from "${rootCwd}". Scope alias "@${scope}" requires a workspace root.`);
+        process.exit(2);
+    }
+    const scopeDir = join(packagesRoot, 'packages', scope);
+    let entries;
+    try {
+        entries = await readdir(scopeDir);
+    }
+    catch {
+        logger.error(`scope alias "@${scope}" has no matching directory at ${scopeDir}.`);
+        process.exit(2);
+    }
+    const matchedNames = [];
+    const expectedPrefix = `@${scope}/`;
+    for (const entry of entries) {
+        const pkgJsonPath = join(scopeDir, entry, 'package.json');
+        if (!existsSync(pkgJsonPath))
+            continue;
+        let parsed;
+        try {
+            const raw = await readFile(pkgJsonPath, 'utf-8');
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        if (typeof parsed.name === 'string' &&
+            parsed.name.startsWith(expectedPrefix) &&
+            parsed.name.length > expectedPrefix.length) {
+            matchedNames.push(parsed.name);
+        }
+    }
+    if (matchedNames.length === 0) {
+        logger.warn(`scope alias "@${scope}" matched no workspace packages under ${scopeDir}.`);
+        return [];
+    }
+    const resolved = [];
+    for (const name of matchedNames) {
+        const meta = await resolvePackage(name, { skipMissingAsset: true });
+        if (meta)
+            resolved.push(meta);
+    }
+    return resolved;
+}
+function findPackagesRoot(start) {
+    let cur = resolve(start);
+    while (true) {
+        if (existsSync(join(cur, 'package.json')) && existsSync(join(cur, 'packages'))) {
+            return cur;
+        }
+        const parent = dirname(cur);
+        if (parent === cur)
+            return null;
+        cur = parent;
+    }
+}
+
+export { resolveScopeAlias };

package/dist/commands/runCli/utils/resolveScopeFlag.d.ts

@@ -1,2 +1,10 @@
 import { type Scope } from '../../../core/index.js';
-export declare function resolveScopeFlag(flag: string | undefined): Promise<Scope>;
+/**
+ * Legacy (non-TTY / --json) scope resolver.
+ *
+ * The TTY Ink path owns its own scope picker via `ui/components/ScopePicker`.
+ * This helper runs only after `renderOrFallback` has chosen the legacy path,
+ * where prompting is not appropriate — either stdout is piped or the caller
+ * asked for structured `--json` output. Missing flag → exit 2.
+ */
+export declare function resolveScopeFlag(flag: string | undefined): Scope;

package/dist/commands/runCli/utils/resolveScopeFlag.mjs

@@ -2,12 +2,9 @@ import 'node:crypto';
 import 'node:fs/promises';
 import 'node:path';
 import { logger } from '../../../utils/logger.mjs';
-import { isValidScope, isInteractive } from '../../../core/scope/scope.mjs';
-import { selectScopeAsync } from '../../../prompts/selectScope.mjs';
-import '@inquirer/prompts';
-import 'picocolors';
+import { isValidScope } from '../../../core/scope/scope.mjs';
 
-async function resolveScopeFlag(flag) {
+function resolveScopeFlag(flag) {
     if (flag) {
         if (!isValidScope(flag)) {
             logger.error(`Invalid --scope: ${flag}. Expected user | project.`);
@@ -15,12 +12,9 @@ async function resolveScopeFlag(flag) {
         }
         return flag;
     }
-    if (!isInteractive()) {
-        logger.error('--scope is required in non-interactive environments.');
-        logger.error('  Pass --scope=user | --scope=project.');
-        process.exit(2);
-    }
-    return selectScopeAsync();
+    logger.error('--scope is required in non-interactive environments.');
+    logger.error('  Pass --scope=user or --scope=project.');
+    process.exit(2);
 }
 
 export { resolveScopeFlag };

package/dist/commands/runCli/utils/resolveTargets.d.ts

@@ -0,0 +1,15 @@
+import { type ResolvedMetadata } from './resolvePackage.js';
+/**
+ * Classify each `--package` value, resolve them all, and dedupe the
+ * result by `packageName`.
+ *
+ * - `@<scope>` values enumerate through `resolveScopeAlias` (soft skip
+ *   when a workspace package lacks `claude.assetPath`).
+ * - `@<scope>/<name>` and `<name>` values go through `resolvePackage`.
+ *   When there is a single `--package` value, the call is strict
+ *   (asset-missing → exit 2); otherwise asset-missing is a soft skip
+ *   so the rest of the batch can proceed.
+ *
+ * Invalid `--package` values exit with code 2 before any filesystem IO.
+ */
+export declare function resolveTargets(targets: readonly string[], rootCwd: string): Promise<ResolvedMetadata[]>;

package/dist/commands/runCli/utils/resolveTargets.mjs

@@ -0,0 +1,38 @@
+import { logger } from '../../../utils/logger.mjs';
+import { classifyTarget } from './classifyTarget.mjs';
+import { resolvePackage } from './resolvePackage.mjs';
+import { resolveScopeAlias } from './resolveScopeAlias.mjs';
+
+async function resolveTargets(targets, rootCwd) {
+    if (targets.length === 0)
+        return [];
+    const isSingleTarget = targets.length === 1;
+    const seen = new Set();
+    const results = [];
+    for (const target of targets) {
+        const classification = classifyTarget(target);
+        if (classification.kind === 'invalid') {
+            logger.error(classification.reason);
+            process.exit(2);
+        }
+        let candidates;
+        if (classification.kind === 'scope') {
+            candidates = await resolveScopeAlias(classification.scope, rootCwd);
+        }
+        else {
+            const meta = await resolvePackage(classification.name, {
+                skipMissingAsset: !isSingleTarget,
+            });
+            candidates = meta ? [meta] : [];
+        }
+        for (const meta of candidates) {
+            if (!seen.has(meta.packageName)) {
+                seen.add(meta.packageName);
+                results.push(meta);
+            }
+        }
+    }
+    return results;
+}
+
+export { resolveTargets };

package/dist/commands/runCli/utils/toConsumerPackages.d.ts

@@ -0,0 +1,9 @@
+import type { ConsumerPackage } from '../type.js';
+import type { ResolvedMetadata } from './resolvePackage.js';
+/**
+ * Convert dispatcher `ResolvedMetadata` into runtime `ConsumerPackage`.
+ * Resolves the asset root against `packageRoot` and probes for
+ * `dist/claude-hashes.json` presence so both the Ink and legacy paths
+ * can treat the target uniformly.
+ */
+export declare function toConsumerPackages(metadataList: readonly ResolvedMetadata[]): Promise<ConsumerPackage[]>;

package/dist/commands/runCli/utils/toConsumerPackages.mjs

@@ -0,0 +1,26 @@
+import { stat } from 'node:fs/promises';
+import { isAbsolute, resolve, join } from 'node:path';
+import { logger } from '../../../utils/logger.mjs';
+
+async function toConsumerPackages(metadataList) {
+    const result = [];
+    for (const metadata of metadataList) {
+        if (!isAbsolute(metadata.packageRoot)) {
+            logger.error(`packageRoot must be an absolute path; received: ${metadata.packageRoot}`);
+            process.exit(2);
+        }
+        const assetRoot = resolve(metadata.packageRoot, metadata.assetPath);
+        const hashesPath = join(metadata.packageRoot, 'dist', 'claude-hashes.json');
+        const hashesPresent = await stat(hashesPath).then(() => true, () => false);
+        result.push({
+            name: metadata.packageName,
+            version: metadata.packageVersion,
+            packageRoot: metadata.packageRoot,
+            assetRoot,
+            hashesPresent,
+        });
+    }
+    return result;
+}
+
+export { toConsumerPackages };

package/dist/core/index.d.ts

@@ -1,5 +1,5 @@
 export { hashContent, hashEquals, hashFile, type Sha256Hex, } from './hash/index.js';
 export { HASH_MANIFEST_FILENAME, computeNamespacePrefixes, readHashManifest, type HashManifest, } from './hashManifest/index.js';
-export { injectDocs, type InjectOptions, type InjectReport, } from './injectDocs/index.js';
+export { applyAction, summarize, type InjectReport, } from './injectDocs/index.js';
 export { buildPlan, type Action, type InjectPlan, type PlanInput, } from './buildPlan/index.js';
-export { findNearestDotClaudeAncestor, isInteractive, isValidScope, resolveScope, type Scope, type ScopeResolution, } from './scope/index.js';
+export { findNearestDotClaudeAncestor, isValidScope, resolveScope, type Scope, type ScopeResolution, } from './scope/index.js';

package/dist/core/injectDocs/index.d.ts

@@ -1,2 +1,3 @@
-export { injectDocs } from './injectDocs.js';
-export type { InjectOptions, InjectReport } from './type.js';
+export { applyAction } from './utils/applyAction.js';
+export { summarize } from './utils/summarize.js';
+export type { InjectReport } from './type.js';

package/dist/core/injectDocs/type.d.ts

@@ -1,22 +1,3 @@
-import type { InjectPlan } from '../buildPlan/index.js';
-import type { Scope } from '../scope/index.js';
-export interface InjectOptions {
-    packageName: string;
-    packageVersion: string;
-    packageRoot: string;
-    assetRoot: string;
-    scope: Scope;
-    dryRun: boolean;
-    force: boolean;
-    /**
-     * Origin directory used to resolve project/local scope targets. When set,
-     * `resolveScope` walks up from this path to find the nearest existing
-     * `.claude` ancestor. Defaults to `process.cwd()`.
-     */
-    originCwd?: string;
-    /** Called AFTER plan is built but BEFORE apply. Return false to abort. */
-    confirmForce?: (plan: InjectPlan) => Promise<boolean>;
-}
 export interface InjectReport {
     created: string[];
     updated: string[];

package/dist/core/injectDocs/utils/applyAction.mjs

@@ -11,7 +11,7 @@ async function applyAction(action, assetRoot) {
     else if (action.kind === 'delete')
         await unlink(action.dstAbs).catch((error) => {
             if (error?.code !== 'ENOENT') {
-                logger.warn(`[claude-sync] unlink failed: ${action.dstAbs} (${error?.code ?? error})`);
+                logger.warn(`[claude-assets-sync] unlink failed: ${action.dstAbs} (${error?.code ?? error})`);
             }
         });
 }

package/dist/core/scope/index.d.ts

@@ -1 +1 @@
-export { findNearestDotClaudeAncestor, isInteractive, isValidScope, resolveScope, type Scope, type ScopeResolution, } from './scope.js';
+export { findNearestDotClaudeAncestor, isValidScope, resolveScope, type Scope, type ScopeResolution, } from './scope.js';

package/dist/core/scope/scope.d.ts

@@ -13,4 +13,3 @@ export declare function isValidScope(value: unknown): value is Scope;
  */
 export declare function findNearestDotClaudeAncestor(start: string): string | null;
 export declare function resolveScope(scope: Scope, cwd?: string): ScopeResolution;
-export declare function isInteractive(): boolean;

package/dist/core/scope/scope.mjs

@@ -34,8 +34,5 @@ function resolveScope(scope, cwd = process.cwd()) {
             : `${base}/.claude (project)`,
     };
 }
-function isInteractive() {
-    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
-}
 
-export { findNearestDotClaudeAncestor, isInteractive, isValidScope, resolveScope };
+export { findNearestDotClaudeAncestor, isValidScope, resolveScope };

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { runCli, type RunCliOptions } from './commands/index.js';
-export { HASH_MANIFEST_FILENAME, computeNamespacePrefixes, injectDocs, isInteractive, isValidScope, readHashManifest, resolveScope, type HashManifest, type InjectOptions, type InjectReport, type Scope, type ScopeResolution, } from './core/index.js';
+export { runCli } from './commands/index.js';
+export { HASH_MANIFEST_FILENAME, computeNamespacePrefixes, isValidScope, readHashManifest, resolveScope, type HashManifest, type InjectReport, type Scope, type ScopeResolution, } from './core/index.js';
 export type { AssetType } from './utils/types.js';

package/dist/index.mjs

@@ -2,6 +2,6 @@ export { runCli } from './commands/runCli/runCli.mjs';
 import 'node:crypto';
 import 'node:fs/promises';
 export { HASH_MANIFEST_FILENAME, computeNamespacePrefixes, readHashManifest } from './core/hashManifest/hashManifest.mjs';
-export { injectDocs } from './core/injectDocs/injectDocs.mjs';
 import 'node:path';
-export { isInteractive, isValidScope, resolveScope } from './core/scope/scope.mjs';
+import 'picocolors';
+export { isValidScope, resolveScope } from './core/scope/scope.mjs';

package/dist/ui/InjectApp/InjectApp.d.ts

@@ -0,0 +1,2 @@
+import type { InjectAppProps } from './utils/type.js';
+export declare function InjectApp(props: InjectAppProps): React.ReactElement;

package/dist/ui/InjectApp/InjectApp.mjs

@@ -0,0 +1,82 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useCallback } from 'react';
+import { Box, Text } from 'ink';
+import { Banner } from '../components/Banner.mjs';
+import { ConfirmForce } from '../components/ConfirmForce.mjs';
+import { ErrorPanel } from '../components/ErrorPanel.mjs';
+import { Footer } from '../components/Footer.mjs';
+import { ProgressBar } from '../components/ProgressBar.mjs';
+import { ScopePicker } from '../components/ScopePicker.mjs';
+import { Spinner } from '../components/Spinner.mjs';
+import { StepTracker } from '../components/StepTracker.mjs';
+import { Summary } from '../components/Summary.mjs';
+import { TargetCard } from '../components/TargetCard.mjs';
+import { useExitApp } from '../hooks/useExitApp.mjs';
+import { useInjectSession } from '../hooks/useInjectSession.mjs';
+import { usePhase } from '../hooks/usePhase.mjs';
+import { colors } from '../theme/colors.mjs';
+import { icons } from '../theme/icons.mjs';
+import { scopeLabel, etaSeconds } from './utils/eventSelectors.mjs';
+
+const VERSION = '0.3.0';
+function InjectApp(props) {
+    const { targets, flags, originCwd, onExit } = props;
+    const [phase, dispatch] = usePhase({ kind: 'resolving', targets });
+    useInjectSession({ targets, flags, originCwd, dispatch });
+    const handleExit = useCallback((code) => {
+        onExit(code);
+    }, [onExit]);
+    useExitApp({
+        enabled: phase.kind === 'summary',
+        exitCode: phase.kind === 'summary' ? phase.exitCode : 0,
+        onExit: handleExit,
+        delayMs: 100,
+    });
+    useExitApp({
+        enabled: phase.kind === 'error',
+        exitCode: 1,
+        onExit: handleExit,
+        delayMs: 100,
+    });
+    return (jsxs(Box, { flexDirection: "column", children: [jsx(Banner, { version: VERSION, scope: scopeLabel(phase) }), jsx(Box, { marginTop: 1, children: jsx(StepTracker, { phase: phase, targetCount: targets.length, scope: scopeLabel(phase) }) }), jsx(Box, { flexDirection: "column", marginTop: 1, children: renderPhaseBody(phase) }), jsx(Footer, { phase: phase, version: VERSION })] }));
+}
+function renderPhaseBody(phase) {
+    switch (phase.kind) {
+        case 'booting':
+        case 'resolving':
+            return jsx(Spinner, { label: "resolving targets\u2026" });
+        case 'scope-select':
+            return jsx(ScopePicker, { onSelect: phase.pending });
+        case 'planning':
+            return (jsxs(Box, { flexDirection: "column", children: [jsx(Spinner, { label: "building plans\u2026" }), jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: [...phase.progress.values()].map((step) => (jsxs(Box, { children: [jsxs(Text, { color: step.status === 'done'
+                                        ? colors.success
+                                        : step.status === 'running'
+                                            ? colors.warn
+                                            : step.status === 'failed'
+                                                ? colors.danger
+                                                : colors.muted, bold: step.status === 'running', children: [step.status === 'done'
+                                            ? icons.check
+                                            : step.status === 'failed'
+                                                ? icons.cross
+                                                : step.status === 'running'
+                                                    ? icons.bulletActive
+                                                    : icons.bulletPending, ' '] }), jsx(Text, { children: step.packageName }), step.error ? (jsxs(Text, { color: colors.danger, dimColor: true, children: ['  ', "(", step.error, ")"] })) : null] }, step.packageName))) })] }));
+        case 'diff-review':
+            return (jsxs(Box, { flexDirection: "column", children: [phase.plans.map((tp, idx) => (jsx(TargetCard, { target: tp.target, plan: tp.plan, expanded: true, highlighted: idx === phase.focusedIndex }, tp.target.name))), jsx(Box, { marginTop: 1, children: jsxs(Text, { color: colors.muted, dimColor: true, children: ["Applying ", phase.plans.length, " plan(s)\u2026"] }) })] }));
+        case 'force-confirm':
+            return (jsx(ConfirmForce, { warnings: phase.warnings, onAnswer: phase.pending }));
+        case 'applying': {
+            const eta = etaSeconds(phase.progress.startedAt, phase.progress.done, phase.progress.total);
+            return (jsxs(Box, { flexDirection: "column", children: [jsx(ProgressBar, { done: phase.progress.done, total: phase.progress.total, etaSeconds: eta, label: phase.progress.current }), jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: phase.plans.map((tp) => (jsx(TargetCard, { target: tp.target, plan: tp.plan, expanded: false }, tp.target.name))) })] }));
+        }
+        case 'summary':
+            return (jsxs(Box, { flexDirection: "column", children: [phase.plans.map((tp) => (jsx(TargetCard, { target: tp.target, plan: tp.plan, expanded: false }, tp.target.name))), jsx(Summary, { reports: phase.reports, exitCode: phase.exitCode, dryRun: phase.dryRun })] }));
+        case 'error':
+            return jsx(ErrorPanel, { error: phase.error });
+        default: {
+            return null;
+        }
+    }
+}
+
+export { InjectApp };

package/dist/ui/InjectApp/index.d.ts

@@ -0,0 +1,2 @@
+export { renderInjectApp } from './utils/renderInjectApp.js';
+export { InjectApp } from './InjectApp.js';

package/dist/ui/InjectApp/utils/eventSelectors.d.ts

@@ -0,0 +1,5 @@
+import type { ConsumerPackage } from '../../../commands/runCli/type.js';
+import type { Phase } from '../../types/index.js';
+export declare function scopeLabel(phase: Phase): string | undefined;
+export declare function targetsOf(phase: Phase): readonly ConsumerPackage[];
+export declare function etaSeconds(startedAt: number, done: number, total: number, now?: number): number | undefined;

package/dist/ui/InjectApp/utils/eventSelectors.mjs

@@ -0,0 +1,24 @@
+function scopeLabel(phase) {
+    switch (phase.kind) {
+        case 'planning':
+        case 'diff-review':
+        case 'force-confirm':
+        case 'applying':
+        case 'summary':
+            return phase.scope;
+        default:
+            return undefined;
+    }
+}
+function etaSeconds(startedAt, done, total, now = Date.now()) {
+    if (done === 0)
+        return undefined;
+    const elapsedMs = Math.max(now - startedAt, 1);
+    const rate = done / elapsedMs;
+    const remaining = total - done;
+    if (rate <= 0)
+        return undefined;
+    return remaining / rate / 1000;
+}
+
+export { etaSeconds, scopeLabel };

package/dist/ui/InjectApp/utils/phaseReducer.d.ts

@@ -0,0 +1,2 @@
+import type { InjectEvent, Phase } from '../../types/index.js';
+export declare function phaseReducer(phase: Phase, event: InjectEvent): Phase;

package/dist/ui/InjectApp/utils/phaseReducer.mjs

@@ -0,0 +1,130 @@
+function phaseReducer(phase, event) {
+    switch (event.type) {
+        case 'scope-needed': {
+            if (phase.kind === 'booting' || phase.kind === 'resolving') {
+                return {
+                    kind: 'scope-select',
+                    targets: phase.kind === 'resolving' ? phase.targets : [],
+                    pending: event.pending,
+                };
+            }
+            return phase;
+        }
+        case 'scope-selected': {
+            return phase;
+        }
+        case 'planning-started': {
+            const progress = new Map(event.targets.map((t) => [t.name, { packageName: t.name, status: 'pending' }]));
+            return {
+                kind: 'planning',
+                targets: event.targets,
+                scope: event.scope,
+                progress,
+            };
+        }
+        case 'plan-step': {
+            if (phase.kind !== 'planning')
+                return phase;
+            const next = new Map(phase.progress);
+            next.set(event.step.packageName, event.step);
+            return { ...phase, progress: next };
+        }
+        case 'plans-ready': {
+            if (phase.kind !== 'planning')
+                return phase;
+            return {
+                kind: 'diff-review',
+                plans: event.plans,
+                focusedIndex: 0,
+                scope: phase.scope,
+            };
+        }
+        case 'focus-target': {
+            if (phase.kind !== 'diff-review')
+                return phase;
+            return { ...phase, focusedIndex: event.index };
+        }
+        case 'force-confirm-required': {
+            if (phase.kind !== 'diff-review' && phase.kind !== 'applying')
+                return phase;
+            return {
+                kind: 'force-confirm',
+                plans: phase.kind === 'diff-review' ? phase.plans : phase.plans,
+                warnings: event.warnings,
+                pending: event.pending,
+                scope: phase.scope,
+            };
+        }
+        case 'force-answer': {
+            if (phase.kind !== 'force-confirm')
+                return phase;
+            if (!event.ok) {
+                return {
+                    kind: 'summary',
+                    reports: [],
+                    plans: phase.plans,
+                    exitCode: 2,
+                    scope: phase.scope,
+                    dryRun: false,
+                };
+            }
+            return {
+                kind: 'applying',
+                plans: phase.plans,
+                progress: {
+                    done: 0,
+                    total: phase.plans.reduce((acc, tp) => acc + tp.plan.actions.length, 0),
+                    startedAt: Date.now(),
+                },
+                scope: phase.scope,
+            };
+        }
+        case 'apply-start': {
+            if (phase.kind !== 'diff-review' && phase.kind !== 'force-confirm')
+                return phase;
+            const plans = phase.kind === 'diff-review' ? phase.plans : phase.plans;
+            return {
+                kind: 'applying',
+                plans,
+                progress: { done: 0, total: event.total, startedAt: Date.now() },
+                scope: phase.scope,
+            };
+        }
+        case 'apply-progress': {
+            if (phase.kind !== 'applying')
+                return phase;
+            return {
+                ...phase,
+                progress: {
+                    ...phase.progress,
+                    done: event.done,
+                    current: event.current,
+                },
+            };
+        }
+        case 'done': {
+            const scope = phase.kind === 'applying' || phase.kind === 'diff-review'
+                ? phase.scope
+                : 'user';
+            const plans = phase.kind === 'applying' || phase.kind === 'diff-review'
+                ? phase.plans
+                : [];
+            return {
+                kind: 'summary',
+                reports: event.reports,
+                plans,
+                exitCode: event.exitCode,
+                scope,
+                dryRun: event.dryRun,
+            };
+        }
+        case 'fail': {
+            return { kind: 'error', error: event.error };
+        }
+        default: {
+            return phase;
+        }
+    }
+}
+
+export { phaseReducer };

package/dist/ui/InjectApp/utils/renderInjectApp.d.ts

@@ -0,0 +1,2 @@
+import type { RenderInput } from '../../types/index.js';
+export declare function renderInjectApp(input: RenderInput): Promise<number>;

package/dist/ui/InjectApp/utils/renderInjectApp.mjs

@@ -0,0 +1,19 @@
+import { jsx } from 'react/jsx-runtime';
+import { render } from 'ink';
+import { InjectApp } from '../InjectApp.mjs';
+
+async function renderInjectApp(input) {
+    let exitCode = 0;
+    const instance = render(jsx(InjectApp, { ...input, onExit: (code) => {
+            exitCode = code;
+        } }), { exitOnCtrlC: true });
+    try {
+        await instance.waitUntilExit();
+        return exitCode;
+    }
+    finally {
+        instance.unmount();
+    }
+}
+
+export { renderInjectApp };

package/dist/ui/InjectApp/utils/type.d.ts

@@ -0,0 +1,5 @@
+import type { RenderInput } from '../../types/index.js';
+export type { Phase, InjectEvent, RenderInput } from '../../types/index.js';
+export interface InjectAppProps extends RenderInput {
+    readonly onExit: (code: 0 | 1 | 2) => void;
+}

package/dist/ui/components/ActionRow.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { Action } from '../../core/buildPlan/index.js';
+interface ActionRowProps {
+    readonly action: Action;
+}
+export declare function ActionRow({ action }: ActionRowProps): React.ReactElement;
+export {};

package/dist/ui/components/ActionRow.mjs

@@ -0,0 +1,45 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { Box, Text } from 'ink';
+import { colors } from '../theme/colors.mjs';
+import { icons } from '../theme/icons.mjs';
+
+function visualFor(action) {
+    switch (action.kind) {
+        case 'copy':
+            return { icon: icons.plus, color: colors.success };
+        case 'skip-uptodate':
+            return {
+                icon: icons.equals,
+                color: colors.muted,
+                dim: true,
+                note: 'up-to-date',
+            };
+        case 'warn-diverged':
+            return {
+                icon: icons.warning,
+                color: colors.warn,
+                note: 'diverged',
+            };
+        case 'warn-orphan':
+            return {
+                icon: icons.question,
+                color: colors.warn,
+                note: 'orphan',
+            };
+        case 'delete':
+            return {
+                icon: icons.minus,
+                color: colors.danger,
+                note: 'delete',
+            };
+        default: {
+            return { icon: '?', color: colors.muted };
+        }
+    }
+}
+function ActionRow({ action }) {
+    const visual = visualFor(action);
+    return (jsxs(Box, { children: [jsxs(Text, { color: visual.color, bold: true, children: [' ', visual.icon, ' '] }), jsx(Text, { color: colors.muted, dimColor: visual.dim, children: action.relPath }), visual.note ? (jsxs(Text, { color: colors.muted, dimColor: true, children: ['  ', "(", visual.note, ")"] })) : null] }));
+}
+
+export { ActionRow };

package/dist/ui/components/Banner.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface BannerProps {
+    readonly version: string;
+    readonly scope?: string;
+}
+export declare function Banner({ version, scope, }: BannerProps): React.ReactElement;
+export {};