@magentrix-corp/magentrix-cli 1.0.0

package/utils/cli/helpers/compare.js

@@ -0,0 +1,281 @@
+import path from 'path';
+import chalk from 'chalk'; // For pretty colors, install with `npm install chalk`
+import { compareLocalAndRemote } from '../../compare.js';
+import inquirer from 'inquirer';
+import { mapRecordToFile } from '../writeRecords.js';
+import { withSpinner } from '../../spinner.js';
+import { meqlQuery } from '../../magentrix/api/meqlQuery.js';
+import readline from 'readline';
+
+/**
+ * Logs a formatted, user-friendly status message for a single file, given its sync comparison result.
+ *
+ * @param {string} relativePath - File path relative to root directory.
+ * @param {Object} statusResult - Result object from compareLocalAndRemote.
+ * @returns {boolean} True if an issue was found (not 'in_sync' or 'missing'), otherwise false.
+ */
+export function logFileStatus(relativePath, statusResult) {
+    const fileDisplay = chalk.bold.blue(relativePath);
+
+    switch (statusResult.status) {
+        case 'in_sync':
+            // Uncomment to show successes:
+            // console.log(chalk.green(`✓ ${fileDisplay} is up to date.`));
+            return false;
+        case 'behind':
+            console.log(
+                chalk.yellow(`⚠️  ${fileDisplay} is OUTDATED:`) +
+                `\n   Local version is older than the server version, but contents are identical.\n` +
+                `   Consider pulling the latest metadata from the server.`
+            );
+            return true;
+        case 'conflict':
+            console.log(
+                chalk.red(`🛑 ${fileDisplay} has a CONFLICT:`) +
+                `\n   Local file is behind the remote, AND both were edited differently.\n` +
+                `   Resolve this conflict before pushing or pulling.`
+            );
+            return true;
+        case 'ahead':
+            console.log(
+                chalk.yellow(`⚠️  ${fileDisplay} is AHEAD:`) +
+                `\n   Local file was modified after the remote version, and contents differ.\n` +
+                `   You may want to push your changes to the server.`
+            );
+            return true;
+        case 'ahead_identical':
+            console.log(
+                chalk.yellow(`⚠️  ${fileDisplay} is AHEAD (identical):`) +
+                `\n   Local file has a newer timestamp, but contents match remote.\n` +
+                `   This could be a system clock drift.`
+            );
+            return true;
+        case 'content_differs':
+            console.log(
+                chalk.red(`🛑 ${fileDisplay} CONTENT MISMATCH:`) +
+                `\n   File timestamps match, but contents differ!\n` +
+                `   This is unusual—please investigate.`
+            );
+            return true;
+        case 'missing':
+            // Not an error, file will be downloaded.
+            // Uncomment if you want to notify about downloads:
+            console.log(
+                chalk.yellow(`⚠️  ${fileDisplay} is MISSING:`) +
+                `\n   Local file has been removed.`
+            );
+
+            // console.log(chalk.cyan(`⬇️  ${fileDisplay} will be downloaded from the server.`));
+            return true;
+        default:
+            console.log(
+                chalk.magenta(`❓  ${fileDisplay} has an unknown status: ${statusResult.status}`)
+            );
+            return true;
+    }
+}
+
+/**
+ * Compares all local files in a specified root directory against their remote versions,
+ * then logs user-friendly, formatted status messages for any files that are not in sync.
+ *
+ * - Uses logFileStatus to handle message formatting for each file.
+ * - Only logs files that require attention; in-sync files are silent by default.
+ * - If no issues are found, logs a celebratory success message.
+ * - Intended for CLI status or sync-check commands.
+ *
+ * @param {string} rootDir
+ *        The local root directory where your files are stored (e.g., './export').
+ * @param {Array<Object>} fileRecords
+ *        Array of remote file descriptors to compare. Each object should include:
+ *        - {string} relativePath: File path relative to rootDir (e.g. 'Controllers/Foo.ctrl')
+ *        - {string} content: Latest file content from the server
+ *        - {string} ModifiedOn: Last modified date/time on server (ISO string)
+ *
+ * @returns {void}
+ *
+ * @example
+ * const filesFromServer = [
+ *   {
+ *     relativePath: "Controllers/AccountController.ctrl",
+ *     content: "...",
+ *     ModifiedOn: "2025-07-10T18:00:00.000Z"
+ *   },
+ *   // ...
+ * ];
+ * compareAllFilesAndLogStatus('./export', filesFromServer);
+ */
+export function compareAllFilesAndLogStatus(rootDir, fileRecords) {
+    let numIssues = 0;
+
+    console.log();
+
+    for (const record of fileRecords) {
+        const localFilePath = path.join(rootDir, record.relativePath);
+
+        const result = compareLocalAndRemote(localFilePath, {
+            content: record.Content,
+            ...record
+        });
+
+        // Use the single-file logger and aggregate if any issues found
+        const hadIssue = logFileStatus(record.relativePath, result);
+        if (hadIssue) numIssues++;
+    }
+
+    if (numIssues === 0) {
+        console.log(chalk.green.bold('\n🎉 All files are up to date and in sync!\n'));
+    }
+}
+
+/**
+ * Checks local vs remote Magentrix file status and warns on conflicts/out-of-sync.
+ * If issues are found, blocks execution unless `forceContinue` is true.
+ * If not forced, user can press any key to continue, or ESC to abort.
+ *
+ * @param {string} rootDir
+ * @param {string} instanceUrl
+ * @param {string} token
+ * @param {boolean} [forceContinue=false]
+ */
+export async function showCurrentConflicts(rootDir, instanceUrl, token, forceContinue = false) {
+    const queries = [
+        {
+            name: "ActiveClass",
+            query: "SELECT Id,Body,Name,CreatedOn,Description,ModifiedOn,Type FROM ActiveClass",
+            contentField: "Body",
+        },
+        {
+            name: "ActivePage",
+            query: "SELECT Id,Content,Name,CreatedOn,Description,ModifiedOn,Type FROM ActivePage",
+            contentField: "Content",
+        },
+    ];
+
+    console.log(chalk.cyan.bold('🔍 Checking local files vs remote Magentrix...'));
+    console.log(chalk.gray('------------------------------------------------'));
+
+    const [activeClassResult, activePageResult] = await withSpinner(
+        chalk.gray('Retrieving files from server...'),
+        async () => Promise.all(
+            queries.map(q => meqlQuery(instanceUrl, token, q.query))
+        )
+    );
+
+    const activeClassRecords = (activeClassResult.Records || []).map(record => {
+        record.Content = record.Body;
+        delete record.Body;
+        return record;
+    });
+    const activePageRecords = (activePageResult.Records || []);
+    const allRecords = [...activeClassRecords, ...activePageRecords].map(mapRecordToFile);
+
+    let warningCount = 0;
+    console.log();
+
+    for (const record of allRecords) {
+        if (record?.error) {
+            continue;
+        }
+
+        const status = compareLocalAndRemote(
+            path.join(rootDir, record.relativePath),
+            { ...record, content: record.Content }
+        );
+
+        const hasIssue = logFileStatus(record.relativePath, status);
+        if (hasIssue) warningCount++;
+    }
+
+    if (warningCount > 0) {
+        console.log();
+        console.log(
+            chalk.yellow.bold(`⚠️  Conflict${warningCount > 1 ? 's' : ''} detected!`) +
+            chalk.yellow('\n   These are just warnings, but you should resolve them before continuing.')
+        );
+        console.log(
+            chalk.yellow('\n👉 To sync and resolve conflicts, run: ') +
+            chalk.cyan.bold('magentrix pull')
+        );
+        console.log(chalk.gray('------------------------------------------------'));
+
+        if (!forceContinue) {
+            await new Promise((resolve) => {
+                process.stdout.write(
+                    chalk.yellow(
+                        '\nPress any key to continue, or press ESC to abort... '
+                    )
+                );
+
+                // Set raw mode so we capture a single key, including ESC
+                process.stdin.setRawMode(true);
+                process.stdin.resume();
+                process.stdin.once('data', (data) => {
+                    process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                    // ESC key is 27 in Buffer
+                    if (data.length === 1 && data[0] === 27) {
+                        console.log(chalk.red.bold('\nAborted due to unresolved conflicts.\n'));
+                        process.exit(1);
+                    } else {
+                        // Continue
+                        process.stdout.write('\n');
+                        resolve();
+                    }
+                });
+            });
+        }
+    } else {
+        console.log();
+        console.log(chalk.green.bold('🎉 All local files are in sync with the server!'));
+        console.log(chalk.gray('------------------------------------------------'));
+    }
+}
+
+
+
+/**
+ * Presents all files with conflicts and prompts the user for a global resolution action.
+ *
+ * @param {Array<{relativePath: string, status: string}>} fileIssues
+ * @returns {Promise<'skip'|'overwrite'|'diff'|'accept_ours'|'accept_theirs'|'manual'>}
+ */
+export async function promptConflictResolution(fileIssues) {
+    if (!fileIssues.length) return 'skip';
+
+    // Clear for better UX
+    console.clear();
+    console.log(
+        chalk.bold.yellow(
+            `\n${fileIssues.length} file${fileIssues.length > 1 ? 's' : ''} require conflict resolution:\n`
+        )
+    );
+
+    fileIssues.forEach((file, i) => {
+        console.log(
+            chalk.cyan(`${i + 1}.`) +
+            ' ' +
+            chalk.bold(file.relativePath) +
+            chalk.gray(` [${file.status}]`)
+        );
+    });
+
+    console.log();
+
+    // Present actions menu
+    const { action } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: chalk.green('Choose how to resolve these conflicts:'),
+            choices: [
+                { name: 'Replace local files with server versions (discard my changes)', value: 'overwrite' },
+                { name: 'Automatically merge changes (may require manual edits if conflicts remain)', value: 'merge' },
+                { name: 'Review each conflict and choose (see diffs)', value: 'diff' },
+                { name: 'Do nothing for now (skip conflicted files)', value: 'skip' }
+            ]
+        },
+    ]);
+
+    return action;
+}

