@contentful/experience-design-system-cli 2.12.0 → 2.12.1-dev-build-589b615.0

package/dist/src/import/tui/auto-filter-error.d.ts

@@ -0,0 +1,2 @@
+export declare function stripAnsi(s: string): string;
+export declare function buildAutoFilterErrorTail(raw: string): string;

package/dist/src/import/tui/auto-filter-error.js

@@ -0,0 +1,29 @@
+// Pure helpers for shaping the auto-filter subprocess stderr stream into a
+// human-readable error tail. The auto-filter (select-agent) subprocess emits
+// three classes of lines on stderr:
+//
+//   1. `progress=...` machine-parseable progress lines consumed by the wizard
+//      to drive `aiDecisions` / `aiFilterProgress` state.
+//   2. `[N/total] Name <verb> ...` per-component status lines (human-readable
+//      mirror of the progress emission).
+//   3. Free-form error output — what we actually want to surface on failure.
+//
+// `buildAutoFilterErrorTail` strips classes (1) and (2) plus ANSI color
+// escapes, then returns the last 3 lines joined with " / " (matching the
+// pre-existing tail format in WizardApp.tsx).
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+const PROGRESS_RE = /^progress=/;
+const PER_COMPONENT_RE = /\[\d+\/\d+\]/;
+export function stripAnsi(s) {
+    return s.replace(ANSI_RE, '');
+}
+function isStructured(line) {
+    return PROGRESS_RE.test(line) || PER_COMPONENT_RE.test(line);
+}
+export function buildAutoFilterErrorTail(raw) {
+    const lines = raw
+        .split('\n')
+        .map((l) => stripAnsi(l.trim()))
+        .filter((l) => l.length > 0 && !isStructured(l));
+    return lines.slice(-3).join(' / ');
+}

package/dist/src/import/tui/final-review-host.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+export type FinalReviewHostProps = {
+    extractSessionId: string | null;
+    generatedCount: number;
+    autoAccept: boolean;
+    onFinalize: (accepted: number, rejected: number, unresolved: number) => void;
+    onQuit: () => void;
+    livePreview?: boolean;
+    spaceId?: string;
+    environmentId?: string;
+    cmaToken?: string;
+    host?: string;
+    tokensPath?: string;
+};
+export declare function FinalReviewHost({ extractSessionId, generatedCount, autoAccept, onFinalize, onQuit, livePreview, spaceId, environmentId, cmaToken, host, tokensPath, }: FinalReviewHostProps): React.ReactElement;

package/dist/src/import/tui/final-review-host.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import React from 'react';
+import { GenerateReviewStep } from './steps/GenerateReviewStep.js';
+export function FinalReviewHost({ extractSessionId, generatedCount, autoAccept, onFinalize, onQuit, livePreview, spaceId, environmentId, cmaToken, host, tokensPath, }) {
+    if (!extractSessionId) {
+        return (_jsx(Box, { paddingX: 2, paddingY: 1, children: _jsx(Text, { color: "red", children: "Error: no session ID \u2014 cannot load generated definitions." }) }));
+    }
+    if (autoAccept) {
+        return _jsx(FinalReviewAutoAccept, { generatedCount: generatedCount, onFinalize: onFinalize });
+    }
+    return (_jsx(GenerateReviewStep, { extractSessionId: extractSessionId, onFinalize: onFinalize, onQuit: onQuit, livePreview: livePreview, spaceId: spaceId, environmentId: environmentId, cmaToken: cmaToken, host: host, tokensPath: tokensPath }));
+}
+function FinalReviewAutoAccept({ generatedCount, onFinalize, }) {
+    React.useEffect(() => {
+        onFinalize(generatedCount, 0, 0);
+        // fire once on mount; deps intentionally empty so a re-render with new generatedCount doesn't double-finalize
+    }, []);
+    return (_jsx(Box, { paddingX: 2, paddingY: 1, children: _jsxs(Text, { dimColor: true, children: ["Auto-accepting ", generatedCount, " generated components..."] }) }));
+}

