lowdefy 4.7.3 → 5.0.0

package/dist/commands/upgrade/executePhase.js

@@ -0,0 +1,92 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import handlePrompt from './handlePrompt.js';
+import { askQuestion } from './handlePrompt.js';
+function updateLowdefyVersion(configDirectory, version) {
+    const yamlPath = path.join(configDirectory, 'lowdefy.yaml');
+    if (!fs.existsSync(yamlPath)) return;
+    let content = fs.readFileSync(yamlPath, 'utf8');
+    // Match both quoted and unquoted version values
+    content = content.replace(/^(lowdefy:\s*)(['"]?)[\d.]+(?:-[\w.-]+)?(\2)\s*$/m, `$1$2${version}$3`);
+    fs.writeFileSync(yamlPath, content);
+}
+function isGitRepo(directory) {
+    try {
+        execSync('git rev-parse --is-inside-work-tree', {
+            cwd: directory,
+            stdio: 'pipe'
+        });
+        return true;
+    } catch  {
+        return false;
+    }
+}
+async function executePhase({ phase, phaseIndex, totalPhases, targetDirectory, codemodsDirectory, logger }) {
+    const phaseLabel = `[${phaseIndex + 1}/${totalPhases}]`;
+    logger.info(`\n${phaseLabel} Upgrading to v${phase.version} — ${phase.description}`);
+    const results = [];
+    const totalCodemods = phase.codemods.length;
+    for(let j = 0; j < phase.codemods.length; j++){
+        const codemod = phase.codemods[j];
+        const stepLabel = `${phaseLabel} [${j + 1}/${totalCodemods}]`;
+        const label = codemod.description;
+        if (!codemod.path) {
+            logger.warn(`  ${stepLabel} ${label} — no path defined, skipping.`);
+            results.push({
+                id: codemod.id,
+                status: 'skipped'
+            });
+            continue;
+        }
+        const codemodPath = path.join(codemodsDirectory, codemod.path);
+        logger.info(`  ${stepLabel} ${label}`);
+        const result = await handlePrompt({
+            path: codemodPath,
+            codemodId: codemod.id,
+            stepLabel,
+            logger
+        });
+        results.push({
+            id: codemod.id,
+            status: result.status
+        });
+    }
+    updateLowdefyVersion(targetDirectory, phase.version);
+    logger.info(`\n  Updated lowdefy.yaml: lowdefy: '${phase.version}'`);
+    if (isGitRepo(targetDirectory)) {
+        const answer = await askQuestion(`  Commit this phase? [Y/n] `);
+        if (answer === '' || answer.toLowerCase() === 'y') {
+            try {
+                execSync(`git add -A && git commit -m "chore: upgrade to lowdefy v${phase.version}"`, {
+                    cwd: targetDirectory,
+                    stdio: 'inherit'
+                });
+            } catch  {
+                logger.warn('  Git commit failed. You can commit manually.');
+            }
+        }
+    }
+    logger.info(`  ✓ Phase complete.`);
+    return {
+        version: phase.version,
+        status: 'completed',
+        codemods: results
+    };
+}
+export default executePhase;
+export { updateLowdefyVersion };

package/dist/commands/upgrade/getCodemods.js

@@ -0,0 +1,70 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import fs from 'fs';
+import path from 'path';
+import axios from 'axios';
+import { cleanDirectory, readFile } from '@lowdefy/node-utils';
+import fetchNpmTarball from '../../utils/fetchNpmTarball.js';
+async function getCodemods({ directory, logger }) {
+    const packageJsonPath = path.join(directory, 'package.json');
+    // Query npm for the latest version
+    let latestVersion;
+    try {
+        const packageInfo = await axios.get('https://registry.npmjs.org/@lowdefy/codemods');
+        latestVersion = packageInfo.data['dist-tags']?.latest;
+    } catch (error) {
+        if (error.response?.status === 404) {
+            throw new Error('No @lowdefy/codemods package found on npm. Upgrade manually using the migration guide.');
+        }
+        throw error;
+    }
+    if (!latestVersion) {
+        throw new Error('Could not determine latest @lowdefy/codemods version.');
+    }
+    // Check if cached version matches
+    let fetchCodemods = false;
+    const exists = fs.existsSync(packageJsonPath);
+    if (!exists) {
+        fetchCodemods = true;
+    } else {
+        const cachedConfig = JSON.parse(await readFile(packageJsonPath));
+        if (cachedConfig.version !== latestVersion) {
+            logger.info(`Updating codemods package from ${cachedConfig.version} to ${latestVersion}.`);
+            await cleanDirectory(directory);
+            fetchCodemods = true;
+        }
+    }
+    if (fetchCodemods) {
+        logger.info({
+            spin: 'start'
+        }, 'Fetching @lowdefy/codemods from npm.');
+        await fetchNpmTarball({
+            packageName: '@lowdefy/codemods',
+            version: latestVersion,
+            directory
+        });
+        logger.info('Fetched @lowdefy/codemods from npm.');
+    }
+    // Read and return registry
+    const registryPath = path.join(directory, 'registry.json');
+    if (!fs.existsSync(registryPath)) {
+        throw new Error('Codemods package missing registry.json.');
+    }
+    return {
+        registry: JSON.parse(fs.readFileSync(registryPath, 'utf8')),
+        directory
+    };
+}
+export default getCodemods;

package/dist/commands/upgrade/handlePrompt.js

@@ -0,0 +1,99 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import fs from 'fs';
+import { execSync } from 'child_process';
+import readline from 'readline';
+function detectAiTool() {
+    if (process.env.CLAUDE_CODE === '1' || fs.existsSync(`${process.env.HOME}/.claude`)) {
+        return 'Claude Code';
+    }
+    return null;
+}
+function askQuestion(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve)=>{
+        rl.question(question, (answer)=>{
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function copyToClipboard(text) {
+    try {
+        if (process.platform === 'darwin') {
+            execSync('pbcopy', {
+                input: text
+            });
+        } else if (process.platform === 'linux') {
+            execSync('xclip -selection clipboard', {
+                input: text
+            });
+        } else if (process.platform === 'win32') {
+            execSync('clip', {
+                input: text
+            });
+        }
+        return true;
+    } catch  {
+        return false;
+    }
+}
+async function handlePrompt({ path: filePath, codemodId, stepLabel, logger }) {
+    const prefix = stepLabel ? `  ${stepLabel}` : '   ';
+    const aiTool = detectAiTool();
+    if (!filePath || !fs.existsSync(filePath)) {
+        logger.warn(`${prefix} No prompt/guide found for ${codemodId}. Skipping.`);
+        return {
+            status: 'skipped'
+        };
+    }
+    const content = fs.readFileSync(filePath, 'utf8');
+    if (aiTool) {
+        logger.info(`${prefix} ${aiTool} detected.`);
+    }
+    logger.info(`${prefix} [1] Copy migration prompt to clipboard`);
+    logger.info(`${prefix} [2] View migration guide`);
+    logger.info(`${prefix} [3] Skip for now`);
+    const answer = await askQuestion(`${prefix} > `);
+    const choice = parseInt(answer, 10);
+    if (choice === 1) {
+        const copied = copyToClipboard(content);
+        if (copied) {
+            logger.info(`${prefix} Prompt copied to clipboard. Paste into your AI tool, then press Enter when done.`);
+        } else {
+            logger.info(`${prefix} Could not copy to clipboard. Content:`);
+            logger.info(content);
+        }
+        await askQuestion(`${prefix} Press Enter when done...`);
+        return {
+            status: 'completed'
+        };
+    }
+    if (choice === 2) {
+        logger.info(content);
+        await askQuestion(`${prefix} Press Enter when done...`);
+        return {
+            status: 'completed'
+        };
+    }
+    return {
+        status: 'skipped'
+    };
+}
+export { detectAiTool, askQuestion, copyToClipboard };
+export default handlePrompt;

package/dist/commands/upgrade/resolveChain.js

@@ -0,0 +1,41 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import semver from 'semver';
+function resolveChain({ registry, currentVersion, targetVersion }) {
+    if (semver.gte(currentVersion, targetVersion)) {
+        return [];
+    }
+    const candidates = (registry.versions ?? []).filter((entry)=>semver.valid(entry.version) && semver.lte(entry.version, targetVersion)).sort((a, b)=>semver.compare(a.version, b.version));
+    const chain = [];
+    let cursor = currentVersion;
+    while(semver.lt(cursor, targetVersion)){
+        const match = candidates.find((entry)=>semver.gt(entry.version, cursor) && semver.satisfies(cursor, entry.from));
+        if (match) {
+            chain.push(match);
+            cursor = match.version;
+            continue;
+        }
+        // Gap handling: skip to next entry with version > cursor
+        const next = candidates.find((entry)=>semver.gt(entry.version, cursor));
+        if (next) {
+            chain.push(next);
+            cursor = next.version;
+            continue;
+        }
+        break;
+    }
+    return chain;
+}
+export default resolveChain;

package/dist/commands/upgrade/runUpgrade.js

@@ -0,0 +1,89 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { readUpgradeState, writeUpgradeState, clearUpgradeState } from './upgradeState.js';
+import executePhase from './executePhase.js';
+async function runUpgrade({ chain, targetDirectory, codemodsDirectory, logger, resume }) {
+    let phases;
+    if (resume) {
+        const state = readUpgradeState(targetDirectory);
+        if (!state) {
+            logger.warn('No upgrade state found. Starting fresh.');
+            phases = chain;
+        } else {
+            const completedVersions = new Set(state.phases.filter((p)=>p.status === 'completed').map((p)=>p.version));
+            phases = chain.filter((entry)=>!completedVersions.has(entry.version));
+            if (phases.length === 0) {
+                logger.info('All phases already completed.');
+                clearUpgradeState(targetDirectory);
+                return;
+            }
+            logger.info(`Resuming upgrade — ${phases.length} phase(s) remaining.`);
+        }
+    } else {
+        phases = chain;
+    }
+    // Write initial state
+    const state = {
+        startedAt: new Date().toISOString(),
+        fromVersion: chain[0]?.version ?? 'unknown',
+        toVersion: chain[chain.length - 1]?.version ?? 'unknown',
+        currentPhase: 0,
+        phases: chain.map((entry)=>({
+                version: entry.version,
+                status: 'pending',
+                codemods: entry.codemods.map((c)=>({
+                        id: c.id,
+                        status: 'pending'
+                    }))
+            }))
+    };
+    writeUpgradeState(targetDirectory, state);
+    let skippedCount = 0;
+    for(let i = 0; i < phases.length; i++){
+        const phase = phases[i];
+        // Update state to in-progress
+        const statePhase = state.phases.find((p)=>p.version === phase.version);
+        if (statePhase) statePhase.status = 'in-progress';
+        state.currentPhase = i;
+        writeUpgradeState(targetDirectory, state);
+        const result = await executePhase({
+            phase,
+            phaseIndex: i,
+            totalPhases: phases.length,
+            targetDirectory,
+            codemodsDirectory,
+            logger
+        });
+        // Update state to completed
+        if (statePhase) {
+            statePhase.status = 'completed';
+            statePhase.codemods = result.codemods;
+        }
+        writeUpgradeState(targetDirectory, state);
+        skippedCount += result.codemods.filter((c)=>c.status === 'skipped').length;
+    }
+    if (skippedCount > 0) {
+        logger.info(`\n⚠ ${skippedCount} codemod(s) were skipped. Run "npx lowdefy upgrade --resume" to complete them.`);
+    } else {
+        clearUpgradeState(targetDirectory);
+    }
+    const targetVersion = chain[chain.length - 1]?.version ?? 'unknown';
+    logger.info(`\n✓ Upgrade complete! Your app is now on Lowdefy ${targetVersion}.`);
+    logger.info(`\n  Next steps:`);
+    logger.info(`  - Review changes: git diff`);
+    logger.info(`  - Run your app: lowdefy dev`);
+    logger.info(`  - Run your tests`);
+}
+export default runUpgrade;

package/dist/commands/upgrade/upgrade.js

@@ -0,0 +1,136 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import path from 'path';
+import axios from 'axios';
+import semver from 'semver';
+import { updateLowdefyVersion } from './executePhase.js';
+import getCodemods from './getCodemods.js';
+import resolveChain from './resolveChain.js';
+import runUpgrade from './runUpgrade.js';
+import { readUpgradeState } from './upgradeState.js';
+import { askQuestion } from './handlePrompt.js';
+async function upgrade({ context }) {
+    const currentVersion = context.lowdefyVersion;
+    const logger = context.logger;
+    const configDirectory = context.directories.config;
+    const codemodsDir = path.join(configDirectory, '.lowdefy', 'codemods');
+    if (!semver.valid(currentVersion)) {
+        throw new Error(`Current version "${currentVersion}" is not a valid semver version.`);
+    }
+    logger.info(`Current version: ${currentVersion} (from lowdefy.yaml)`);
+    // Determine target version
+    let targetVersion = context.options.to;
+    if (!targetVersion) {
+        logger.info({
+            spin: 'start'
+        }, 'Checking latest Lowdefy version...');
+        try {
+            const packageInfo = await axios.get('https://registry.npmjs.org/lowdefy');
+            targetVersion = packageInfo.data['dist-tags'].latest;
+        } catch  {
+            throw new Error('Could not reach npm registry to determine latest version.');
+        }
+        logger.info(`Latest stable version: ${targetVersion}`);
+    }
+    if (!semver.valid(targetVersion)) {
+        throw new Error(`Target version "${targetVersion}" is not a valid semver version.`);
+    }
+    const targetIsPrerelease = semver.prerelease(targetVersion) !== null;
+    if (!targetIsPrerelease && semver.gt(currentVersion, targetVersion)) {
+        logger.info(`Already up to date (${currentVersion}).`);
+        return;
+    }
+    if (!targetIsPrerelease && semver.eq(currentVersion, targetVersion)) {
+        logger.info(`Version ${currentVersion} is already set in lowdefy.yaml.`);
+        const runCodemods = await askQuestion('Still run codemods for this version? [y/N] ');
+        if (!runCodemods || runCodemods.toLowerCase() !== 'y') {
+            logger.info('Upgrade skipped.');
+            return;
+        }
+    }
+    if (targetIsPrerelease) {
+        logger.warn(`
+---------------------------------------------------
+  Upgrading to prerelease version ${targetVersion}.
+  Features may change at any time.
+---------------------------------------------------`);
+        updateLowdefyVersion(configDirectory, targetVersion);
+        logger.info(`Updated lowdefy.yaml to version ${targetVersion}.`);
+        return;
+    }
+    logger.info(`\nUpgrade path: ${currentVersion} → ${targetVersion}\n`);
+    // Fetch codemods package
+    const { registry, directory: codemodsDirectory } = await getCodemods({
+        directory: codemodsDir,
+        logger
+    });
+    // Resolve chain
+    const chain = resolveChain({
+        registry,
+        currentVersion,
+        targetVersion
+    });
+    if (chain.length === 0) {
+        logger.info('No codemods needed for this upgrade. Update lowdefy.yaml manually.');
+        return;
+    }
+    // Handle resume
+    const resume = context.options.resume;
+    if (resume) {
+        const state = readUpgradeState(configDirectory);
+        if (!state) {
+            logger.warn('No upgrade in progress. Starting fresh.');
+        }
+    }
+    // Print plan
+    chain.forEach((phase, i)=>{
+        const codemodCount = phase.codemods.length;
+        logger.info(`  Phase ${i + 1}: v${phase.version} — ${codemodCount} codemod(s)`);
+        phase.codemods.forEach((c)=>{
+            logger.info(`    • ${c.description}`);
+        });
+        logger.info('');
+    });
+    if (context.options.plan) {
+        return;
+    }
+    // Confirm
+    const answer = await askQuestion('Proceed? [Y/n] ');
+    if (answer && answer.toLowerCase() !== 'y') {
+        logger.info('Upgrade cancelled.');
+        return;
+    }
+    // Execute
+    await runUpgrade({
+        chain,
+        targetDirectory: configDirectory,
+        codemodsDirectory,
+        logger,
+        resume
+    });
+    // Telemetry
+    if (context.sendTelemetry) {
+        await context.sendTelemetry({
+            data: {
+                upgrade: {
+                    from: currentVersion,
+                    to: targetVersion,
+                    phases: chain.length
+                }
+            }
+        });
+    }
+}
+export default upgrade;

package/dist/commands/upgrade/upgradeState.js

@@ -0,0 +1,43 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import fs from 'fs';
+import path from 'path';
+function getStatePath(directory) {
+    return path.join(directory, '.lowdefy', 'upgrade-state.json');
+}
+function readUpgradeState(directory) {
+    const statePath = getStatePath(directory);
+    if (!fs.existsSync(statePath)) {
+        return null;
+    }
+    return JSON.parse(fs.readFileSync(statePath, 'utf8'));
+}
+function writeUpgradeState(directory, state) {
+    const statePath = getStatePath(directory);
+    const dir = path.dirname(statePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, {
+            recursive: true
+        });
+    }
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n');
+}
+function clearUpgradeState(directory) {
+    const statePath = getStatePath(directory);
+    if (fs.existsSync(statePath)) {
+        fs.unlinkSync(statePath);
+    }
+}
+export { readUpgradeState, writeUpgradeState, clearUpgradeState };

package/dist/program.js

@@ -20,6 +20,7 @@ import init from './commands/init/init.js';
 import initDocker from './commands/init-docker/initDocker.js';
 import initVercel from './commands/init-vercel/initVercel.js';
 import start from './commands/start/start.js';
+import upgrade from './commands/upgrade/upgrade.js';
 import runCommand from './utils/runCommand.js';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
@@ -68,4 +69,8 @@ program.command('start').description('Start a Lowdefy production app.').usage('[
     cliVersion,
     handler: start
 }));
+program.command('upgrade').description('Upgrade a Lowdefy app to a newer version, applying codemods.').usage('[options]').addOption(options.configDirectory).addOption(options.disableTelemetry).addOption(options.logLevel).addOption(new Option('--to <version>', 'Target version. Default: latest stable.')).addOption(new Option('--plan', 'Show upgrade plan without executing.')).addOption(new Option('--resume', 'Resume a previously interrupted upgrade.')).action(runCommand({
+    cliVersion,
+    handler: upgrade
+}));
 export default program;

package/dist/utils/startUp.js

@@ -47,7 +47,10 @@ async function startUp({ context, options = {}, command }) {
         logger: context.logger,
         pnpmCmd: context.pnpmCmd
     });
-    await validateVersion(context);
+    await validateVersion({
+        ...context,
+        configDirectory: context.configDirectory
+    });
     context.sendTelemetry = getSendTelemetry(context);
     if (type.isNone(lowdefyVersion)) {
         context.logger.info(`Running 'lowdefy ${context.command}'.`);

package/dist/utils/validateVersion.js

@@ -12,9 +12,11 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ import axios from 'axios';
+*/ import fs from 'fs';
+import path from 'path';
+import axios from 'axios';
 import semver from 'semver';
-async function validateVersion({ cliVersion, lowdefyVersion, logger, requiresLowdefyYaml }) {
+async function validateVersion({ cliVersion, lowdefyVersion, logger, requiresLowdefyYaml, configDirectory }) {
     const ui = logger?.ui ?? logger ?? {
         warn: (message)=>console.warn(message)
     };
@@ -73,8 +75,27 @@ async function validateVersion({ cliVersion, lowdefyVersion, logger, requiresLow
     } catch (error) {
         ui.warn('Failed to check for latest Lowdefy version.');
     }
+    // Check for pending codemods from an interrupted upgrade
+    if (configDirectory) {
+        try {
+            const upgradeStatePath = path.join(configDirectory, '.lowdefy', 'upgrade-state.json');
+            if (fs.existsSync(upgradeStatePath)) {
+                const state = JSON.parse(fs.readFileSync(upgradeStatePath, 'utf8'));
+                const skipped = state.phases.flatMap((p)=>p.codemods).filter((c)=>c.status === 'skipped');
+                if (skipped.length > 0) {
+                    ui.warn(`
+-------------------------------------------------------------
+  ${skipped.length} codemod(s) were skipped during upgrade.
+  Run "npx lowdefy upgrade --resume" to complete them.
+-------------------------------------------------------------`);
+                }
+            }
+        } catch  {
+        // Ignore errors reading upgrade state
+        }
+    }
 }
 function isExperimentalVersion(version) {
-    return version.includes('alpha') || version.includes('beta') || version.includes('rc');
+    return version.includes('alpha') || version.includes('beta') || version.includes('rc') || version.includes('experimental');
 }
 export default validateVersion;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lowdefy",
-  "version": "4.7.3",
+  "version": "5.0.0",
   "license": "Apache-2.0",
   "description": "Lowdefy CLI",
   "homepage": "https://lowdefy.com",
@@ -32,10 +32,10 @@
   ],
   "exports": "./dist/index.js",
   "dependencies": {
-    "@lowdefy/errors": "4.7.3",
-    "@lowdefy/helpers": "4.7.3",
-    "@lowdefy/logger": "4.7.3",
-    "@lowdefy/node-utils": "4.7.3",
+    "@lowdefy/errors": "5.0.0",
+    "@lowdefy/helpers": "5.0.0",
+    "@lowdefy/logger": "5.0.0",
+    "@lowdefy/node-utils": "5.0.0",
     "axios": "1.8.2",
     "commander": "11.1.0",
     "decompress": "4.2.1",
@@ -47,9 +47,9 @@
   },
   "devDependencies": {
     "@jest/globals": "28.1.3",
-    "@swc/cli": "0.1.63",
-    "@swc/core": "1.3.99",
-    "@swc/jest": "0.2.29",
+    "@swc/cli": "0.8.0",
+    "@swc/core": "1.15.18",
+    "@swc/jest": "0.2.39",
     "jest": "28.1.3"
   },
   "engines": {
@@ -59,7 +59,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "swc src --out-dir dist --config-file ../../.swcrc --delete-dir-on-start --copy-files",
+    "build": "swc src --out-dir dist --config-file ../../.swcrc --cli-config-file ../../.swc-cli.json --copy-files",
     "clean": "rm -rf dist && rm -rf .lowdefy",
     "start": "node ./dist/index.js",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"