gtx-cli 2.5.0-alpha.0 → 2.5.0-alpha.1

package/dist/workflow/DownloadStep.js

@@ -0,0 +1,127 @@
+import chalk from 'chalk';
+import { WorkflowStep } from './Workflow.js';
+import { createProgressBar, logError, logWarning } from '../console/logging.js';
+import { downloadFileBatch, } from '../api/downloadFileBatch.js';
+export class DownloadTranslationsStep extends WorkflowStep {
+    gt;
+    settings;
+    spinner = null;
+    constructor(gt, settings) {
+        super();
+        this.gt = gt;
+        this.settings = settings;
+    }
+    async run({ fileTracker, resolveOutputPath, forceDownload, }) {
+        this.spinner = createProgressBar(fileTracker.completed.size);
+        this.spinner.start('Downloading files...');
+        // Download ready files
+        const success = await this.downloadFiles(fileTracker, resolveOutputPath, forceDownload);
+        if (success) {
+            this.spinner.stop(chalk.green('Downloaded files successfully'));
+        }
+        else {
+            this.spinner.stop(chalk.red('Failed to download files'));
+        }
+        return success;
+    }
+    async downloadFiles(fileTracker, resolveOutputPath, forceDownload) {
+        try {
+            // Only download files that are marked as completed
+            const currentQueryData = Array.from(fileTracker.completed.values());
+            // If no files to download, we're done
+            if (currentQueryData.length === 0) {
+                return true;
+            }
+            // Check for translations
+            const responseData = await this.gt.queryFileData({
+                translatedFiles: currentQueryData.map((item) => ({
+                    fileId: item.fileId,
+                    versionId: item.versionId,
+                    branchId: item.branchId,
+                    locale: item.locale,
+                })),
+            });
+            const translatedFiles = responseData.translatedFiles || [];
+            // Filter for ready translations
+            const readyTranslations = translatedFiles.filter((file) => file.completedAt !== null);
+            // Prepare batch download data
+            const batchFiles = readyTranslations
+                .map((translation) => {
+                const fileKey = `${translation.branchId}:${translation.fileId}:${translation.versionId}:${translation.locale}`;
+                const fileProperties = fileTracker.completed.get(fileKey);
+                if (!fileProperties) {
+                    return null;
+                }
+                const outputPath = resolveOutputPath(fileProperties.fileName, translation.locale);
+                // Skip downloading GTJSON files that are not in the files configuration
+                if (outputPath === null) {
+                    fileTracker.completed.delete(fileKey);
+                    fileTracker.skipped.set(fileKey, fileProperties);
+                    return null;
+                }
+                return {
+                    branchId: translation.branchId,
+                    fileId: translation.fileId,
+                    versionId: translation.versionId,
+                    locale: translation.locale,
+                    inputPath: fileProperties.fileName,
+                    outputPath,
+                };
+            })
+                .filter((file) => file !== null);
+            if (batchFiles.length > 0) {
+                const batchResult = await this.downloadFilesWithRetry(fileTracker, batchFiles, forceDownload);
+                this.spinner?.stop(chalk.green(`Downloaded ${batchResult.successful.length} files${batchResult.skipped.length > 0 ? `, skipped ${batchResult.skipped.length} files` : ''}`));
+                if (batchResult.failed.length > 0) {
+                    logWarning(`Failed to download ${batchResult.failed.length} files: ${batchResult.failed.map((f) => f.inputPath).join('\n')}`);
+                }
+            }
+            else {
+                this.spinner?.stop(chalk.green('No files to download'));
+            }
+            return true;
+        }
+        catch (error) {
+            this.spinner?.stop(chalk.red('An error occurred while downloading translations'));
+            logError(chalk.red('Error: ') + error);
+            return false;
+        }
+    }
+    async downloadFilesWithRetry(fileTracker, files, forceDownload, maxRetries = 3, initialDelay = 1000) {
+        let remainingFiles = files;
+        let allSuccessful = [];
+        let retryCount = 0;
+        let allSkipped = [];
+        while (remainingFiles.length > 0 && retryCount <= maxRetries) {
+            const batchResult = await downloadFileBatch(fileTracker, remainingFiles, this.settings, forceDownload);
+            allSuccessful = [...allSuccessful, ...batchResult.successful];
+            allSkipped = [...allSkipped, ...batchResult.skipped];
+            this.spinner?.advance(batchResult.successful.length +
+                batchResult.skipped.length +
+                batchResult.failed.length);
+            // If no failures or we've exhausted retries, we're done
+            if (batchResult.failed.length === 0 || retryCount === maxRetries) {
+                return {
+                    successful: allSuccessful,
+                    failed: batchResult.failed,
+                    skipped: allSkipped,
+                };
+            }
+            // Calculate exponential backoff delay
+            const delay = initialDelay * Math.pow(2, retryCount);
+            logError(chalk.yellow(`Retrying ${batchResult.failed.length} failed file(s) in ${delay}ms (attempt ${retryCount + 1}/${maxRetries})...`));
+            // Wait before retrying
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            remainingFiles = batchResult.failed;
+            retryCount++;
+        }
+        return {
+            successful: allSuccessful,
+            failed: remainingFiles,
+            skipped: allSkipped,
+        };
+    }
+    async wait() {
+        return;
+    }
+}