package/dist/src/import/tui/push-decision-gate-helpers.d.ts

@@ -0,0 +1,8 @@
+import type { PushDecisionChoice } from './steps/PushDecisionGateStep.js';
+export type GateAction = 'save-and-push' | 'push-only' | 'save-only';
+/**
+ * Maps a `PushDecisionGateStep` choice to the wizard action it triggers.
+ * Centralizing this keeps the gate component free of wizard-side semantics
+ * and gives us a unit-testable seam between UI choice and side-effect.
+ */
+export declare function chooseGateAction(choice: PushDecisionChoice): GateAction;

package/dist/src/import/tui/push-decision-gate-helpers.js

@@ -0,0 +1,8 @@
+/**
+ * Maps a `PushDecisionGateStep` choice to the wizard action it triggers.
+ * Centralizing this keeps the gate component free of wizard-side semantics
+ * and gives us a unit-testable seam between UI choice and side-effect.
+ */
+export function chooseGateAction(choice) {
+    return choice === 'both' ? 'save-and-push' : choice;
+}

package/dist/src/import/tui/push-progress.d.ts

@@ -0,0 +1,23 @@
+import type { ServerPreviewResponse } from '@contentful/experience-design-system-types';
+export type PushExpected = {
+    componentTypes: {
+        create: number;
+        update: number;
+        remove: number;
+    };
+    designTokens: {
+        create: number;
+        update: number;
+        remove: number;
+    };
+};
+export type PushProgress = {
+    kind: 'queued';
+    operationId: string;
+} | {
+    kind: 'progress';
+    processed: number;
+    total: number;
+    current: string | null;
+} | null;
+export declare function computePushExpected(preview: ServerPreviewResponse): PushExpected;

package/dist/src/import/tui/push-progress.js

@@ -0,0 +1,14 @@
+export function computePushExpected(preview) {
+    return {
+        componentTypes: {
+            create: preview.components?.new?.length ?? 0,
+            update: preview.components?.changed?.length ?? 0,
+            remove: preview.components?.removed?.length ?? 0,
+        },
+        designTokens: {
+            create: preview.tokens?.new?.length ?? 0,
+            update: preview.tokens?.changed?.length ?? 0,
+            remove: preview.tokens?.removed?.length ?? 0,
+        },
+    };
+}

