@detergent-software/atk 8.9.0-dev.1 → 8.9.0-dev.3

package/build/hooks/usePublishState.js

@@ -1,84 +1,9 @@
-import { cp, mkdir, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
+import { rm } from 'node:fs/promises';
 import { useEffect, useReducer, useRef } from 'react';
-import { loadAllAdapters, resolveInstalledPaths } from '../lib/adapter.js';
-import { isApiError } from '../lib/api-client.js';
-import { getCredential } from '../lib/auth.js';
-import { hashFile } from '../lib/checksum.js';
-import { errorGuidance, errorMessage } from '../lib/errors.js';
-import { detectCompatibleTools, getSignedInUserName } from '../lib/init.js';
-import { addAssetToLockfile, findInstalledAsset, readLockfile, withLockfileLock, writeLockfile, } from '../lib/lockfile.js';
-import { diffManifests, fetchExistingManifest } from '../lib/manifest-diff.js';
-import { parseOrgFromName } from '../lib/org.js';
-import { findProjectRoot } from '../lib/paths.js';
-import { buildPublishPlan, buildStagingArea, bumpVersion, checkRegistryVersion, detectAssetFromPath, detectPublishType, executePublish, findSiblingDependencies, isOrgScopedTarget, loadPublishBatch, loadPublishEntries, mapPublishError, missingDependencies, resolvePlanDependencies, unknownToolsError, updateManifestField, updateManifestVersion, validatePublishTarget, } from '../lib/publisher.js';
-import { fetchAssetManifest } from '../lib/registry.js';
-import { clearCache, fetchRegistry, findAsset, findBundle } from '../lib/registry.js';
-import { parseReviewersInput, validateGithubUsername } from '../lib/reviewers.js';
-import { resolveTools } from '../lib/tool-resolver.js';
-// ---------------------------------------------------------------------------
-// Error helpers
-// ---------------------------------------------------------------------------
-export function createInitialState(flags) {
-    // Non-interactive when --yes, --dry-run, --json, or stdin is not a TTY (raw mode
-    // unsupported). Defaults isTTY to true when the flag is omitted (call site responsible
-    // for threading useStdin().isRawModeSupported in). --dry-run and --json force
-    // non-interactive regardless of TTY — JSON output cannot interleave with prompts.
-    const isTTY = flags.isTTY ?? true;
-    const nonInteractive = Boolean(flags.yes) || flags.dryRun || Boolean(flags.json) || !isTTY;
-    const flagError = batchFlagError(flags);
-    return {
-        authorValue: '',
-        bumpSelection: '',
-        confirmValue: '',
-        descriptionValue: '',
-        entries: [],
-        errorMessage: flagError ?? '',
-        flags,
-        isRawPublish: false,
-        isUpdate: false,
-        manifestDiff: undefined,
-        metadataSubPhase: 'description',
-        missingDependencies: [],
-        nonInteractive,
-        orgValue: '',
-        phase: flagError
-            ? 'error'
-            : flags.update
-                ? 'resolving-update'
-                : flags.fromInstalled
-                    ? 'resolving-installed'
-                    : 'detecting',
-        plan: undefined,
-        progressMessage: '',
-        promptTagsValue: '',
-        publishConfirmValue: '',
-        publishResult: undefined,
-        rawDetection: null,
-        resolvedPath: flags.update ? '' : flags.fromInstalled ? '' : resolve(flags.rawPath),
-        resolvedVersion: '',
-        reviewerValue: '',
-        selectedPromptTools: [],
-        suggestedEntries: [],
-        tagsValue: '',
-        target: undefined,
-        token: undefined,
-        toolAdapters: [],
-        toolCursorIndex: 0,
-        toolsDetected: [],
-        validation: undefined,
-        versionCheck: undefined,
-        withConfirmValue: '',
-    };
-}
-// ---------------------------------------------------------------------------
-// Initial state factory
-// ---------------------------------------------------------------------------
-/** Several folders published together (`atk publish a b c`) in one pull request; one folder named twice is one. */
-export function isBatch(flags) {
-    return new Set(flags.paths?.map((path) => resolve(path))).size > 1;
-}
+import { createInitialState, isBatch, runPublishStep, splitList, } from '../lib/publish-flow.js';
+import { bumpVersion, isOrgScopedTarget } from '../lib/publisher.js';
+import { parseReviewersInput } from '../lib/reviewers.js';
+export { createInitialState, isBatch } from '../lib/publish-flow.js';
 export function publishReducer(state, action) {
     switch (action.type) {
         case 'BUMP_DONE': {
@@ -343,11 +268,7 @@ export function publishReducer(state, action) {
             };
         }
         case 'SUBMIT_PROMPT_TAGS': {
-            // Parse comma-separated tags from the prompt value
-            const parsedTags = state.promptTagsValue
-                .split(',')
-                .map((t) => t.trim())
-                .filter(Boolean);
+            const parsedTags = splitList(state.promptTagsValue);
             // Update the target's data with the new tags
             const updatedTagsTarget = state.target
                 ? {
@@ -488,12 +409,7 @@ export function publishReducer(state, action) {
             if (state.nonInteractive) {
                 let nextTarget = state.target;
                 if (!hasTags && nextTarget) {
-                    const flagTags = state.flags.tagsFlag
-                        ? state.flags.tagsFlag
-                            .split(',')
-                            .map((t) => t.trim())
-                            .filter(Boolean)
-                        : [];
+                    const flagTags = splitList(state.flags.tagsFlag);
                     nextTarget = {
                         ...nextTarget,
                         data: { ...nextTarget.data, tags: flagTags.length > 0 ? flagTags : undefined },
@@ -537,783 +453,56 @@ export function publishReducer(state, action) {
             return state;
     }
 }
+/**
+ * The publish flow's state for the command's UI. The reducer moves it through its
+ * phases; on each phase that waits on work, the step in `lib/publish-flow.ts` runs
+ * and dispatches what it found.
+ */
 export function usePublishState(flags) {
     const [state, dispatch] = useReducer(publishReducer, undefined, () => createInitialState(flags));
-    // Temp directory ref for staging / --from-installed cleanup
-    const tempDirRef = useRef(null);
-    // --- Phase: resolving-installed ---
-    useEffect(() => {
-        if (state.phase !== 'resolving-installed')
-            return;
-        let cancelled = false;
-        const resolveInstalled = async () => {
-            const assetName = state.flags.rawPath;
-            const { name, org } = parseOrgFromName(assetName);
-            const projectRoot = findProjectRoot(state.flags.projectRoot);
-            const tools = await resolveTools(state.flags.tool);
-            const adapter = tools[0].adapter;
-            const lockfile = await readLockfile(projectRoot);
-            const installed = findInstalledAsset(lockfile, name, undefined, org);
-            if (!installed) {
-                if (!cancelled) {
-                    dispatch({ message: `Asset '${assetName}' is not installed.`, type: 'ERROR' });
-                }
-                return;
-            }
-            // Create temp directory and copy installed files
-            const tempDir = await mkdir(join(tmpdir(), 'atk-publish-'), { recursive: true })
-                .then(() => join(tmpdir(), `atk-publish-${Date.now()}-${Math.random().toString(36).slice(2)}`))
-                .then(async (dir) => {
-                await mkdir(dir, { recursive: true });
-                return dir;
-            });
-            if (cancelled) {
-                await rm(tempDir, { force: true, recursive: true });
-                return;
-            }
-            tempDirRef.current = tempDir;
-            // Resolve installed paths via the adapter
-            const resolved = resolveInstalledPaths(installed, adapter, projectRoot);
-            // Copy each installed file preserving sourcePath directory structure
-            for (const file of resolved.files) {
-                const sourceAbsolute = join(projectRoot, file.installedPath);
-                const destPath = join(tempDir, file.sourcePath);
-                const destDir = dirname(destPath);
-                await mkdir(destDir, { recursive: true });
-                await cp(sourceAbsolute, destPath);
-            }
-            // Generate manifest.json in the temp dir
-            const manifest = {
-                author: 'unknown',
-                description: `Published from installed asset ${installed.name}`,
-                entrypoint: installed.files[0]?.sourcePath ?? 'index.md',
-                name: installed.name,
-                ...(installed.org ? { org: installed.org } : {}),
-                type: installed.type,
-                version: installed.version,
-            };
-            await writeFile(join(tempDir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
-            if (!cancelled) {
-                dispatch({ resolvedPath: tempDir, type: 'RESOLVED_INSTALLED' });
-            }
-        };
-        resolveInstalled().catch((err) => {
-            if (!cancelled) {
-                dispatch(toErrorAction(err));
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-        // Phase-gated effect: only runs when entering 'resolving-installed'
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [state.phase]);
-    // --- Phase: resolving-update ---
-    useEffect(() => {
-        if (state.phase !== 'resolving-update')
-            return;
-        let cancelled = false;
-        const resolveUpdate = async () => {
-            const assetName = state.flags.rawPath;
-            const { name, org } = parseOrgFromName(assetName);
-            const projectRoot = findProjectRoot(state.flags.projectRoot);
-            const tools = await resolveTools(state.flags.tool);
-            const adapter = tools[0].adapter;
-            const lockfile = await readLockfile(projectRoot);
-            const installed = findInstalledAsset(lockfile, name, undefined, org);
-            if (!installed) {
-                if (!cancelled) {
-                    dispatch({ message: `Asset '${assetName}' is not installed.`, type: 'ERROR' });
-                }
-                return;
-            }
-            // Fetch the registry to find the latest version
-            const registry = await fetchRegistry({ force: state.flags.refresh });
-            if (cancelled)
-                return;
-            // Look up the asset in the registry: try findAsset first, then findBundle
-            const resolvedAsset = findAsset(registry, installed.name, installed.type, undefined, installed.org ?? org);
-            const resolvedBundle = resolvedAsset ? undefined : findBundle(registry, installed.name, installed.org ?? org);
-            if (!resolvedAsset && !resolvedBundle) {
-                if (!cancelled) {
-                    dispatch({ message: `Asset '${assetName}' not found in the registry.`, type: 'ERROR' });
-                }
-                return;
-            }
-            const latestVersion = resolvedAsset ? resolvedAsset.version : resolvedBundle.version;
-            const assetType = resolvedAsset ? resolvedAsset.asset.type : 'bundle';
-            // Fetch the authoritative manifest (and optional README) from the registry
-            const fetched = await fetchAssetManifest({ name: installed.name, org: installed.org ?? org, type: assetType }, latestVersion);
-            if (cancelled)
-                return;
-            // Create temp staging directory
-            const tempDir = await mkdir(join(tmpdir(), 'atk-publish-'), { recursive: true })
-                .then(() => join(tmpdir(), `atk-publish-${Date.now()}-${Math.random().toString(36).slice(2)}`))
-                .then(async (dir) => {
-                await mkdir(dir, { recursive: true });
-                return dir;
+    // Staging directories (--from-installed, --update, a raw publish's manifest) to remove at the end
+    const stagingDirs = useRef([]);
+    const unmounted = useRef(false);
+    const removeStagingDirs = (dirs) => {
+        for (const dir of dirs.splice(0)) {
+            rm(dir, { force: true, recursive: true }).catch(() => {
+                // Best-effort cleanup — ignore errors
             });
-            if (cancelled) {
-                await rm(tempDir, { force: true, recursive: true });
-                return;
-            }
-            tempDirRef.current = tempDir;
-            // Resolve installed paths and copy the user's locally modified files into staging
-            const resolved = resolveInstalledPaths(installed, adapter, projectRoot);
-            for (const file of resolved.files) {
-                const sourceAbsolute = join(projectRoot, file.installedPath);
-                const destPath = join(tempDir, file.sourcePath);
-                const destDir = dirname(destPath);
-                await mkdir(destDir, { recursive: true });
-                await cp(sourceAbsolute, destPath);
-            }
-            // Write the fetched manifest into the staging directory. It is the manifest as this
-            // CLI's schema parsed it: a field the schema does not know (from a newer publisher)
-            // is dropped here and so is missing from the re-published version.
-            await writeFile(join(tempDir, fetched.manifestFileName), fetched.manifestContent, 'utf-8');
-            // Write README if present
-            if (fetched.readmeContent) {
-                await writeFile(join(tempDir, 'README.md'), fetched.readmeContent, 'utf-8');
-            }
-            if (!cancelled) {
-                dispatch({ resolvedPath: tempDir, type: 'RESOLVED_UPDATE' });
-            }
-        };
-        resolveUpdate().catch((err) => {
-            if (!cancelled) {
-                dispatch(toErrorAction(err));
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-        // Phase-gated effect: only runs when entering 'resolving-update'
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [state.phase]);
-    // --- Phase: detecting ---
-    useEffect(() => {
-        if (state.phase !== 'detecting')
-            return;
-        let cancelled = false;
-        const detect = async () => {
-            // A batch reads every folder now; any that is missing, a bundle or not an asset folder
-            // fails here, all of them together, before any prompt.
-            if (isBatch(state.flags)) {
-                const { entries, root } = await loadPublishBatch(state.flags.paths ?? [], state.flags.withPaths);
-                if (cancelled)
-                    return;
-                dispatch({ entries, type: 'ENTRIES_LOADED' });
-                dispatch({ target: root.target, type: 'DETECT_DONE' });
-                return;
-            }
-            // A --with folder that is missing, a bundle, the root or a repeat fails here, before any
-            // prompt; its validation and version check come in checking-entries.
-            if (state.flags.withPaths?.length) {
-                const entries = await loadPublishEntries(state.flags.withPaths, state.resolvedPath);
-                if (cancelled)
-                    return;
-                dispatch({ entries, type: 'ENTRIES_LOADED' });
-            }
-            // First, try manifest-based detection (existing flow)
-            try {
-                const detected = await detectPublishType(state.resolvedPath);
-                if (cancelled)
-                    return;
-                dispatch({ target: detected, type: 'DETECT_DONE' });
-                return;
-            }
-            catch (manifestError) {
-                // Only attempt raw detection if the error is specifically about missing manifest/bundle
-                const manifestMsg = errorMessage(manifestError);
-                if (!manifestMsg.includes('No manifest.json or bundle.json found')) {
-                    // This is a different error (e.g., invalid JSON in manifest) — surface it directly
-                    if (!cancelled) {
-                        dispatch({ message: manifestMsg, type: 'ERROR' });
-                    }
-                    return;
-                }
-            }
-            // Manifest not found — attempt raw asset detection
-            const resolvedTools = await resolveTools(state.flags.tool);
-            const adapter = resolvedTools[0].adapter;
-            if (cancelled)
-                return;
-            const projectRoot = findProjectRoot(state.flags.projectRoot);
-            const detection = await detectAssetFromPath(state.resolvedPath, adapter, projectRoot);
-            if (cancelled)
-                return;
-            // Pre-fill metadata
-            const author = (await getSignedInUserName()) ?? '';
-            if (cancelled)
-                return;
-            const lockfile = await readLockfile(projectRoot);
-            if (cancelled)
-                return;
-            const tools = await detectCompatibleTools(detection.assetType);
-            if (cancelled)
-                return;
-            const orgVal = lockfile.org ?? '';
-            // Non-interactive mode (raw publish — no manifest exists yet, so the only
-            // sources for description are --description flag or exit-1; tags come from
-            // --tags or default to empty). Tool detection runs for both modes above.
-            if (state.nonInteractive) {
-                if (!state.flags.descriptionFlag) {
-                    if (!cancelled) {
-                        dispatch({
-                            message: 'description required: provide --description or include in manifest.json',
-                            type: 'ERROR',
-                        });
-                    }
-                    return;
-                }
-                const tags = state.flags.tagsFlag
-                    ? state.flags.tagsFlag
-                        .split(',')
-                        .map((t) => t.trim())
-                        .filter(Boolean)
-                    : [];
-                // Tools resolution: --tools flag -> detected (already populated above)
-                let toolsList;
-                if (state.flags.toolsFlag) {
-                    toolsList = state.flags.toolsFlag
-                        .split(',')
-                        .map((t) => t.trim())
-                        .filter(Boolean);
-                }
-                else if (tools.length > 0) {
-                    toolsList = tools;
-                }
-                else {
-                    if (!cancelled) {
-                        dispatch({
-                            message: `--tools <comma-separated> required: no tools detected for type ${detection.assetType}`,
-                            type: 'ERROR',
-                        });
-                    }
-                    return;
-                }
-                const stagingDir = await buildStagingArea(detection, {
-                    author,
-                    description: state.flags.descriptionFlag,
-                    ...(lockfile.org ? { org: lockfile.org } : {}),
-                    tags,
-                    tools: toolsList,
-                });
-                if (cancelled)
-                    return;
-                tempDirRef.current = stagingDir;
-                const detected = await detectPublishType(stagingDir);
-                if (cancelled)
-                    return;
-                dispatch({ rawDetection: detection, target: detected, type: 'RAW_DETECT_DONE_NON_INTERACTIVE' });
-            }
-            else {
-                // Interactive mode — gather metadata from the user
-                dispatch({
-                    authorValue: author,
-                    orgValue: orgVal,
-                    rawDetection: detection,
-                    toolsDetected: tools,
-                    type: 'RAW_DETECT_DONE',
-                });
-            }
-        };
-        detect().catch((err) => {
-            if (!cancelled) {
-                dispatch(toErrorAction(err));
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-        // Phase-gated effect: only runs when entering 'detecting'
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [state.phase]);
-    // --- Phase: gathering-metadata / building-staging sub-phase ---
+        }
+    };
+    // Phase-gated: the step runs once on entering its phase (or the building-staging sub-phase)
     useEffect(() => {
-        if (state.phase !== 'gathering-metadata' || state.metadataSubPhase !== 'building-staging')
-            return;
         let cancelled = false;
-        const build = async () => {
-            // Parse tags from comma-separated string
-            const tags = state.tagsValue
-                .split(',')
-                .map((t) => t.trim())
-                .filter(Boolean);
-            // Build staging area
-            const stagingDir = await buildStagingArea(state.rawDetection, {
-                author: state.authorValue,
-                description: state.descriptionValue,
-                org: state.orgValue || undefined,
-                tags,
-                tools: state.toolsDetected,
-            });
-            if (cancelled)
-                return;
-            // Store for cleanup
-            tempDirRef.current = stagingDir;
-            // Re-detect using the staging area (now has manifest.json)
-            const detectedTarget = await detectPublishType(stagingDir);
-            if (cancelled)
-                return;
-            dispatch({ target: detectedTarget, type: 'STAGING_DONE' });
-        };
-        build().catch((err) => {
-            if (!cancelled) {
-                dispatch(toErrorAction(err));
-            }
+        void runPublishStep(state, {
+            cancelled: () => cancelled,
+            dispatch,
+            stage: (dir) => {
+                stagingDirs.current.push(dir);
+                // A step that outlived the command still leaves nothing behind
+                if (unmounted.current)
+                    removeStagingDirs(stagingDirs.current);
+            },
         });
         return () => {
             cancelled = true;
         };
-        // Phase-gated effect: only runs when entering building-staging sub-phase
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [state.phase, state.metadataSubPhase]);
-    // --- Phase: validating ---
-    useEffect(() => {
-        if (state.phase !== 'validating')
-            return;
-        if (!state.target)
-            return;
-        let cancelled = false;
-        const validate = async () => {
-            let lockfileOrg;
-            let lockfileOrgReviewers;
-            try {
-                const projectRoot = findProjectRoot(state.flags.projectRoot);
-                const lockfile = await readLockfile(projectRoot);
-                lockfileOrg = lockfile.org;
-                lockfileOrgReviewers = lockfile.orgReviewers;
-            }
-            catch {
-                // No project root / lockfile — treat as no lockfile org / reviewers
-            }
-            if (cancelled)
-                return;
-            // Bundles need the registry so their asset refs can be resolved during
-            // validation — an unresolvable ref must fail here, not at install time.
-            let registry;
-            if (state.target.type === 'bundle') {
-                registry = await fetchRegistry({ force: state.flags.refresh });
-                if (cancelled)
-                    return;
-            }
-            const result = await validatePublishTarget(state.target, {
-                force: state.flags.force,
-                lockfileOrg,
-                registry,
-            });
-            if (cancelled)
-                return;
-            // A batch checks every asset before stopping, so one run lists every folder's problems.
-            if (isBatch(state.flags)) {
-                const entries = [];
-                for (const entry of state.entries) {
-                    const validation = await validatePublishTarget(entry.target, { force: state.flags.force, lockfileOrg });
-                    if (cancelled)
-                        return;
-                    entries.push({ ...entry, validation });
-                }
-                const failed = [{ label: state.flags.rawPath, validation: result }, ...entries].filter((f) => f.validation && !f.validation.valid);
-                if (failed.length > 0) {
-                    const lines = failed.flatMap((f) => [
-                        `  ${f.label}:`,
-                        ...(f.validation?.errors ?? []).map((e) => `    - ${e}`),
-                    ]);
-                    dispatch({ message: `Validation failed:\n${lines.join('\n')}`, type: 'ERROR' });
-                    return;
-                }
-                // checking-entries keeps these instead of validating each entry again.
-                dispatch({ entries, type: 'ENTRIES_LOADED' });
-            }
-            dispatch({ lockfileOrgReviewers, type: 'VALIDATE_DONE', validation: result });
-        };
-        validate().catch((err) => {
-            if (!cancelled) {
-                dispatch(toErrorAction(err));
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-        // Phase-gated effect: only runs when entering 'validating'
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [state.phase]);
-    // --- Phase: loading-tools ---
-    // In interactive mode, loads adapters for the multi-select prompt.
-    // In non-interactive mode, resolves tools via manifest -> --tools flag ->
-    // detectCompatibleTools(assetType) -> exit 1, then dispatches
-    // RESOLVE_TOOLS_NONINTERACTIVE to advance directly to checking-registry.
-    useEffect(() => {
-        if (state.phase !== 'loading-tools')
-            return;
-        let cancelled = false;
-        const load = async () => {
-            if (state.nonInteractive) {
-                // Manifest tools win when present (VALIDATE_DONE only routes here when
-                // manifest tools are missing for assets — bundles short-circuit hasTools).
-                if (state.target?.type !== 'asset') {
-                    // Bundles don't carry tools — just advance.
-                    dispatch({ tools: [], type: 'RESOLVE_TOOLS_NONINTERACTIVE' });
-                    return;
-                }
-                // Try --tools flag
-                let resolvedToolList = [];
-                if (state.flags.toolsFlag) {
-                    resolvedToolList = state.flags.toolsFlag
-                        .split(',')
-                        .map((t) => t.trim())
-                        .filter(Boolean);
-                    // Validation ran before these tools were filled in, so check them here.
-                    const toolsError = await unknownToolsError(resolvedToolList);
-                    if (cancelled)
-                        return;
-                    if (toolsError) {
-                        dispatch({ message: `--tools: ${toolsError}`, type: 'ERROR' });
-                        return;
-                    }
-                }
-                // Fall back to detectCompatibleTools
-                if (resolvedToolList.length === 0) {
-                    const assetType = state.target.assetType;
-                    if (!assetType) {
-                        dispatch({
-                            message: '--tools <comma-separated> required: no tools detected for type unknown',
-                            type: 'ERROR',
-                        });
-                        return;
-                    }
-                    const detected = await detectCompatibleTools(assetType);
-                    if (cancelled)
-                        return;
-                    if (detected.length === 0) {
-                        dispatch({
-                            message: `--tools <comma-separated> required: no tools detected for type ${assetType}`,
-                            type: 'ERROR',
-                        });
-                        return;
-                    }
-                    resolvedToolList = detected;
-                }
-                dispatch({ tools: resolvedToolList, type: 'RESOLVE_TOOLS_NONINTERACTIVE' });
-                return;
-            }
-            const adapters = await loadAllAdapters();
-            if (cancelled)
-                return;
-            dispatch({ adapters, type: 'TOOLS_LOADED' });
-        };
-        load().catch((err) => {
-            if (!cancelled) {
-                dispatch(toErrorAction(err));
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-        // Phase-gated effect: only runs when entering 'loading-tools'
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [state.phase]);
-    // --- Phase: checking-registry ---
-    useEffect(() => {
-        if (state.phase !== 'checking-registry')
-            return;
-        if (!state.target)
-            return;
-        let cancelled = false;
-        const check = async () => {
-            const authToken = (await getCredential()).token;
-            if (cancelled)
-                return;
-            const reg = await fetchRegistry({ force: state.flags.refresh });
-            if (cancelled)
-                return;
-            const versionResult = checkRegistryVersion(state.target, reg);
-            if (cancelled)
-                return;
-            let isUpdate;
-            let resolvedVersion = '';
-            if (versionResult.status === 'new-asset') {
-                isUpdate = false;
-                resolvedVersion = state.target.data.version;
-            }
-            else if (versionResult.status === 'version-already-bumped') {
-                isUpdate = true;
-                resolvedVersion = state.target.data.version;
-            }
-            else {
-                // needs-bump
-                isUpdate = true;
-            }
-            if (cancelled)
-                return;
-            dispatch({
-                isUpdate,
-                resolvedVersion,
-                token: authToken,
-                type: 'REGISTRY_CHECK_DONE',
-                versionCheck: versionResult,
-            });
-        };
-        check().catch((err) => {
-            if (!cancelled) {
-                dispatch(toErrorAction(err, mapPublishError(err)));
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-        // Phase-gated effect: only runs when entering 'checking-registry'
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [state.phase]);
-    // --- Phase: checking-entries ---
-    // Validate each entry not yet checked the same way as the root asset, and check its
-    // version against the registry; advanceToPlan then settles any bump it needs.
-    useEffect(() => {
-        if (state.phase !== 'checking-entries')
-            return;
-        let cancelled = false;
-        const check = async () => {
-            let lockfileOrg;
-            try {
-                lockfileOrg = (await readLockfile(findProjectRoot(state.flags.projectRoot))).org;
-            }
-            catch {
-                // No project root / lockfile — treat as no lockfile org
-            }
-            const registry = await fetchRegistry({ force: state.flags.refresh });
-            if (cancelled)
-                return;
-            const entries = [];
-            for (const entry of state.entries) {
-                if (entry.versionCheck) {
-                    entries.push(entry);
-                    continue;
-                }
-                const validation = entry.validation ?? (await validatePublishTarget(entry.target, { force: state.flags.force, lockfileOrg }));
-                if (cancelled)
-                    return;
-                if (!validation.valid) {
-                    dispatch({
-                        message: `Validation failed for ${entry.label}:\n${validation.errors.map((e) => `  - ${e}`).join('\n')}`,
-                        type: 'ERROR',
-                    });
-                    return;
-                }
-                const versionCheck = checkRegistryVersion(entry.target, registry);
-                entries.push({
-                    ...entry,
-                    ...(versionCheck.status === 'needs-bump' ? {} : { resolvedVersion: entry.target.data.version }),
-                    validation,
-                    versionCheck,
-                });
-            }
-            dispatch({ entries, type: 'ENTRIES_CHECKED' });
-        };
-        check().catch((err) => {
-            if (!cancelled) {
-                dispatch(toErrorAction(err, mapPublishError(err)));
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-        // Phase-gated effect: only runs when entering 'checking-entries'
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [state.phase]);
-    // --- Phase: building-plan ---
-    // Plans from the targets in memory, which carry every bump and prompted tag or tool:
-    // nothing is written to a manifest until the publish succeeds (writeManifestEdits).
-    useEffect(() => {
-        if (state.phase !== 'building-plan')
-            return;
-        if (!state.target)
-            return;
-        let cancelled = false;
-        const build = async () => {
-            const currentTarget = state.target;
-            const currentVersion = state.resolvedVersion;
-            // Reject invalid reviewer usernames here, before any branch/commit/push work happens
-            const reviewers = parseReviewersInput(state.reviewerValue);
-            for (const reviewer of reviewers) {
-                const check = validateGithubUsername(reviewer);
-                if (!check.valid) {
-                    throw new Error(check.error);
-                }
-            }
-            const entries = state.entries.map((entry) => ({ label: entry.label, target: entry.target }));
-            const localPlan = await buildPublishPlan(currentTarget, currentVersion, state.isUpdate, state.flags.message, reviewers, entries, ...(isBatch(state.flags) ? [state.flags.rawPath] : []));
-            if (cancelled)
-                return;
-            // Resolve declared dependencies against the registry now, so the preview and
-            // --dry-run show them and an unresolvable one stops before the confirm prompt.
-            const publishPlan = await resolvePlanDependencies(localPlan);
-            if (cancelled)
-                return;
-            let manifestDiff;
-            if (state.isUpdate && state.versionCheck && state.versionCheck.status !== 'new-asset' && state.token) {
-                const existing = await fetchExistingManifest(currentTarget, state.versionCheck.latestVersion);
-                if (cancelled)
-                    return;
-                if (existing) {
-                    manifestDiff = diffManifests(existing, currentTarget.data);
-                }
-            }
-            dispatch({ manifestDiff, plan: publishPlan, type: 'PLAN_DONE' });
-        };
-        build().catch(async (err) => {
-            if (cancelled)
-                return;
-            // Worded like the publishing phase: resolvePlanDependencies calls the same API.
-            const error = toErrorAction(err, mapPublishError(err, entryLabels(state), batchRootLabel(state)));
-            const suggestion = await suggestSiblingEntries(state, err).catch(() => undefined);
-            if (cancelled)
-                return;
-            dispatch(suggestion ? { error, ...suggestion, type: 'SUGGEST_ENTRIES' } : error);
-        });
-        return () => {
-            cancelled = true;
-        };
-        // Phase-gated effect: only runs when entering 'building-plan'
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [state.phase]);
-    // --- Phase: publishing ---
-    useEffect(() => {
-        if (state.phase !== 'publishing')
-            return;
-        if (!state.plan || !state.token)
-            return;
-        let cancelled = false;
-        const publish = async () => {
-            const progressCallback = (msg) => {
-                if (!cancelled) {
-                    dispatch({ message: msg, type: 'PUBLISH_PROGRESS' });
-                }
-            };
-            const published = await executePublish(state.plan, progressCallback);
-            // The PR is open, so the folders take its versions, tags and tools even if the run was cancelled meanwhile.
-            const unwritten = await writeManifestEdits(state);
-            if (cancelled)
-                return;
-            const result = unwritten.length > 0 ? { ...published, warnings: [...(published.warnings ?? []), ...unwritten] } : published;
-            // Clear registry cache so subsequent commands see the new version
-            try {
-                await clearCache();
-            }
-            catch {
-                // Best-effort — don't fail publish over cache
-            }
-            // Update lockfile in-place when publishing from an installed asset
-            if (state.flags.fromInstalled || state.flags.update) {
-                try {
-                    const projectRoot = findProjectRoot(state.flags.projectRoot);
-                    const pubTools = await resolveTools(state.flags.tool);
-                    const pubAdapter = pubTools[0].adapter;
-                    await withLockfileLock(projectRoot, async () => {
-                        const lockfile = await readLockfile(projectRoot);
-                        const { name, org } = parseOrgFromName(state.flags.rawPath);
-                        const installed = findInstalledAsset(lockfile, name, undefined, org);
-                        if (installed) {
-                            const resolved = resolveInstalledPaths(installed, pubAdapter, projectRoot);
-                            const updatedFiles = await Promise.all(resolved.files.map(async (file) => ({
-                                checksum: await hashFile(join(projectRoot, file.installedPath)),
-                                sourcePath: file.sourcePath,
-                            })));
-                            const updatedLockfile = addAssetToLockfile(lockfile, {
-                                ...installed,
-                                files: updatedFiles,
-                                version: state.resolvedVersion,
-                            });
-                            await writeLockfile(projectRoot, updatedLockfile);
-                        }
-                    });
-                }
-                catch {
-                    // Best-effort — don't fail publish over lockfile update
-                }
-            }
-            if (cancelled)
-                return;
-            dispatch({ result, type: 'PUBLISH_DONE' });
-        };
-        publish().catch((err) => {
-            if (!cancelled) {
-                dispatch(toErrorAction(err, mapPublishError(err, entryLabels(state), batchRootLabel(state))));
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-        // Phase-gated effect: only runs when entering 'publishing'
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [state.phase]);
-    // --- Phase: installing (auto-install raw publish to lockfile) ---
-    useEffect(() => {
-        if (state.phase !== 'installing')
-            return;
-        let cancelled = false;
-        const install = async () => {
-            try {
-                const projectRoot = findProjectRoot(state.flags.projectRoot);
-                await withLockfileLock(projectRoot, async () => {
-                    // Read current lockfile
-                    const lockfile = await readLockfile(projectRoot);
-                    // Compute checksums from actual project files (not staging copies)
-                    const files = [];
-                    for (const file of state.rawDetection.files) {
-                        const checksum = await hashFile(file.absolutePath);
-                        files.push({
-                            checksum,
-                            sourcePath: file.relativePath,
-                        });
-                    }
-                    // Build InstalledAsset entry
-                    const installedAsset = {
-                        files,
-                        installReason: 'direct',
-                        name: state.rawDetection.name,
-                        org: state.orgValue || undefined,
-                        type: state.rawDetection.assetType,
-                        version: state.resolvedVersion || state.target?.data.version || '1.0.0',
-                    };
-                    // Add to lockfile and write
-                    const updatedLockfile = addAssetToLockfile(lockfile, installedAsset);
-                    await writeLockfile(projectRoot, updatedLockfile);
-                });
-                if (!cancelled) {
-                    dispatch({ type: 'INSTALL_DONE' });
-                }
-            }
-            catch {
-                // Publish already succeeded, so just warn and move to done
-                if (!cancelled) {
-                    dispatch({ type: 'INSTALL_DONE' });
-                }
-            }
-        };
-        install();
-        return () => {
-            cancelled = true;
-        };
-        // Phase-gated effect: only runs when entering 'installing'
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [state.phase]);
     // --- Cleanup temp directory on error or done ---
     useEffect(() => {
         if (state.phase !== 'error' && state.phase !== 'done' && state.phase !== 'dry-run-result')
             return;
-        if (tempDirRef.current) {
-            const dir = tempDirRef.current;
-            tempDirRef.current = null;
-            rm(dir, { force: true, recursive: true }).catch(() => {
-                // Best-effort cleanup — ignore errors
-            });
-        }
+        removeStagingDirs(stagingDirs.current);
     }, [state.phase]);
+    // --- ...or when the command goes away before either ---
+    useEffect(() => () => {
+        unmounted.current = true;
+        removeStagingDirs(stagingDirs.current);
+    }, []);
     return [state, dispatch];
 }
 // ---------------------------------------------------------------------------
-// Pure reducer
+// Pure reducer helpers
 // ---------------------------------------------------------------------------
 /**
  * The step before `building-plan`, once the root asset's own checks are done:
@@ -1361,27 +550,6 @@ function advanceToPlan(state) {
     }
     return bumpEntryAt(state, index, state.flags.bump);
 }
-/** Why the flags can't publish a batch: one installed asset, or one asset's metadata. Undefined otherwise. */
-function batchFlagError(flags) {
-    if (!isBatch(flags))
-        return undefined;
-    if (flags.update || flags.fromInstalled) {
-        return `${flags.update ? '--update' : '--from-installed'} publishes one installed asset; leave it out to publish several folders.`;
-    }
-    const perAsset = [
-        ['--description', flags.descriptionFlag],
-        ['--tags', flags.tagsFlag],
-        ['--tools', flags.toolsFlag],
-    ].flatMap(([flag, value]) => (value === undefined ? [] : [flag]));
-    if (perAsset.length > 0) {
-        return `${perAsset.join(', ')} ${perAsset.length === 1 ? 'sets' : 'set'} one asset's metadata; put it in each folder's manifest.json to publish several folders.`;
-    }
-    return undefined;
-}
-/** In a batch, what the API calls `Root asset`, as the folder the user named. */
-function batchRootLabel(state) {
-    return isBatch(state.flags) ? state.flags.rawPath : undefined;
-}
 /**
  * Bump the entry at `index` from its registry version, then go on toward the
  * plan; an error state, as for the root, when the version can't be bumped.
@@ -1399,25 +567,6 @@ function bumpEntryAt(state, index, bump) {
     }
     return advanceToPlan({ ...state, entries: replaceEntry(state.entries, index, withVersion(entry, version)) });
 }
-/** What the API calls `dependencies[i]`, as the folder the user named. */
-function entryLabels(state) {
-    return state.entries.map((entry) => entry.label);
-}
-// ---------------------------------------------------------------------------
-// Hook
-// ---------------------------------------------------------------------------
-/** Run the writes in order until one throws: its index and error, or undefined when all succeed. */
-async function firstFailure(edits) {
-    for (const [index, edit] of edits.entries()) {
-        try {
-            await edit.write();
-        }
-        catch (error) {
-            return { error, index };
-        }
-    }
-    return undefined;
-}
 /**
  * Phase to enter once the tags/tools metadata prompts are resolved: org-scoped
  * targets get the reviewer prompt, everything else proceeds to the registry check.
@@ -1428,42 +577,6 @@ function phaseAfterMetadata(target) {
 function replaceEntry(entries, index, entry) {
     return entries.map((current, i) => (i === index ? entry : current));
 }
-/**
- * Folders next to the root asset that could fix the plan's error: an interactive
- * run, a `422` naming root dependencies that aren't in the registry (or have no
- * matching version), and a sibling folder whose manifest has the same type and
- * name that isn't an entry yet. Undefined when there is nothing to offer.
- * `--update` and `--from-installed` roots live in a temp folder, so they never get offers.
- */
-async function suggestSiblingEntries(state, err) {
-    const { target } = state;
-    if (state.nonInteractive ||
-        state.flags.fromInstalled ||
-        state.flags.update ||
-        target?.type !== 'asset' ||
-        !(isApiError(err, 'dependency_not_found') || isApiError(err, 'dependency_version_unsatisfied'))) {
-        return undefined;
-    }
-    const included = (d) => state.entries.some((e) => e.target.assetType === d.type && e.target.data.name === d.name);
-    const missing = missingDependencies(target.data, err.issues).filter((d) => !included(d));
-    if (missing.length === 0)
-        return undefined;
-    const rootDir = state.rawDetection?.sourceDir ?? target.sourceDir;
-    const suggested = await findSiblingDependencies(rootDir, missing, state.entries.map((e) => e.target.sourceDir), target.data.org);
-    return suggested.length > 0 ? { missing, suggested } : undefined;
-}
-/**
- * Build an ERROR dispatch action from a caught value, carrying the `code`,
- * `hint` and `command` typed errors have so commands can render actionable
- * recovery guidance.
- */
-function toErrorAction(err, override) {
-    return {
-        ...errorGuidance(err),
-        message: override ?? errorMessage(err),
-        type: 'ERROR',
-    };
-}
 /** The entry published at `version`; a successful publish writes it to the entry's manifest. */
 function withVersion(entry, version) {
     return {
@@ -1472,52 +585,4 @@ function withVersion(entry, version) {
         target: { ...entry.target, data: { ...entry.target.data, version } },
     };
 }
-/**
- * Write what the run changed in memory to the manifests on disk: the root's bump and each
- * entry's, and the tags and tools the prompts asked for. Only once the publish has opened its
- * PR, so a cancelled or failed one leaves every manifest as it was. A file whose write fails
- * takes none of its later edits and comes back as one warning naming the fields it lacks; the
- * other files are still written.
- */
-async function writeManifestEdits(state) {
-    const target = state.target;
-    if (!target)
-        return [];
-    const files = new Map();
-    const edit = (dir, file, field, value, write) => {
-        const path = join(dir, file);
-        files.set(path, [...(files.get(path) ?? []), { field, value, write }]);
-    };
-    const version = (dir, file, value) => edit(dir, file, 'version', value, () => updateManifestVersion(dir, file, value));
-    const field = (name, value) => edit(target.sourceDir, 'manifest.json', name, value, () => updateManifestField(target.sourceDir, 'manifest.json', name, value));
-    if (state.versionCheck?.status === 'needs-bump' && state.resolvedVersion) {
-        version(target.sourceDir, target.type === 'asset' ? 'manifest.json' : 'bundle.json', state.resolvedVersion);
-    }
-    // Only an asset's manifest.json takes the prompted tags and tools, as the target (and so the plan) has them.
-    if (target.type === 'asset') {
-        const { tags, tools } = target.data;
-        if (state.promptTagsValue && tags && tags.length > 0) {
-            field('tags', tags);
-        }
-        if (state.selectedPromptTools.length > 0) {
-            field('tools', tools);
-        }
-    }
-    for (const entry of state.entries) {
-        if (entry.versionCheck?.status === 'needs-bump' && entry.resolvedVersion) {
-            version(entry.target.sourceDir, 'manifest.json', entry.resolvedVersion);
-        }
-    }
-    const unwritten = [];
-    for (const [path, edits] of files) {
-        const failed = await firstFailure(edits);
-        if (!failed)
-            continue;
-        const missing = edits.slice(failed.index);
-        // Only the version matters to the next publish: it asks for missing tags and tools again.
-        const again = missing.some((e) => e.field === 'version') ? ' before you publish it again' : '';
-        unwritten.push(`The PR is open, but ${path} wasn't updated (${errorMessage(failed.error)}): set ${missing.map((e) => `"${e.field}" to ${JSON.stringify(e.value)}`).join(', ')}${again}.`);
-    }
-    return unwritten;
-}
 //# sourceMappingURL=usePublishState.js.map