package/dist/workflow/EnqueueStep.d.ts

@@ -0,0 +1,15 @@
+import type { EnqueueFilesResult } from 'generaltranslation/types';
+import { WorkflowStep } from './Workflow.js';
+import { GT } from 'generaltranslation';
+import { Settings } from '../types/index.js';
+import type { FileReference } from 'generaltranslation/types';
+export declare class EnqueueStep extends WorkflowStep<FileReference[], EnqueueFilesResult> {
+    private gt;
+    private settings;
+    private force?;
+    private spinner;
+    private result;
+    constructor(gt: GT, settings: Settings, force?: boolean | undefined);
+    run(files: FileReference[]): Promise<EnqueueFilesResult>;
+    wait(): Promise<void>;
+}

package/dist/workflow/EnqueueStep.js

@@ -0,0 +1,33 @@
+import { WorkflowStep } from './Workflow.js';
+import { createSpinner } from '../console/logging.js';
+import chalk from 'chalk';
+export class EnqueueStep extends WorkflowStep {
+    gt;
+    settings;
+    force;
+    spinner = createSpinner('dots');
+    result = null;
+    constructor(gt, settings, force) {
+        super();
+        this.gt = gt;
+        this.settings = settings;
+        this.force = force;
+    }
+    async run(files) {
+        this.spinner.start('Enqueuing translations...');
+        this.result = await this.gt.enqueueFiles(files, {
+            sourceLocale: this.settings.defaultLocale,
+            targetLocales: this.settings.locales,
+            publish: this.settings.publish,
+            requireApproval: this.settings.stageTranslations,
+            modelProvider: this.settings.modelProvider,
+            force: this.force,
+        });
+        return this.result;
+    }
+    async wait() {
+        if (this.result) {
+            this.spinner.stop(chalk.green('Translations enqueued successfully'));
+        }
+    }
+}

package/dist/workflow/PollJobsStep.d.ts

@@ -0,0 +1,31 @@
+import { WorkflowStep } from './Workflow.js';
+import { GT } from 'generaltranslation';
+import { EnqueueFilesResult } from 'generaltranslation/types';
+import type { FileProperties } from '../types/files.js';
+export type PollJobsInput = {
+    fileTracker: FileStatusTracker;
+    fileQueryData: FileProperties[];
+    jobData: EnqueueFilesResult;
+    timeoutDuration: number;
+    forceRetranslation?: boolean;
+};
+export type FileStatusTracker = {
+    completed: Map<string, FileProperties>;
+    inProgress: Map<string, FileProperties>;
+    failed: Map<string, FileProperties>;
+    skipped: Map<string, FileProperties>;
+};
+export type PollJobsOutput = {
+    success: boolean;
+    fileTracker: FileStatusTracker;
+};
+export declare class PollTranslationJobsStep extends WorkflowStep<PollJobsInput, PollJobsOutput> {
+    private gt;
+    private spinner;
+    private previousProgress;
+    constructor(gt: GT);
+    run({ fileTracker, fileQueryData, jobData, timeoutDuration, forceRetranslation, }: PollJobsInput): Promise<PollJobsOutput>;
+    private updateSpinner;
+    private generateStatusSuffixText;
+    wait(): Promise<void>;
+}

package/dist/workflow/PollJobsStep.js