package/dist/src/import/tui/run-print-files-helpers.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Computes the wizard state patch applied after `runPrintFiles` successfully
+ * writes components.json. Default behavior transitions to the print-gate
+ * confirm screen. When `skipGate: true` is passed (used by the "save AND push"
+ * path), the transition is suppressed so the caller can chain into
+ * `runPreview` without an intermediate gate render.
+ *
+ * When `outDir` is provided (Task 4 — operator chose a custom save path via
+ * the inline path-prompt), it is folded into the patch so the wizard's
+ * `state.outDir` reflects the chosen path. Subsequent reads (e.g. the
+ * appendRun call, the print-gate's summary) pick it up automatically.
+ */
+export type NextStateAfterPrintInput = {
+    skipGate?: boolean;
+    componentsPath: string;
+    outDir?: string;
+};
+export type NextStateAfterPrintOutput = {
+    componentsPath: string;
+    outDir?: string;
+} | {
+    step: 'print-gate';
+    componentsPath: string;
+    outDir?: string;
+};
+export declare function nextStateAfterPrint(opts: NextStateAfterPrintInput): NextStateAfterPrintOutput;

package/dist/src/import/tui/run-print-files-helpers.js

@@ -0,0 +1,8 @@
+export function nextStateAfterPrint(opts) {
+    const base = opts.outDir
+        ? { componentsPath: opts.componentsPath, outDir: opts.outDir }
+        : { componentsPath: opts.componentsPath };
+    if (opts.skipGate)
+        return base;
+    return { step: 'print-gate', ...base };
+}

package/dist/src/import/tui/run-teaser.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Task 8 — one-line teaser appended at the end of every successful run.
+ * Format pinned in dsi-tui-local-save-tooling-spec.md Part 6.
+ */
+export declare function buildRunTeaserLine(runId: string | null | undefined): string;

package/dist/src/import/tui/run-teaser.js

@@ -0,0 +1,9 @@
+/**
+ * Task 8 — one-line teaser appended at the end of every successful run.
+ * Format pinned in dsi-tui-local-save-tooling-spec.md Part 6.
+ */
+export function buildRunTeaserLine(runId) {
+    if (!runId)
+        return '';
+    return `Run saved as ${runId} — push to Contentful with 'experiences import --push-from-run ${runId}' or modify with 'experiences import --modify ${runId}'.`;
+}

package/dist/src/import/tui/runLivePreview.d.ts

@@ -0,0 +1,35 @@
+import type { ServerPreviewResponse } from '@contentful/experience-design-system-types';
+export declare class TimeoutError extends Error {
+    constructor(message?: string);
+}
+export type LivePreviewResult = {
+    generation: number;
+    response: ServerPreviewResponse | null;
+};
+export type RunLivePreviewOptions = {
+    sessionId: string;
+    tokensPath: string;
+    spaceId: string;
+    environmentId: string;
+    cmaToken: string;
+    host: string;
+    generation: number;
+    timeoutMs?: number;
+};
+/**
+ * Pure async helper used by `useLivePreview` to re-fire `previewImport` after a
+ * FieldEditor save in the wizard's final-review step. Mirrors the round-1
+ * `runScopeGate` shape: a side-effect-bearing pure orchestrator that owns no
+ * React state.
+ *
+ * Skips silently (returns `{ response: null }`) when any of `spaceId`,
+ * `environmentId`, or `cmaToken` is missing — live preview is an enhancement
+ * and the caller treats `null` as a no-op. Throws on API errors so the caller
+ * (`useLivePreview`) can downgrade to local-only mode on 401/403 and log a
+ * warning otherwise. Wraps the API call in a timeout so a hung backend doesn't
+ * leave the spinner stuck.
+ *
+ * Does NOT run the second-pass seeding from `WizardApp.runPreview`; that's a
+ * one-shot wizard-step concern and would re-seed on every save.
+ */
+export declare function runLivePreview(opts: RunLivePreviewOptions): Promise<LivePreviewResult>;

package/dist/src/import/tui/runLivePreview.js

@@ -0,0 +1,73 @@
+import { buildManifest } from '@contentful/experience-design-system-types';
+import { ImportApiClient } from '../../apply/api-client.js';
+import { readTokensFromPath } from '../../apply/manifest.js';
+import { backfillUnclassifiedProps, loadCDFComponents, openPipelineDb } from '../../session/db.js';
+export class TimeoutError extends Error {
+    constructor(message = 'live-preview timed out') {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}
+const DEFAULT_TIMEOUT_MS = 15_000;
+/**
+ * Pure async helper used by `useLivePreview` to re-fire `previewImport` after a
+ * FieldEditor save in the wizard's final-review step. Mirrors the round-1
+ * `runScopeGate` shape: a side-effect-bearing pure orchestrator that owns no
+ * React state.
+ *
+ * Skips silently (returns `{ response: null }`) when any of `spaceId`,
+ * `environmentId`, or `cmaToken` is missing — live preview is an enhancement
+ * and the caller treats `null` as a no-op. Throws on API errors so the caller
+ * (`useLivePreview`) can downgrade to local-only mode on 401/403 and log a
+ * warning otherwise. Wraps the API call in a timeout so a hung backend doesn't
+ * leave the spinner stuck.
+ *
+ * Does NOT run the second-pass seeding from `WizardApp.runPreview`; that's a
+ * one-shot wizard-step concern and would re-seed on every save.
+ */
+export async function runLivePreview(opts) {
+    const { sessionId, tokensPath, spaceId, environmentId, cmaToken, host, generation } = opts;
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    if (!spaceId || !environmentId || !cmaToken) {
+        return { generation, response: null };
+    }
+    let components = [];
+    if (sessionId) {
+        const db = openPipelineDb();
+        try {
+            backfillUnclassifiedProps(db, sessionId);
+            components = loadCDFComponents(db, sessionId);
+        }
+        finally {
+            db.close();
+        }
+    }
+    let tokens = [];
+    if (tokensPath) {
+        tokens = await readTokensFromPath('tokens', tokensPath);
+    }
+    const manifest = buildManifest(components, tokens);
+    const client = new ImportApiClient({ host, cmaToken, spaceId, environmentId });
+    const startedAt = Date.now();
+    let timeoutHandle;
+    const timeoutPromise = new Promise((_resolve, reject) => {
+        timeoutHandle = setTimeout(() => reject(new TimeoutError()), timeoutMs);
+    });
+    try {
+        const response = (await Promise.race([client.previewImport(manifest), timeoutPromise]));
+        if (process.env['EDS_VERBOSE']) {
+            const durationMs = Date.now() - startedAt;
+            try {
+                process.stderr.write(`live-preview: ${durationMs}ms\n`);
+            }
+            catch {
+                // best-effort
+            }
+        }
+        return { generation, response };
+    }
+    finally {
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+    }
+}

package/dist/src/import/tui/runScopeGate.d.ts

@@ -0,0 +1,22 @@
+export declare function runScopeGate(opts: {
+    sessionId: string;
+    decisions: {
+        accepted: string[];
+        rejected: string[];
+    };
+    /**
+     * Optional cancellation hook for the auto-filter (`select-agent`) subprocess.
+     * If supplied, it will be awaited BEFORE the review-state snapshot is written
+     * so the operator's full decision set is the last writer to the snapshot
+     * file. Without this gate the subprocess can race the operator's confirm
+     * (see PR #43): if select-agent finishes a batch after the operator presses
+     * `f`, it overwrites the snapshot with a partial view and components silently
+     * disappear from final-review. Resolves when the subprocess has exited.
+     */
+    cancelAutoFilter?: () => Promise<void> | void;
+    onAdvanceToGenerate: (info: {
+        sessionId: string;
+        acceptedCount: number;
+    }) => Promise<void> | void;
+    onAdvanceToPushFlow: (acceptedCount: number) => Promise<void> | void;
+}): Promise<void>;

package/dist/src/import/tui/runScopeGate.js

@@ -0,0 +1,28 @@
+import { writeScopeDecisionsSnapshot } from '../../analyze/select/persistence.js';
+import { applyScopeDecisions, openPipelineDb } from '../../session/db.js';
+export async function runScopeGate(opts) {
+    // Cancel-and-await BEFORE any DB / snapshot write. The subprocess's
+    // in-flight write may complete before SIGTERM lands; that's fine — we wait
+    // for it to fully exit, then our authoritative write goes last.
+    if (opts.cancelAutoFilter) {
+        await opts.cancelAutoFilter();
+    }
+    const db = openPipelineDb();
+    try {
+        applyScopeDecisions(db, opts.sessionId, opts.decisions);
+        // Also persist a review-state snapshot so `generate components` can filter
+        // out rejected components via loadAcceptedNames. Without this the wizard's
+        // scope-gate decisions never reach the generator and rejected components
+        // get processed by the LLM anyway.
+        await writeScopeDecisionsSnapshot(db, opts.sessionId, opts.decisions);
+    }
+    finally {
+        db.close();
+    }
+    if (opts.decisions.accepted.length > 0) {
+        await opts.onAdvanceToGenerate({ sessionId: opts.sessionId, acceptedCount: opts.decisions.accepted.length });
+    }
+    else {
+        await opts.onAdvanceToPushFlow(0);
+    }
+}

package/dist/src/import/tui/scope-gate-host.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import type { ScopeComponent } from './steps/ScopeGateStep.js';
+export type { ScopeComponent };
+export type AutoFilterStatus = 'idle' | 'running' | 'complete' | 'cancelled' | 'failed';
+export type ScopeGateHostProps = {
+    components: ReadonlyArray<ScopeComponent>;
+    autoAccept: boolean;
+    onConfirm: (decisions: {
+        accepted: string[];
+        rejected: string[];
+    }) => void;
+    onQuit: () => void;
+    aiFilterStatus?: AutoFilterStatus;
+    aiFilterProgress?: {
+        done: number;
+        total: number;
+    } | null;
+    aiFilterError?: string | null;
+    onCancelAutoFilter?: () => void;
+};
+export declare function ScopeGateHost({ components, autoAccept, onConfirm, onQuit, aiFilterStatus, aiFilterProgress, aiFilterError, onCancelAutoFilter, }: ScopeGateHostProps): React.ReactElement;

package/dist/src/import/tui/scope-gate-host.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import React from 'react';
+import { ScopeGateStep } from './steps/ScopeGateStep.js';
+export function ScopeGateHost({ components, autoAccept, onConfirm, onQuit, aiFilterStatus = 'idle', aiFilterProgress = null, aiFilterError = null, onCancelAutoFilter, }) {
+    if (components.length === 0) {
+        return (_jsx(Box, { paddingX: 2, paddingY: 1, children: _jsx(Text, { color: "red", children: "Error: no components found for this session \u2014 please re-run analyze extract." }) }));
+    }
+    if (autoAccept) {
+        return _jsx(ScopeGateAutoAccept, { components: components, onConfirm: onConfirm });
+    }
+    return (_jsx(ScopeGateStep, { components: [...components], onConfirm: onConfirm, onQuit: onQuit, aiFilterStatus: aiFilterStatus, aiFilterProgress: aiFilterProgress, aiFilterError: aiFilterError, onCancelAutoFilter: onCancelAutoFilter }));
+}
+function ScopeGateAutoAccept({ components, onConfirm, }) {
+    React.useEffect(() => {
+        onConfirm({ accepted: components.map((c) => c.name), rejected: [] });
+        // fire once on mount; deps intentionally empty so a re-render with new components doesn't double-confirm
+    }, []);
+    return (_jsx(Box, { paddingX: 2, paddingY: 1, children: _jsxs(Text, { dimColor: true, children: ["Auto-accepting ", components.length, " components..."] }) }));
+}

package/dist/src/import/tui/spawn-generate.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Extracted spawn helper for the `generate components` subprocess.
+ *
+ * Why this exists: the wizard now kicks off generation from TWO call sites —
+ * the post-credentials path (`runGenerate`) AND a pre-fetch from scope-gate
+ * confirm (Change 2 in the prefetch spec). Both need the same spawn-and-stream
+ * behavior but the await-on-exit happens at different times. Keeping `runGenerate`
+ * as a thin wrapper around this helper lets the pre-fetch path stash the
+ * `donePromise` in a ref and resolve it later.
+ *
+ * Subprocess hygiene: we listen for 'close' (not 'exit') when surfacing the
+ * final result so the child's stdio + any inherited file handles (e.g. the
+ * pipeline SQLite WAL/SHM) have been fully released by the OS before the
+ * wizard re-enters that path. This applies the same lesson as
+ * fix/auto-filter-db-lock.
+ */
+import { type ChildProcess } from 'node:child_process';
+export type SpawnGenerateResult = {
+    exitCode: number;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+};
+export type SpawnGenerateOpts = {
+    command: string;
+    args: string[];
+    onStderr?: (chunk: string) => void;
+    onStdout?: (chunk: string) => void;
+};
+export declare function spawnGenerateChild(opts: SpawnGenerateOpts): {
+    child: ChildProcess;
+    donePromise: Promise<SpawnGenerateResult>;
+};

package/dist/src/import/tui/spawn-generate.js

@@ -0,0 +1,53 @@
+/**
+ * Extracted spawn helper for the `generate components` subprocess.
+ *
+ * Why this exists: the wizard now kicks off generation from TWO call sites —
+ * the post-credentials path (`runGenerate`) AND a pre-fetch from scope-gate
+ * confirm (Change 2 in the prefetch spec). Both need the same spawn-and-stream
+ * behavior but the await-on-exit happens at different times. Keeping `runGenerate`
+ * as a thin wrapper around this helper lets the pre-fetch path stash the
+ * `donePromise` in a ref and resolve it later.
+ *
+ * Subprocess hygiene: we listen for 'close' (not 'exit') when surfacing the
+ * final result so the child's stdio + any inherited file handles (e.g. the
+ * pipeline SQLite WAL/SHM) have been fully released by the OS before the
+ * wizard re-enters that path. This applies the same lesson as
+ * fix/auto-filter-db-lock.
+ */
+import { spawn } from 'node:child_process';
+export function spawnGenerateChild(opts) {
+    const child = spawn(opts.command, opts.args);
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.on('data', (d) => {
+        const chunk = String(d);
+        stdout += chunk;
+        opts.onStdout?.(chunk);
+    });
+    child.stderr?.on('data', (d) => {
+        const chunk = String(d);
+        stderr += chunk;
+        opts.onStderr?.(chunk);
+    });
+    const donePromise = new Promise((resolve) => {
+        // Use 'close' rather than 'exit' so stdio drains and any inherited file
+        // handles are released before downstream code reacts.
+        child.on('close', (code, signal) => {
+            resolve({
+                exitCode: code ?? 0,
+                signal: signal ?? null,
+                stdout,
+                stderr,
+            });
+        });
+        child.on('error', (err) => {
+            resolve({
+                exitCode: 1,
+                signal: null,
+                stdout,
+                stderr: stderr + (err.message ?? String(err)),
+            });
+        });
+    });
+    return { child, donePromise };
+}

package/dist/src/import/tui/steps/CredentialsStep.d.ts

@@ -6,11 +6,35 @@ type CredentialsStepProps = {
     initialEnvironmentId?: string;
     initialCmaToken?: string;
     initialHost?: string;
+    /**
+     * When true, the credentials screen stays mounted but locks input and shows
+     * an inline "Validating credentials..." status. Replaces the previous
+     * dedicated `validating-credentials` render screen so the operator sees a
+     * continuous credentials surface instead of a transient loading screen
+     * (Change 1 of the wizard prefetch refactor).
+     */
+    validating?: boolean;
+    /** Inline status describing in-flight background generation prefetch. */
+    generatePrefetchStatus?: 'idle' | 'running' | 'complete' | 'failed';
+    /** Error message from a failed generation prefetch (rendered as a banner). */
+    generatePrefetchError?: string | null;
     /** Called when the user submits with any field changed from its initial value */
     onConfirm: (spaceId: string, environmentId: string, cmaToken: string, host: string) => void;
     /** Called when the user submits without changing any field (use existing creds as-is) */
     onContinue?: (spaceId: string, environmentId: string, cmaToken: string, host: string) => void;
     onQuit: () => void;
+    /**
+     * Optional retry callback wired up when a background generation prefetch
+     * failed mid-credentials-entry. The operator presses R to re-trigger.
+     */
+    onRetryPrefetch?: () => void;
+    /**
+     * Skip-credentials escape hatch. When pressed (via `s` keybind, gated
+     * against text-entry mode), the wizard advances without validating
+     * credentials and disables push downstream. See dsi-tui-skip-credentials
+     * spec.
+     */
+    onSkip?: () => void;
 };
-export declare function CredentialsStep({ summary, error: externalError, initialSpaceId, initialEnvironmentId, initialCmaToken, initialHost, onConfirm, onContinue, onQuit, }: CredentialsStepProps): React.ReactElement;
+export declare function CredentialsStep({ summary, error: externalError, initialSpaceId, initialEnvironmentId, initialCmaToken, initialHost, validating, generatePrefetchStatus, generatePrefetchError, onConfirm, onContinue, onQuit, onRetryPrefetch, onSkip, }: CredentialsStepProps): React.ReactElement;
 export {};

package/dist/src/import/tui/steps/CredentialsStep.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useRef } from 'react';
 import { Box, Text } from 'ink';
 import { useImmediateInput } from '../../../analyze/select/tui/hooks/useImmediateInput.js';
 import { DEFAULT_CONFIGURED_HOST, toConfiguredHost } from '../../../host-utils.js';