package/utils/cli/helpers/ensureApiKey.js

@@ -0,0 +1,57 @@
+import prompts from "prompts";
+import Config from "../../config.js";
+import { HASHED_CWD } from "../../../vars/global.js";
+
+const config = new Config();
+
+/**
+ * Ensures a valid Magentrix API key is available in the global config.
+ * - If a key is missing, invalid, or forcePrompt is true, prompts the user to enter one.
+ * - Validates that the key is at least 12 characters long and contains no spaces.
+ * - Exits the process if the user fails to provide a valid key.
+ * 
+ * @async
+ * @param {boolean} [forcePrompt=false] - If true, always prompt for API key, even if one exists.
+ * @returns {Promise<string>} The valid API key, either from config or user input.
+ */
+export const ensureApiKey = async (forcePrompt = false) => {
+    let apiKey = config.read('apiKey', { global: true, pathHash: HASHED_CWD });
+
+    // Helper: checks for min length and no spaces
+    const isValid = (key) =>
+        typeof key === "string" &&
+        key.trim().length >= 12 &&
+        !/\s/.test(key);
+
+    if (forcePrompt || !isValid(apiKey)) {
+        console.log('\n🚀 Magentrix CLI Setup:');
+
+        while (true) {
+            const response = await prompts({
+                type: 'password',
+                name: 'apiKey',
+                message: 'Enter your Magentrix API key (no spaces):',
+                validate: value =>
+                    !value || value.trim().length < 12
+                        ? "API key must be at least 12 characters."
+                        : /\s/.test(value)
+                            ? "API key cannot contain any spaces."
+                            : true,
+            });
+
+            if (!response.apiKey) {
+                console.error('❌ API key is required. Exiting.');
+                process.exit(1);
+            }
+
+            const trimmed = response.apiKey.trim();
+
+            if (isValid(trimmed)) {
+                return trimmed;
+            }
+            // Invalid: will re-prompt.
+        }
+    }
+
+    return apiKey;
+};