@@ -0,0 +1,284 @@
+import chalk from 'chalk';
+import { WorkflowStep } from './Workflow.js';
+import { createProgressBar, logError } from '../console/logging.js';
+import { TEMPLATE_FILE_NAME } from '../cli/commands/stage.js';
+export class PollTranslationJobsStep extends WorkflowStep {
+    gt;
+    spinner = null;
+    previousProgress = 0;
+    constructor(gt) {
+        super();
+        this.gt = gt;
+    }
+    async run({ fileTracker, fileQueryData, jobData, timeoutDuration, forceRetranslation, }) {
+        const startTime = Date.now();
+        this.spinner = createProgressBar(fileQueryData.length);
+        const spinnerMessage = forceRetranslation
+            ? 'Waiting for retranslation...'
+            : 'Waiting for translation...';
+        this.spinner.start(spinnerMessage);
+        // Build a map of branchId:fileId:versionId:locale -> FileProperties
+        const filePropertiesMap = new Map();
+        fileQueryData.forEach((item) => {
+            filePropertiesMap.set(`${item.branchId}:${item.fileId}:${item.versionId}:${item.locale}`, item);
+        });
+        // Initial query to check which files already have translations
+        const initialFileData = await this.gt.queryFileData({
+            translatedFiles: fileQueryData.map((item) => ({
+                fileId: item.fileId,
+                versionId: item.versionId,
+                branchId: item.branchId,
+                locale: item.locale,
+            })),
+        });
+        const existingTranslations = initialFileData.translatedFiles || [];
+        // Mark all existing translations as completed
+        existingTranslations.forEach((translation) => {
+            if (!translation.completedAt) {
+                return;
+            }
+            const fileKey = `${translation.branchId}:${translation.fileId}:${translation.versionId}:${translation.locale}`;
+            const fileProperties = filePropertiesMap.get(fileKey);
+            if (fileProperties) {
+                fileTracker.completed.set(fileKey, fileProperties);
+            }
+        });
+        // Build a map of jobs for quick lookup:
+        // branchId:fileId:versionId:locale -> job
+        const jobMap = new Map();
+        Object.entries(jobData.jobData).forEach(([jobId, job]) => {
+            const key = `${job.branchId}:${job.fileId}:${job.versionId}:${job.targetLocale}`;
+            jobMap.set(key, { ...job, jobId });
+        });
+        // Build a map of jobs for quick lookup:
+        // jobId -> file data for the job
+        const jobFileMap = new Map();
+        Object.entries(jobData.jobData).forEach(([jobId, job]) => {
+            jobFileMap.set(jobId, {
+                branchId: job.branchId,
+                fileId: job.fileId,
+                versionId: job.versionId,
+                locale: job.targetLocale,
+            });
+        });
+        // Categorize each file query item
+        for (const item of fileQueryData) {
+            const fileKey = `${item.branchId}:${item.fileId}:${item.versionId}:${item.locale}`;
+            // Check if translation already exists (completedAt is truthy)
+            const existingTranslation = fileTracker.completed.get(fileKey);
+            if (existingTranslation) {
+                continue;
+            }
+            // Check if there's a job for this file
+            const jobKey = `${item.branchId}:${item.fileId}:${item.versionId}:${item.locale}`;
+            const job = jobMap.get(jobKey);
+            if (job) {
+                // Job exists - mark as in progress initially
+                fileTracker.inProgress.set(fileKey, item);
+            }
+            else {
+                // No job and no existing translation - mark as skipped
+                fileTracker.skipped.set(fileKey, item);
+            }
+        }
+        // Update spinner with initial status
+        this.updateSpinner(fileTracker, fileQueryData);
+        // If force retranslation, don't skip the initial check
+        if (!forceRetranslation) {
+            // Check if all jobs are already complete
+            if (fileTracker.inProgress.size === 0) {
+                this.spinner.stop(chalk.green('All translations ready'));
+                return { success: true, fileTracker };
+            }
+        }
+        // Calculate time until next 5-second interval since startTime
+        const msUntilNextInterval = Math.max(0, 5000 - ((Date.now() - startTime) % 5000));
+        return new Promise((resolve) => {
+            let intervalCheck;
+            setTimeout(() => {
+                intervalCheck = setInterval(async () => {
+                    try {
+                        // Query job status
+                        const jobIds = Array.from(jobFileMap.keys());
+                        const jobStatusResponse = await this.gt.checkJobStatus(jobIds);
+                        // Update status based on job completion
+                        for (const job of jobStatusResponse) {
+                            const jobFileProperties = jobFileMap.get(job.jobId);
+                            if (jobFileProperties) {
+                                const fileKey = `${jobFileProperties.branchId}:${jobFileProperties.fileId}:${jobFileProperties.versionId}:${jobFileProperties.locale}`;
+                                const fileProperties = filePropertiesMap.get(fileKey);
+                                if (!fileProperties) {
+                                    continue;
+                                }
+                                if (job.status === 'completed') {
+                                    fileTracker.completed.set(fileKey, fileProperties);
+                                    fileTracker.inProgress.delete(fileKey);
+                                }
+                                else if (job.status === 'failed') {
+                                    fileTracker.failed.set(fileKey, fileProperties);
+                                    fileTracker.inProgress.delete(fileKey);
+                                }
+                                else if (job.status === 'unknown') {
+                                    fileTracker.skipped.set(fileKey, fileProperties);
+                                    fileTracker.inProgress.delete(fileKey);
+                                }
+                                jobFileMap.delete(job.jobId);
+                            }
+                        }
+                        // Update spinner
+                        this.updateSpinner(fileTracker, fileQueryData);
+                        const elapsed = Date.now() - startTime;
+                        const allJobsProcessed = fileTracker.inProgress.size === 0;
+                        if (allJobsProcessed || elapsed >= timeoutDuration * 1000) {
+                            clearInterval(intervalCheck);
+                            if (fileTracker.inProgress.size === 0) {
+                                this.spinner.stop(chalk.green('Translation jobs finished'));
+                                resolve({ success: true, fileTracker });
+                            }
+                            else {
+                                this.spinner.stop(chalk.red('Timed out waiting for translation jobs'));
+                                resolve({ success: false, fileTracker });
+                            }
+                        }
+                    }
+                    catch (error) {
+                        logError(chalk.red('Error checking job status: ') + error);
+                    }
+                }, 5000);
+            }, msUntilNextInterval);
+        });
+    }
+    updateSpinner(fileTracker, fileQueryData) {
+        if (!this.spinner)
+            return;
+        const statusText = this.generateStatusSuffixText(fileTracker, fileQueryData);
+        const currentProgress = fileTracker.completed.size +
+            fileTracker.failed.size +
+            fileTracker.skipped.size;
+        const progressDelta = currentProgress - this.previousProgress;
+        this.spinner.advance(progressDelta, statusText);
+        this.previousProgress = currentProgress;
+    }
+    generateStatusSuffixText(fileTracker, fileQueryData) {
+        // Simple progress indicator
+        const progressText = `${chalk.green(`[${fileTracker.completed.size +
+            fileTracker.failed.size +
+            fileTracker.skipped.size}/${fileQueryData.length}]`)} translations completed`;
+        // Get terminal height to adapt our output
+        const terminalHeight = process.stdout.rows || 24;
+        // If terminal is very small, just show the basic progress
+        if (terminalHeight < 6) {
+            return progressText;
+        }
+        const newSuffixText = [progressText];
+        // Organize data by filename : locale
+        const fileStatus = new Map();
+        // Initialize with all files and locales from fileQueryData
+        for (const item of fileQueryData) {
+            if (!fileStatus.has(item.fileName)) {
+                fileStatus.set(item.fileName, {
+                    completed: new Set(),
+                    pending: new Set([item.locale]),
+                    failed: new Set(),
+                    skipped: new Set(),
+                });
+            }
+            else {
+                fileStatus.get(item.fileName)?.pending.add(item.locale);
+            }
+        }
+        // Mark which ones are completed, failed, or skipped
+        for (const [_, fileProperties] of fileTracker.completed) {
+            const { fileName, locale } = fileProperties;
+            const status = fileStatus.get(fileName);
+            if (status) {
+                status.pending.delete(locale);
+                status.completed.add(locale);
+            }
+        }
+        for (const [_, fileProperties] of fileTracker.failed) {
+            const { fileName, locale } = fileProperties;
+            const status = fileStatus.get(fileName);
+            if (status) {
+                status.pending.delete(locale);
+                status.failed.add(locale);
+            }
+        }
+        for (const [_, fileProperties] of fileTracker.skipped) {
+            const { fileName, locale } = fileProperties;
+            const status = fileStatus.get(fileName);
+            if (status) {
+                status.pending.delete(locale);
+                status.skipped.add(locale);
+            }
+        }
+        // Calculate how many files we can show based on terminal height
+        const filesArray = Array.from(fileStatus.entries());
+        const maxFilesToShow = Math.min(filesArray.length, terminalHeight - 3 // Header + progress + buffer
+        );
+        // Display each file with its status on a single line
+        for (let i = 0; i < maxFilesToShow; i++) {
+            const [fileName, status] = filesArray[i];
+            // Create condensed locale status
+            const localeStatuses = [];
+            // Add completed locales (green)
+            if (status.completed.size > 0) {
+                localeStatuses.push(...Array.from(status.completed).map((locale) => ({
+                    locale,
+                    status: 'completed',
+                })));
+            }
+            // Add skipped locales (green)
+            if (status.skipped.size > 0) {
+                localeStatuses.push(...Array.from(status.skipped).map((locale) => ({
+                    locale,
+                    status: 'skipped',
+                })));
+            }
+            // Add failed locales (red)
+            if (status.failed.size > 0) {
+                localeStatuses.push(...Array.from(status.failed).map((locale) => ({
+                    locale,
+                    status: 'failed',
+                })));
+            }
+            // Add pending locales (yellow)
+            if (status.pending.size > 0) {
+                localeStatuses.push(...Array.from(status.pending).map((locale) => ({
+                    locale,
+                    status: 'pending',
+                })));
+            }
+            // Sort localeStatuses by locale
+            localeStatuses.sort((a, b) => a.locale.localeCompare(b.locale));
+            // Add colors
+            const localeString = localeStatuses
+                .map((locale) => {
+                if (locale.status === 'completed') {
+                    return chalk.green(locale.locale);
+                }
+                else if (locale.status === 'skipped') {
+                    return chalk.gray(locale.locale);
+                }
+                else if (locale.status === 'failed') {
+                    return chalk.red(locale.locale);
+                }
+                else if (locale.status === 'pending') {
+                    return chalk.yellow(locale.locale);
+                }
+            })
+                .join(', ');
+            // Format the line
+            const prettyFileName = fileName === TEMPLATE_FILE_NAME ? '<React Elements>' : fileName;
+            newSuffixText.push(`${chalk.bold(prettyFileName)} [${localeString}]`);
+        }
+        // If we couldn't show all files, add an indicator
+        if (filesArray.length > maxFilesToShow) {
+            newSuffixText.push(`... and ${filesArray.length - maxFilesToShow} more files`);
+        }
+        return newSuffixText.join('\n');
+    }
+    async wait() {
+        return;
+    }
+}