-export function CredentialsStep({ summary, error: externalError, initialSpaceId = '', initialEnvironmentId = 'master', initialCmaToken = '', initialHost, onConfirm, onContinue, onQuit, }) {
+export function CredentialsStep({ summary, error: externalError, initialSpaceId = '', initialEnvironmentId = 'master', initialCmaToken = '', initialHost, validating = false, generatePrefetchStatus = 'idle', generatePrefetchError = null, onConfirm, onContinue, onQuit, onRetryPrefetch, onSkip, }) {
     const normalizedInitialHost = toConfiguredHost(initialHost) ?? DEFAULT_CONFIGURED_HOST;
     const [spaceId, setSpaceId] = useState(initialSpaceId);
     const [environmentId, setEnvironmentId] = useState(initialEnvironmentId);
@@ -12,11 +12,28 @@ export function CredentialsStep({ summary, error: externalError, initialSpaceId
     const [activeField, setActiveField] = useState('spaceId');
     const [inlineError, setInlineError] = useState(null);
     const [cursorVisible, setCursorVisible] = useState(true);
+    // Tracks whether the operator has typed any printable character into a
+    // form field since mount. While false, the `s` keybind is interpreted as
+    // the skip-credentials shortcut. Once the operator has begun typing, `s`
+    // is routed into the active field as input (we don't want to swallow a
+    // legitimate letter in a space ID / token / host).
+    const hasTypedRef = useRef(false);
     useEffect(() => {
         const interval = setInterval(() => setCursorVisible((v) => !v), 500);
         return () => clearInterval(interval);
     }, []);
     useImmediateInput((input, key) => {
+        // While we are validating credentials, the screen stays mounted but the
+        // form is locked — any input is dropped. The exception is `R` when a
+        // prefetch failed and we expose a retry hook (so the operator can recover
+        // without backing out of the wizard).
+        if (validating) {
+            return;
+        }
+        if ((input === 'r' || input === 'R') && generatePrefetchStatus === 'failed' && onRetryPrefetch) {
+            onRetryPrefetch();
+            return;
+        }
         if (key.return) {
             if (activeField === 'spaceId') {
                 setActiveField('environmentId');
@@ -57,6 +74,14 @@ export function CredentialsStep({ summary, error: externalError, initialSpaceId
             onQuit();
             return;
         }
+        // Skip-credentials shortcut. Gated against text-entry mode so the letter
+        // 's' can still be typed into a form field once the operator has begun
+        // editing. The legend hint is always rendered (see below) so operators
+        // know the escape hatch exists from the moment the screen mounts.
+        if ((input === 's' || input === 'S') && onSkip && !hasTypedRef.current) {
+            onSkip();
+            return;
+        }
         if (key.backspace || key.delete) {
             if (activeField === 'spaceId')
                 setSpaceId((v) => v.slice(0, -1));
@@ -69,6 +94,7 @@ export function CredentialsStep({ summary, error: externalError, initialSpaceId
             return;
         }
         if (input && !key.ctrl && !key.meta) {
+            hasTypedRef.current = true;
             if (activeField === 'spaceId')
                 setSpaceId((v) => v + input);
             else if (activeField === 'environmentId')
@@ -89,5 +115,7 @@ export function CredentialsStep({ summary, error: externalError, initialSpaceId
     const displayError = inlineError ?? externalError ?? null;
     return (_jsxs(Box, { flexDirection: "column", gap: 1, paddingX: 2, paddingY: 1, children: [summary && _jsxs(Text, { color: "green", children: ["\u2713 ", summary] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: initialSpaceId && initialCmaToken
                         ? 'Credentials pre-filled from experiences setup. Press Enter to continue or edit any field to update.'
-                        : 'Enter your Contentful credentials to continue.' }) }), !(initialSpaceId && initialCmaToken) && (_jsx(Text, { dimColor: true, children: "Tip: run experiences setup to save these to ~/.config/experiences/credentials.json so they pre-fill here automatically." })), _jsxs(Box, { flexDirection: "column", gap: 0, marginTop: 1, children: [renderField('Space ID', spaceId, 'spaceId'), renderField('Environment', environmentId, 'environmentId'), renderField('CMA Token', cmaToken, 'cmaToken', true), renderField('API Host', host, 'host')] }), activeField === 'host' && _jsx(Text, { dimColor: true, children: "Default: api.contentful.com \u00B7 EU spaces: api.eu.contentful.com" }), displayError && _jsxs(Text, { color: "red", children: ["\u2717 ", displayError] }), _jsxs(Box, { gap: 3, marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "[Enter] Next field / Submit" }), _jsx(Text, { dimColor: true, children: "[Tab] Switch field" }), _jsx(Text, { dimColor: true, children: "[q] Quit" })] })] }));
+                        : 'Enter your Contentful credentials to continue.' }) }), !(initialSpaceId && initialCmaToken) && (_jsx(Text, { dimColor: true, children: "Tip: run experiences setup to save these to ~/.config/experiences/credentials.json so they pre-fill here automatically." })), _jsxs(Box, { flexDirection: "column", gap: 0, marginTop: 1, children: [renderField('Space ID', spaceId, 'spaceId'), renderField('Environment', environmentId, 'environmentId'), renderField('CMA Token', cmaToken, 'cmaToken', true), renderField('API Host', host, 'host')] }), activeField === 'host' && _jsx(Text, { dimColor: true, children: "Default: api.contentful.com \u00B7 EU spaces: api.eu.contentful.com" }), displayError && _jsxs(Text, { color: "red", children: ["\u2717 ", displayError] }), validating && (_jsx(Text, { color: "cyan", children: generatePrefetchStatus === 'running'
+                    ? 'Validating credentials & finishing component generation...'
+                    : 'Validating credentials...' })), !validating && generatePrefetchStatus === 'running' && _jsx(Text, { dimColor: true, children: "Component generation in progress..." }), !validating && generatePrefetchStatus === 'complete' && (_jsx(Text, { color: "green", children: "Component generation complete." })), !validating && generatePrefetchStatus === 'failed' && (_jsxs(Text, { color: "yellow", children: ["Component generation failed", generatePrefetchError ? `: ${generatePrefetchError}` : '', ". Will retry after credential validation.", onRetryPrefetch ? ' Press R to retry now.' : ''] })), _jsxs(Box, { gap: 3, marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "[Enter] Next field / Submit" }), _jsx(Text, { dimColor: true, children: "[Tab] Switch field" }), _jsx(Text, { dimColor: true, children: "[q] Quit" })] }), onSkip && (_jsx(Box, { marginTop: 0, children: _jsx(Text, { dimColor: true, children: "[s] Skip \u2014 review locally only (no push, no live preview)" }) }))] }));
 }

package/dist/src/import/tui/steps/DoneStep.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 type EntityResult = {
     created: number;
     updated: number;
+    removed: number;
     failed: number;
 };
 type DoneStepProps = {
@@ -14,7 +15,11 @@ type DoneStepProps = {
     };
     spaceId: string;
     environmentId: string;
+    /** Configured API host (e.g. `api.contentful.com`). Used to derive the webapp URL. */
+    host?: string;
+    /** Task 8 — pre-formatted run teaser; rendered dim below the space link. */
+    runTeaser?: string;
     onExit: () => void;
 };
-export declare function DoneStep({ componentTypes, designTokens, summary, spaceId, environmentId, onExit, }: DoneStepProps): React.ReactElement;
+export declare function DoneStep({ componentTypes, designTokens, summary, spaceId, environmentId, host, runTeaser, onExit, }: DoneStepProps): React.ReactElement;
 export {};