@mycadet/assistant 0.12.11 → 0.13.0

package/src/runtime/migrations/transfer-progress-screen.ts

@@ -1,323 +0,0 @@
-/**
- * Transfer progress screen -- view model for the transfer step.
- *
- * Derives display state from the migration wizard state machine for rendering
- * a transfer/import progress UI. Usable from macOS/iOS web views, CLI, or
- * any TypeScript consumer.
- *
- * The transfer step is import-only: it commits a pre-uploaded bundle to
- * the destination. The export/poll phases are retained in the type system
- * for managed-source flows that still use them, but the default phase is
- * "import".
- *
- * View model states:
- *   - disabled: step is not yet accessible (earlier steps incomplete)
- *   - exporting: export phase is in progress (managed-source flows only)
- *   - polling: managed async export job is being polled for completion
- *   - importing: import phase is in progress
- *   - success: import completed successfully
- *   - error: an error occurred (with retry capability info)
- */
-
-import type {
-  ExportManagedResult,
-  ImportCommitSuccessResponse,
-} from "./migration-transport.js";
-import type {
-  MigrationWizardState,
-  StepError,
-  StepExecutorOptions,
-} from "./migration-wizard.js";
-import {
-  canRetryCurrentStep,
-  executeTransferStep,
-  goBackTo,
-  isStepAccessible,
-  resetStepForRetry,
-} from "./migration-wizard.js";
-
-// ---------------------------------------------------------------------------
-// View model types
-// ---------------------------------------------------------------------------
-
-/** Which phase of the transfer is currently active. */
-export type TransferPhase = "export" | "poll" | "import";
-
-/** Summary of the import result for display. */
-export interface TransferImportSummary {
-  totalFiles: number;
-  filesCreated: number;
-  filesOverwritten: number;
-  filesSkipped: number;
-  backupsCreated: number;
-  warnings: string[];
-}
-
-/**
- * Discriminated union representing the current display state of the
- * transfer progress screen.
- */
-export type TransferScreenState =
-  | { phase: "disabled" }
-  | { phase: "exporting"; message: string }
-  | { phase: "polling"; message: string; jobId: string }
-  | { phase: "importing"; message: string }
-  | {
-      phase: "error";
-      error: StepError;
-      /** Which transfer phase failed, if determinable. */
-      failedPhase: TransferPhase | "unknown";
-      canRetry: boolean;
-    }
-  | {
-      phase: "success";
-      importSummary: TransferImportSummary;
-      canContinue: boolean;
-    };
-
-// ---------------------------------------------------------------------------
-// State derivation
-// ---------------------------------------------------------------------------
-
-/**
- * Infer which transfer sub-phase is active based on wizard state.
- *
- * The default flow is import-only (bundleData provided directly). Managed
- * export flows that populate exportResult still get poll/export phases.
- */
-function inferActivePhase(state: MigrationWizardState): TransferPhase {
-  // Managed export flows that populate exportResult
-  if (state.exportResult && "jobId" in state.exportResult) {
-    const managed = state.exportResult as ExportManagedResult;
-    if (state.importResult) {
-      return "import";
-    }
-    if (managed.status !== "complete") {
-      return "poll";
-    }
-  }
-
-  return "import";
-}
-
-/**
- * Infer the phase that failed when the transfer step is in error state.
- */
-function inferFailedPhase(
-  state: MigrationWizardState,
-): TransferPhase | "unknown" {
-  const stepError = state.steps["transfer"].error;
-  if (!stepError) {
-    return "unknown";
-  }
-
-  // Export job failure codes
-  if (
-    stepError.code === "EXPORT_JOB_FAILED" ||
-    stepError.code === "NO_DOWNLOAD_URL"
-  ) {
-    return "export";
-  }
-
-  // No exportResult means this is the import-only flow; attribute to import
-  if (!state.exportResult) {
-    return "import";
-  }
-
-  // If we have an export result but the error mentions import
-  if (state.importResult && !state.importResult.success) {
-    return "import";
-  }
-
-  // If export result exists but no import result, and error is transport-level,
-  // it could be download failure or import failure
-  if (state.exportResult && !state.importResult) {
-    if ("jobId" in state.exportResult) {
-      const managed = state.exportResult as ExportManagedResult;
-      if (managed.status === "complete") {
-        // Export completed but no importResult -- check whether the failure was
-        // during archive download (between export and import) or during import.
-        // Download failures surface with "download" in the message; actual
-        // import failures would have set importResult.
-        const msg = stepError.message?.toLowerCase() ?? "";
-        if (msg.includes("download")) {
-          return "poll";
-        }
-        return "import";
-      }
-      return "poll";
-    }
-    return "import";
-  }
-
-  return "unknown";
-}
-
-/**
- * Derive the current transfer screen state from the wizard state.
- *
- * This is a pure function -- no side effects. Call it whenever the wizard
- * state changes to get the latest display state.
- */
-export function deriveTransferScreenState(
-  wizardState: MigrationWizardState,
-): TransferScreenState {
-  const transferStep = wizardState.steps["transfer"];
-
-  // Not yet accessible -- earlier steps incomplete
-  if (
-    wizardState.currentStep !== "transfer" &&
-    transferStep.status !== "success"
-  ) {
-    if (!isStepAccessible(wizardState, "transfer")) {
-      return { phase: "disabled" };
-    }
-  }
-
-  // Transfer step is in error state
-  if (
-    wizardState.currentStep === "transfer" &&
-    transferStep.status === "error"
-  ) {
-    return {
-      phase: "error",
-      error: transferStep.error ?? {
-        message: "Transfer failed",
-        retryable: false,
-      },
-      failedPhase: inferFailedPhase(wizardState),
-      canRetry: canRetryCurrentStep(wizardState),
-    };
-  }
-
-  // Transfer step is loading -- determine sub-phase
-  if (
-    wizardState.currentStep === "transfer" &&
-    (transferStep.status === "loading" || transferStep.status === "idle")
-  ) {
-    const activePhase = inferActivePhase(wizardState);
-
-    if (
-      activePhase === "poll" &&
-      wizardState.exportResult &&
-      "jobId" in wizardState.exportResult
-    ) {
-      return {
-        phase: "polling",
-        message: "Waiting for export job to complete...",
-        jobId: (wizardState.exportResult as ExportManagedResult).jobId,
-      };
-    }
-
-    if (activePhase === "export") {
-      return {
-        phase: "exporting",
-        message: "Exporting data from source...",
-      };
-    }
-
-    // Default: import phase
-    return {
-      phase: "importing",
-      message: "Importing bundle to destination...",
-    };
-  }
-
-  // Transfer step succeeded -- show results
-  if (transferStep.status === "success") {
-    const importResult = wizardState.importResult;
-    if (importResult && importResult.success) {
-      const successResult = importResult as ImportCommitSuccessResponse;
-      return {
-        phase: "success",
-        importSummary: {
-          totalFiles: successResult.summary.total_files,
-          filesCreated: successResult.summary.files_created,
-          filesOverwritten: successResult.summary.files_overwritten,
-          filesSkipped: successResult.summary.files_skipped,
-          backupsCreated: successResult.summary.backups_created,
-          warnings: successResult.warnings,
-        },
-        canContinue: isStepAccessible(wizardState, "rebind-secrets"),
-      };
-    }
-
-    // Success status but no import result (shouldn't happen, defensive)
-    return {
-      phase: "success",
-      importSummary: {
-        totalFiles: 0,
-        filesCreated: 0,
-        filesOverwritten: 0,
-        filesSkipped: 0,
-        backupsCreated: 0,
-        warnings: [],
-      },
-      canContinue: isStepAccessible(wizardState, "rebind-secrets"),
-    };
-  }
-
-  return { phase: "disabled" };
-}
-
-// ---------------------------------------------------------------------------
-// Actions -- delegate to wizard state machine
-// ---------------------------------------------------------------------------
-
-/**
- * Execute the full transfer flow: export from source and import to destination.
- *
- * For managed sources, this includes async export polling.
- * For runtime sources, the export returns binary data directly.
- *
- * Returns the final wizard state after the transfer step completes.
- */
-export async function executeTransferFlow(
-  state: MigrationWizardState,
-  options: StepExecutorOptions,
-): Promise<MigrationWizardState> {
-  return executeTransferStep(state, options);
-}
-
-/**
- * Retry the transfer step after an error.
- *
- * Resets the step to idle and re-executes the transfer flow.
- */
-export async function retryTransferFlow(
-  state: MigrationWizardState,
-  options: StepExecutorOptions,
-): Promise<MigrationWizardState> {
-  const reset = resetStepForRetry(state);
-  const cleaned = {
-    ...reset,
-    exportResult: undefined,
-    importResult: undefined,
-  };
-  options.onStateChange?.(cleaned);
-  return executeTransferStep(cleaned, options);
-}
-
-/**
- * Navigate back to the preflight-review step.
- */
-export function goBackToPreflight(
-  state: MigrationWizardState,
-): MigrationWizardState {
-  return goBackTo(state, "preflight-review");
-}
-
-// ---------------------------------------------------------------------------
-// Query helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Check if the transfer progress screen is accessible from the current state.
- */
-export function isTransferScreenAccessible(
-  state: MigrationWizardState,
-): boolean {
-  return (
-    isStepAccessible(state, "transfer") || state.currentStep === "transfer"
-  );
-}