package/dist/workflow/SetupStep.d.ts

@@ -0,0 +1,16 @@
+import { FileReference } from 'generaltranslation/types';
+import { WorkflowStep } from './Workflow.js';
+import { GT } from 'generaltranslation';
+import { Settings } from '../types/index.js';
+export declare class SetupStep extends WorkflowStep<FileReference[], FileReference[]> {
+    private gt;
+    private settings;
+    private timeoutMs;
+    private spinner;
+    private setupJobId;
+    private files;
+    private completed;
+    constructor(gt: GT, settings: Settings, timeoutMs: number);
+    run(files: FileReference[]): Promise<FileReference[]>;
+    wait(): Promise<void>;
+}

package/dist/workflow/SetupStep.js

@@ -0,0 +1,71 @@
+import { WorkflowStep } from './Workflow.js';
+import { createSpinner } from '../console/logging.js';
+import chalk from 'chalk';
+export class SetupStep extends WorkflowStep {
+    gt;
+    settings;
+    timeoutMs;
+    spinner = createSpinner('dots');
+    setupJobId = null;
+    files = null;
+    completed = false;
+    constructor(gt, settings, timeoutMs) {
+        super();
+        this.gt = gt;
+        this.settings = settings;
+        this.timeoutMs = timeoutMs;
+    }
+    async run(files) {
+        this.files = files;
+        this.spinner.start('Setting up project...');
+        if (files.length === 0) {
+            this.completed = true;
+            return [];
+        }
+        const result = await this.gt.setupProject(files, {
+            locales: this.settings.locales,
+        });
+        if (result.status === 'completed') {
+            this.completed = true;
+            return files;
+        }
+        if (result.status === 'queued') {
+            this.setupJobId = result.setupJobId;
+            return files;
+        }
+        // Unknown status
+        this.completed = true;
+        return files;
+    }
+    async wait() {
+        if (this.completed) {
+            this.spinner.stop(chalk.green('Setup successfully completed'));
+            return;
+        }
+        if (!this.setupJobId) {
+            this.spinner.stop(chalk.yellow('Setup status unknown — proceeding without setup'));
+            return;
+        }
+        // Poll for completion
+        const start = Date.now();
+        const pollInterval = 5000; // 5 seconds
+        while (Date.now() - start < this.timeoutMs) {
+            const status = await this.gt.checkJobStatus([this.setupJobId]);
+            if (!status[0]) {
+                this.spinner.stop(chalk.yellow('Setup status unknown — proceeding without setup'));
+                return;
+            }
+            if (status[0].status === 'completed') {
+                this.spinner.stop(chalk.green('Setup successfully completed'));
+                return;
+            }
+            if (status[0].status === 'failed') {
+                this.spinner.stop(chalk.yellow(`Setup failed: ${status[0].error?.message || 'Unknown error'} — proceeding without setup`));
+                return;
+            }
+            await new Promise((r) => setTimeout(r, pollInterval));
+        }
+        // Timeout
+        this.spinner.stop(chalk.yellow('Setup timed out — proceeding without setup'));
+    }
+}