package/utils/cli/helpers/ensureCredentials.js

@@ -0,0 +1,60 @@
+import Config from "../../config.js";
+import { setup } from "../../../actions/setup.js";
+import { HASHED_CWD } from "../../../vars/global.js";
+import { tryAuthenticate } from "../../magentrix/api/auth.js";
+
+/**
+ * Returns true if the token is present and not expired (60 seconds buffer).
+ * @param {{ value?: string, validUntil?: string } | undefined} tokenObj 
+ * @returns {boolean}
+ */
+export function isTokenValid(tokenObj) {
+    if (!tokenObj || !tokenObj.value || !tokenObj.validUntil) return false;
+    const now = Date.now();
+    const expiresAt = Date.parse(tokenObj.validUntil);
+    if (isNaN(expiresAt)) return false;
+    const SECONDS_BEFORE_EXPIRY = 60 * 1000;
+    return expiresAt - now > SECONDS_BEFORE_EXPIRY;
+}
+
+/**
+ * Ensures Magentrix credentials are present and valid, refreshing the token if needed.
+ * Prompts user only when needed.
+ * 
+ * @returns {Promise<{ apiKey: string, instanceUrl: string, token: { value: string, validUntil: string } }>}
+ */
+export async function ensureValidCredentials() {
+    const config = new Config();
+
+    // Load from config
+    const apiKey = config.read('apiKey', { global: true, pathHash: HASHED_CWD });
+    const instanceUrl = config.read('instanceUrl', { global: true, pathHash: HASHED_CWD });
+    const token = config.read('token', { global: true, pathHash: HASHED_CWD });
+
+    // If missing API key or URL, prompt/setup immediately
+    if (!apiKey || !instanceUrl) {
+        return setup();
+    }
+
+    // If token is present and valid, return immediately
+    if (isTokenValid(token)) {
+        return { apiKey, instanceUrl, token };
+    }
+
+    // If we have API key & URL but no valid token, try to refresh
+    try {
+        const result = await tryAuthenticate(apiKey, instanceUrl);
+
+        if (!result || !result.token || !result.validUntil) {
+            throw new Error("Invalid token refresh response");
+        }
+
+        // Save new token and return
+        const newToken = { value: result.token, validUntil: result.validUntil };
+        config.save('token', newToken, { global: true, pathHash: HASHED_CWD });
+        return { apiKey, instanceUrl, token: newToken };
+    } catch (err) {
+        // Failed to refresh, fall back to prompting the user
+        return setup();
+    }
+}