package/dist/workflow/UploadStep.d.ts

@@ -0,0 +1,21 @@
+import type { FileToUpload } from 'generaltranslation/types';
+import { WorkflowStep } from './Workflow.js';
+import { GT } from 'generaltranslation';
+import { Settings } from '../types/index.js';
+import { BranchData } from '../types/branch.js';
+import type { FileReference } from 'generaltranslation/types';
+export declare class UploadStep extends WorkflowStep<{
+    files: FileToUpload[];
+    branchData: BranchData;
+}, FileReference[]> {
+    private gt;
+    private settings;
+    private spinner;
+    private result;
+    constructor(gt: GT, settings: Settings);
+    run({ files, branchData, }: {
+        files: FileToUpload[];
+        branchData: BranchData;
+    }): Promise<FileReference[]>;
+    wait(): Promise<void>;
+}

package/dist/workflow/UploadStep.js

@@ -0,0 +1,72 @@
+import { WorkflowStep } from './Workflow.js';
+import { createSpinner, logInfo } from '../console/logging.js';
+import chalk from 'chalk';
+export class UploadStep extends WorkflowStep {
+    gt;
+    settings;
+    spinner = createSpinner('dots');
+    result = null;
+    constructor(gt, settings) {
+        super();
+        this.gt = gt;
+        this.settings = settings;
+    }
+    async run({ files, branchData, }) {
+        if (files.length === 0) {
+            logInfo('No files to upload found... skipping upload step');
+            return [];
+        }
+        this.spinner.start(`Syncing ${files.length} file${files.length !== 1 ? 's' : ''} with General Translation API...`);
+        // First, figure out which files need to be uploaded
+        const fileData = await this.gt.queryFileData({
+            sourceFiles: files.map((f) => ({
+                fileId: f.fileId,
+                versionId: f.versionId,
+                branchId: f.branchId ?? branchData.currentBranch.id,
+            })),
+        });
+        // build a map of branch:fileId:versionId to fileData
+        const fileDataMap = new Map();
+        fileData.sourceFiles?.forEach((f) => {
+            fileDataMap.set(`${f.branchId}:${f.fileId}:${f.versionId}`, f);
+        });
+        // Build a list of files that need to be uploaded
+        const filesToUpload = [];
+        const filesToSkipUpload = [];
+        files.forEach((f) => {
+            if (fileDataMap.has(`${f.branchId ?? branchData.currentBranch.id}:${f.fileId}:${f.versionId}`)) {
+                filesToSkipUpload.push(f);
+            }
+            else {
+                filesToUpload.push(f);
+            }
+        });
+        const response = await this.gt.uploadSourceFiles(filesToUpload.map((f) => ({
+            source: {
+                ...f,
+                branchId: f.branchId ?? branchData.currentBranch.id,
+                locale: this.settings.defaultLocale,
+                incomingBranchId: branchData.incomingBranch?.id,
+                checkedOutBranchId: branchData.checkedOutBranch?.id,
+            },
+        })), {
+            sourceLocale: this.settings.defaultLocale,
+            modelProvider: this.settings.modelProvider,
+        });
+        this.result = response.uploadedFiles;
+        // Merge files that were already uploaded into the result
+        this.result.push(...filesToSkipUpload.map((f) => ({
+            fileId: f.fileId,
+            versionId: f.versionId,
+            branchId: f.branchId ?? branchData.currentBranch.id,
+            fileName: f.fileName,
+            fileFormat: f.fileFormat,
+            dataFormat: f.dataFormat,
+        })));
+        this.spinner.stop(chalk.green('Files uploaded successfully'));
+        return this.result;
+    }
+    async wait() {
+        return;
+    }
+}