package/utils/cli/helpers/ensureInstanceUrl.js

@@ -0,0 +1,63 @@
+import prompts from "prompts";
+import Config from "../../config.js";
+import { checkInstanceUrl } from "../checkInstanceUrl.js";
+import { withSpinner } from "../../spinner.js";
+import { HASHED_CWD } from "../../../vars/global.js";
+
+const config = new Config();
+const urlRegex = /^https:\/\/[a-zA-Z0-9-]+\.magentrix(cloud)?\.com$/;
+
+/**
+ * Ensures a valid Magentrix instance URL is available in the global config.
+ * Prompts until user provides a valid, reachable URL or cancels.
+ *
+ * @async
+ * @param {boolean} [forcePrompt=false] - If true, always prompt for instance URL, even if one exists.
+ * @returns {Promise<string>} The valid instance URL, either from config or user input.
+ */
+export const ensureInstanceUrl = async (forcePrompt = false) => {
+    let instanceUrl = config.read('instanceUrl', { global: true, pathHash: HASHED_CWD });
+
+    if (
+        forcePrompt ||
+        !instanceUrl ||
+        typeof instanceUrl !== 'string' ||
+        !urlRegex.test(instanceUrl.trim())
+    ) {
+        console.log('\n🚀 Magentrix CLI Setup: Instance URL');
+
+        while (true) {
+            // Prompt: Only validate format, NOT reachability
+            const { instanceUrl: inputUrl } = await prompts({
+                type: 'text',
+                name: 'instanceUrl',
+                message: 'Enter your Magentrix instance URL (e.g., https://example.magentrixcloud.com):',
+                validate: value =>
+                    urlRegex.test(value.trim())
+                        ? true
+                        : 'Instance URL must be in the form: https://subdomain.magentrixcloud.com (NO http, NO trailing /, NO extra path)',
+            });
+
+            if (!inputUrl) {
+                console.error('❌ Instance URL is required. Exiting.');
+                process.exit(1);
+            }
+
+            const trimmed = inputUrl.trim();
+
+            // Now check reachability WITH a spinner
+            try {
+                await withSpinner('Checking instance URL...', () =>
+                    checkInstanceUrl(trimmed)
+                );
+                
+                return trimmed;
+            } catch (error) {
+                // Print error AFTER spinner, then re-prompt
+                console.error('❌ Instance URL not reachable. Try again.');
+            }
+        }
+    }
+
+    return instanceUrl.trim();
+};

package/utils/cli/writeRecords.js

@@ -0,0 +1,223 @@
+import { EXPORT_ROOT, TYPE_DIR_MAP } from "../../vars/global.js";
+import fs from 'fs';
+import path from "path";
+import { compareLocalAndRemote } from "../compare.js";
+import { mergeFiles } from "../merge.js";
+import Config from "../config.js";
+import chalk from "chalk";
+import { diffLines } from 'diff';
+import readlineSync from "readline-sync";
+import { updateBase } from "../updateFileBase.js";
+import { sha256 } from "../hash.js";
+import { openDiffInVSCode } from "../diff.js";
+import { tmpdir } from "os";
+import { v4 as uuidv4 } from 'uuid';
+import { findFileByTag, getFileTag, setFileTag } from "../filetag.js";
+import { decompressString } from "../compress.js";
+
+const config = new Config();
+
+/**
+ * Maps an ActivePage record to its local file representation.
+ * @param {Object} record - The ActivePage record from the API.
+ * @returns {Object} The enriched record with 'relativePath' property.
+ */
+export const mapRecordToFile = (record) => {
+    const { Type, Name, Id } = record;
+    const mapping = TYPE_DIR_MAP[Type];
+
+    if (!mapping) {
+        const errMsg = `Unrecognized type "${Type}" for record "${Name || 'UNKNOWN'}". This can be resolved in the Magentrix IDE and is likely due to a misconfiguration.`;
+        return { ...record, error: errMsg };
+    }
+
+    const safeName = Name.replace(/[<>:"/\\|?*]+/g, "_");
+    const filename = `${safeName}.${mapping.extension}`;
+
+    const foundPathByRecordId = findFileByTag(Id) || "";
+    const relativeFoundPath = foundPathByRecordId
+        ? path.join(mapping.directory, foundPathByRecordId.split(mapping.directory)[1] || "")
+        : "";
+
+    const filePath = foundPathByRecordId ? relativeFoundPath : path.join(mapping.directory, filename);
+
+    return {
+        ...record,
+        relativePath: filePath
+    };
+};
+
+/**
+ * Writes records to disk, handling conflicts per the chosen resolution method.
+ * @param {Array} records - List of entity records (ActiveClass or ActivePage)
+ * @param {string} resolutionMethod - One of: "overwrite", "merge", "diff", "skip"
+ */
+export const writeRecords = async (records, resolutionMethod) => {
+    for (const record of records) {
+        const mapping = TYPE_DIR_MAP[record.Type];
+        if (!mapping) {
+            console.warn(chalk.gray(`⚠️  Skipping unknown type: ${record.Type} (record: ${record.Name})`));
+            continue;
+        }
+
+        // Build output path and filename
+        const outputDir = path.join(EXPORT_ROOT, mapping.directory);
+        fs.mkdirSync(outputDir, { recursive: true }); // Ensure dir exists
+
+        const safeName = record.Name.replace(/[<>:"/\\|?*]+/g, "_");
+        const filename = `${safeName}.${mapping.extension}`;
+        const filePath = path.join(outputDir, filename);
+
+        const content = record.Content;
+        if (!content) {
+            console.warn(`⚠️  No content found for ${record.Name} (${record.Type}), skipping file.`);
+            continue;
+        }
+
+        // Compare local and remote to determine sync status/conflict
+        const comparison = compareLocalAndRemote(filePath, { content, ...record });
+
+        // --- Conflict Handling ---
+        let finalContent = null; // Will hold the string to write if we should write the file
+
+        if (['missing', 'in_sync'].includes(comparison.status)) {
+            // No conflict, just write server version (create if missing)
+            finalContent = content;
+        } else {
+            // Attempt to read local file (may not exist)
+            let local = "";
+
+            const base = config.read(record.Id, { global: false, filename: 'base.json' });
+            const baseContent = decompressString(base?.compressedContent) || '';
+
+            // const base = config.read(filePath);
+            try { local = fs.readFileSync(filePath, "utf8"); } catch { }
+
+            if (resolutionMethod === 'skip') {
+                // Do nothing, never create or update file
+                console.log(chalk.yellow(`⏭️  Skipped ${record.Name} (${record.Type}) due to conflict or mismatch.`));
+                continue;
+            }
+            else if (resolutionMethod === 'overwrite') {
+                // Always accept server version, creating file if missing
+                console.log(chalk.redBright(`⚠️  Overwriting local file: ${filePath} with server version.`));
+                finalContent = content;
+            }
+            else if (resolutionMethod === 'diff') {
+                // Use mergeFiles, show diff, ask user
+                let merged;
+                try {
+                    merged = mergeFiles(baseContent, local, content);
+                } catch (e) {
+                    console.log(chalk.red(`❌ Error merging: ${e.message}`));
+                    continue;
+                }
+
+                // Attempt to open the diff in vs code
+                const randomStr = (length) => Math.random().toString(36).slice(2, 2 + length);
+                const tempFileServer = path.join(tmpdir(), `${randomStr(4)}.Server${filename}`);
+                const tempFileLocal = path.join(tmpdir(), `${randomStr(4)}.Local${filename}`);
+                fs.writeFileSync(tempFileServer, content);
+                fs.writeFileSync(tempFileLocal, local);
+
+                const vsCodeDiffDisplayed = openDiffInVSCode(tempFileServer, tempFileLocal);
+
+                // If the VS Code diff failed, show in terminal
+                if (!vsCodeDiffDisplayed) {
+                    // Show diff (local vs merged)
+                    const diff = diffLines(local, merged);
+                    console.log(chalk.magenta.bold(`\n======= REVIEW MERGED for ${filename} =======`));
+                    diff.forEach(part => {
+                        const color = part.added ? 'green' :
+                            part.removed ? 'red' : 'gray';
+                        process.stdout.write(chalk[color](part.value));
+                    });
+                    console.log(chalk.magenta.bold("\n======= END REVIEW ======="));
+
+                    // Warn if there are still unresolved conflict markers
+                    if (merged.includes('<<<<<<<')) {
+                        console.log(chalk.red.bold("\n⚠️  Merge conflict markers present. Please resolve manually after accepting."));
+                    }
+                }
+
+                // Prompt user to accept or skip writing merged content
+                const choice = readlineSync.question(
+                    chalk.yellow("\nAccept merged changes and write to file? (y/n): ")
+                );
+
+                // Delete the temp files
+                fs.unlinkSync(tempFileLocal);
+                fs.unlinkSync(tempFileServer);
+
+                if (choice.trim().toLowerCase() === 'y') {
+                    finalContent = merged;
+                } else {
+                    console.log(chalk.yellow("⏭️  Skipped due to user choice."));
+                    continue;
+                }
+            }
+            else if (resolutionMethod === 'merge') {
+                // No prompt: always write merged result (may contain conflict markers)
+                let merged;
+
+                try {
+                    merged = mergeFiles(baseContent, local, content);
+                } catch (e) {
+                    console.log(chalk.red(`❌ Error merging: ${e.message}`));
+                    continue;
+                }
+                if (merged.includes('<<<<<<<')) {
+                    console.log(chalk.red.bold(`⚠️  Merge conflict markers written to ${filename}. Manual review required.`));
+                } else {
+                    console.log(chalk.green(`✔️  Merged ${filename} automatically.`));
+                }
+                finalContent = merged;
+            }
+            else {
+                // Unknown or unsupported mode (should not occur)
+                console.log(chalk.red(`❌ Unknown resolution method: ${resolutionMethod}`));
+                continue;
+            }
+        }
+
+        // --- Actually Write File (if required by resolution) ---
+        if (finalContent !== null) {
+            try {
+                // Lookup a matching file dir in our cache, in case the file was renamed
+                const cachedFilePath = findFileByTag(record.Id) || path.resolve(filePath);
+                
+                // Ensure the directory exists (paranoia for deeply nested files)
+                fs.mkdirSync(path.dirname(cachedFilePath), { recursive: true });
+                fs.writeFileSync(cachedFilePath, finalContent, "utf8");
+
+                // Add a file tag so we can keep track of file changes
+                await setFileTag(cachedFilePath, record.Id);
+
+                // Set mtime/atime for reproducible syncs (optional, best effort)
+                let mtimeMs = null;
+                if (record.ModifiedOn) {
+                    mtimeMs = new Date(record.ModifiedOn).getTime();
+                } else if (record.CreatedOn) {
+                    mtimeMs = new Date(record.CreatedOn).getTime();
+                }
+                if (mtimeMs) {
+                    const mtimeSeconds = mtimeMs / 1000;
+                    try {
+                        fs.utimesSync(cachedFilePath, mtimeSeconds, mtimeSeconds);
+                    } catch (e) {
+                        console.warn(`⚠️  Could not set times for ${cachedFilePath}: ${e.message}`);
+                    }
+                }
+
+
+                // If the server records content and the local files content match then we can update the base
+                if (sha256(finalContent) === sha256(record.Content)) {
+                    // We still need to use the expected filePath as the rename might be local only
+                    updateBase(filePath, record, cachedFilePath);
+                }
+            } catch (err) {
+                console.error(chalk.red(`❌ Failed to write file ${cachedFilePath}: ${err.message}`));
+            }
+        }
+    }
+};