motia 0.5.11-beta.120-357906 → 0.5.11-beta.120-207545

package/dist/cjs/cloud/build/builders/node/index.js

@@ -68,7 +68,10 @@ class NodeBuilder {
     async buildApiSteps(steps) {
         const relativePath = path_1.default.relative(constants_1.distDir, this.builder.projectDir);
         const getStepPath = (step) => {
-            return step.filePath.replace(this.builder.projectDir, relativePath).replace(/(.*)\.(ts|js)$/, '$1.js');
+            return step.filePath
+                .replace(this.builder.projectDir, relativePath)
+                .replace(/(.*)\.(ts|js)$/, '$1.js')
+                .replace(/\\/g, '/');
         };
         const file = fs_1.default
             .readFileSync(path_1.default.join(__dirname, 'router-template.ts'), 'utf-8')

package/dist/cjs/cloud/build/builders/python/index.d.ts

@@ -5,9 +5,7 @@ export declare class PythonBuilder implements StepBuilder {
     private readonly builder;
     private readonly listener;
     private uvPackager;
-    private uvConfig;
     constructor(builder: Builder, listener: BuildListener);
-    private loadUvConfig;
     buildApiSteps(steps: Step<ApiRouteConfig>[]): Promise<RouterBuildResult>;
     build(step: Step): Promise<void>;
     private addStepToArchive;
@@ -18,4 +16,5 @@ export declare class PythonBuilder implements StepBuilder {
     private findInternalFiles;
     private resolveModulePaths;
     private getModuleName;
+    private waitForDirectoryReady;
 }

package/dist/cjs/cloud/build/builders/python/index.js

@@ -10,40 +10,22 @@ const archiver_1 = require("../archiver");
 const include_static_files_1 = require("../include-static-files");
 const constants_1 = require("../../../new-deployment/constants");
 const uv_packager_1 = require("./uv-packager");
+const activate_python_env_1 = require("../../../../utils/activate-python-env");
 class PythonBuilder {
     constructor(builder, listener) {
         this.builder = builder;
         this.listener = listener;
-        this.uvConfig = { ...uv_packager_1.defaultUvConfig, ...this.loadUvConfig() };
-        this.uvPackager = new uv_packager_1.UvPackager(this.builder.projectDir, this.uvConfig);
-    }
-    loadUvConfig() {
-        const configFiles = ['uv.config.json', '.uvrc.json'];
-        for (const configFile of configFiles) {
-            const configPath = path_1.default.join(this.builder.projectDir, configFile);
-            if (fs_1.default.existsSync(configPath)) {
-                try {
-                    const configContent = fs_1.default.readFileSync(configPath, 'utf-8');
-                    return JSON.parse(configContent);
-                }
-                catch (err) {
-                    console.warn(`Warning: Failed to load UV config from ${configFile}`);
-                }
-            }
-        }
-        return {};
+        (0, activate_python_env_1.activatePythonVenv)({ baseDir: this.builder.projectDir });
+        this.uvPackager = new uv_packager_1.UvPackager(this.builder.projectDir);
     }
     async buildApiSteps(steps) {
         const zipName = 'router-python.zip';
         const archive = new archiver_1.Archiver(path_1.default.join(constants_1.distDir, zipName));
-        if (!await this.uvPackager.checkUvInstalled()) {
-            throw new Error('UV is not installed. Please install UV: curl -LsSf https://astral.sh/uv/install.sh | sh');
-        }
         const tempSitePackages = path_1.default.join(constants_1.distDir, `temp-python-packages-${Date.now()}`);
         try {
             await this.uvPackager.packageDependencies(tempSitePackages);
-            // Pequena pausa para garantir que o filesystem sincronize
-            await new Promise(resolve => setTimeout(resolve, 100));
+            // Wait for directory to be ready with proper access checks
+            await this.waitForDirectoryReady(tempSitePackages);
             await this.addPackagesToArchive(archive, tempSitePackages);
             for (const step of steps) {
                 await this.addStepToArchive(step, archive);
@@ -70,15 +52,12 @@ class PythonBuilder {
         this.builder.registerStep({ entrypointPath, bundlePath, step, type: 'python' });
         this.listener.onBuildStart(step);
         try {
-            if (!await this.uvPackager.checkUvInstalled()) {
-                throw new Error('UV is not installed. Please install UV: curl -LsSf https://astral.sh/uv/install.sh | sh');
-            }
             fs_1.default.mkdirSync(path_1.default.dirname(outfile), { recursive: true });
             const archive = new archiver_1.Archiver(outfile);
             const tempSitePackages = path_1.default.join(constants_1.distDir, `temp-python-packages-${Date.now()}`);
             try {
                 await this.uvPackager.packageDependencies(tempSitePackages);
-                await new Promise(resolve => setTimeout(resolve, 100));
+                await this.waitForDirectoryReady(tempSitePackages);
                 await this.addStepToArchive(step, archive);
                 await this.addPackagesToArchive(archive, tempSitePackages);
                 (0, include_static_files_1.includeStaticFiles)([step], this.builder, archive);
@@ -113,7 +92,6 @@ class PythonBuilder {
             console.warn(`Warning: Site packages directory not found: ${sitePackagesDir}`);
             return;
         }
-        // Verificar se o diretório está acessível
         try {
             fs_1.default.accessSync(sitePackagesDir, fs_1.default.constants.R_OK);
         }
@@ -208,13 +186,11 @@ class PythonBuilder {
             files.push(path_1.default.relative(this.builder.projectDir, filePath));
             try {
                 const content = fs_1.default.readFileSync(filePath, 'utf-8');
-                // Regex melhorada para capturar imports mais complexos
                 const importRegex = /^(?:from\s+([a-zA-Z_][a-zA-Z0-9_.]*)\s+import|import\s+([a-zA-Z_][a-zA-Z0-9_.]*))/gm;
                 let match;
                 while ((match = importRegex.exec(content)) !== null) {
                     const moduleName = match[1] || match[2]; // from X import Y ou import X
-                    // Verificar diferentes formas de import
-                    this.resolveModulePaths(moduleName, path_1.default.dirname(filePath)).forEach(possiblePath => {
+                    this.resolveModulePaths(moduleName, path_1.default.dirname(filePath)).forEach((possiblePath) => {
                         if (fs_1.default.existsSync(possiblePath)) {
                             analyzeFile(possiblePath);
                         }
@@ -233,23 +209,47 @@ class PythonBuilder {
         const baseName = parts[0];
         const subPath = parts.length > 1 ? path_1.default.join(...parts) : baseName;
         return [
-            // Relativo ao arquivo atual
             path_1.default.join(currentDir, `${baseName}.py`),
             path_1.default.join(currentDir, baseName, '__init__.py'),
             path_1.default.join(currentDir, `${subPath}.py`),
-            // Relativo ao diretório do projeto
             path_1.default.join(this.builder.projectDir, `${baseName}.py`),
             path_1.default.join(this.builder.projectDir, baseName, '__init__.py'),
             path_1.default.join(this.builder.projectDir, `${subPath}.py`),
-            // Para utils.database -> utils/database.py
             path_1.default.join(this.builder.projectDir, subPath + '.py'),
             path_1.default.join(this.builder.projectDir, subPath, '__init__.py'),
         ];
     }
     getModuleName(step) {
-        return this.normalizeStepPath(step, true)
-            .replace(/\.py$/, '')
-            .replace(/\//g, '.');
+        return this.normalizeStepPath(step, true).replace(/\.py$/, '').replace(/\//g, '.');
+    }
+    async waitForDirectoryReady(dirPath, maxRetries = 10, initialDelayMs = 10) {
+        let lastError = null;
+        for (let i = 0; i < maxRetries; i++) {
+            try {
+                const exists = await fs_1.default.promises
+                    .access(dirPath, fs_1.default.constants.F_OK)
+                    .then(() => true)
+                    .catch(() => false);
+                if (!exists) {
+                    // Directory doesn't exist yet, wait
+                    lastError = new Error(`Directory ${dirPath} does not exist yet`);
+                }
+                else {
+                    await fs_1.default.promises.access(dirPath, fs_1.default.constants.R_OK);
+                    return;
+                }
+            }
+            catch (error) {
+                lastError = error;
+            }
+            if (i === maxRetries - 1) {
+                throw new Error(`Directory ${dirPath} is not accessible after ${maxRetries} attempts. ` +
+                    `Last error: ${lastError?.message || 'Unknown error'}`);
+            }
+            // Exponential backoff: 10ms, 20ms, 40ms, 80ms, etc.
+            const delay = initialDelayMs * Math.pow(2, i);
+            await new Promise((resolve) => setTimeout(resolve, Math.min(delay, 1000))); // Cap at 1 second
+        }
     }
 }
 exports.PythonBuilder = PythonBuilder;

package/dist/cjs/cloud/build/builders/python/uv-packager.d.ts

@@ -8,7 +8,6 @@ export declare class UvPackager {
     private readonly projectDir;
     private readonly config;
     constructor(projectDir: string, config?: UvPackageConfig);
-    checkUvInstalled(): Promise<boolean>;
+    private runCommand;
     packageDependencies(targetDir: string): Promise<void>;
-    private runUvCommand;
 }

package/dist/cjs/cloud/build/builders/python/uv-packager.js

@@ -8,53 +8,28 @@ const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 exports.defaultUvConfig = {
-    pythonVersion: '3.13',
-    platform: 'x86_64-manylinux2014',
-    onlyBinary: true
+    pythonVersion: process.env.MOTIA_PYTHON_VERSION || '3.13',
+    platform: process.env.MOTIA_PLATFORM || 'x86_64-manylinux2014',
+    onlyBinary: process.env.MOTIA_ONLY_BINARY !== 'false',
 };
 class UvPackager {
     constructor(projectDir, config = exports.defaultUvConfig) {
         this.projectDir = projectDir;
         this.config = config;
     }
-    async checkUvInstalled() {
-        return new Promise((resolve) => {
-            const child = (0, child_process_1.spawn)('uv', ['--version'], { stdio: 'pipe' });
-            child.on('close', (code) => resolve(code === 0));
-            child.on('error', () => resolve(false));
-        });
-    }
-    async packageDependencies(targetDir) {
-        if (!fs_1.default.existsSync(targetDir)) {
-            fs_1.default.mkdirSync(targetDir, { recursive: true });
-        }
-        const requirementsFile = path_1.default.join(this.projectDir, 'requirements.txt');
-        if (!fs_1.default.existsSync(requirementsFile)) {
-            return;
-        }
-        const args = [
-            'pip', 'install',
-            '--target', targetDir,
-            '--requirement', requirementsFile,
-            '--python-version', this.config.pythonVersion || '3.13',
-            '--python-platform', this.config.platform || 'x86_64-manylinux2014',
-            '--force-reinstall'
-        ];
-        if (this.config.onlyBinary) {
-            args.push('--only-binary=:all:');
-        }
-        await this.runUvCommand(args);
-    }
-    async runUvCommand(args) {
+    async runCommand(command, args, options) {
         return new Promise((resolve, reject) => {
-            const child = (0, child_process_1.spawn)('uv', args, {
-                cwd: this.projectDir,
-                stdio: ['pipe', 'pipe', 'pipe']
+            const child = (0, child_process_1.spawn)(command, args, {
+                cwd: options?.cwd,
+                stdio: ['pipe', 'pipe', 'pipe'],
             });
             let stdout = '';
             let stderr = '';
             child.stdout?.on('data', (data) => {
                 stdout += data.toString();
+                if (options?.showOutput) {
+                    process.stdout.write(data);
+                }
             });
             child.stderr?.on('data', (data) => {
                 stderr += data.toString();
@@ -64,13 +39,39 @@ class UvPackager {
                     resolve(stdout);
                 }
                 else {
-                    reject(new Error(`UV command failed: ${stderr || stdout}`));
+                    const errorPrefix = `Command '${command}'`;
+                    reject(new Error(`${errorPrefix} failed: ${stderr || stdout}`));
                 }
             });
             child.on('error', (error) => {
-                reject(new Error(`Failed to spawn UV: ${error.message}`));
+                reject(new Error(`Failed to spawn ${command}: ${error.message}`));
             });
         });
     }
+    async packageDependencies(targetDir) {
+        if (!fs_1.default.existsSync(targetDir)) {
+            fs_1.default.mkdirSync(targetDir, { recursive: true });
+        }
+        const requirementsFile = path_1.default.join(this.projectDir, 'requirements.txt');
+        if (!fs_1.default.existsSync(requirementsFile)) {
+            return;
+        }
+        const args = [
+            'pip',
+            'install',
+            '--target',
+            targetDir,
+            '--requirement',
+            requirementsFile,
+            '--python-version',
+            this.config.pythonVersion || '3.13',
+            '--python-platform',
+            this.config.platform || 'x86_64-manylinux2014',
+        ];
+        if (this.config.onlyBinary) {
+            args.push('--only-binary=:all:');
+        }
+        await this.runCommand('uv', args, { cwd: this.projectDir });
+    }
 }
 exports.UvPackager = UvPackager;

package/dist/cjs/cloud/cli/deploy.js

@@ -13,11 +13,13 @@ cli_1.cloudCli
     .command('deploy')
     .description('Deploy a new version to Motia Cloud')
     .requiredOption('-k, --api-key <key>', 'The API key for authentication', process.env.MOTIA_API_KEY)
-    .requiredOption('-v, --version-name <version>', 'The version to deploy')
     .option('-p, --project-id <id>', 'Project ID (Deprecated)')
+    .option('-n, --project-name <name>', 'Project name (used when creating a new project)')
     .option('-s, --environment-id <id>', 'Environment ID', process.env.MOTIA_ENVIRONMENT_ID)
+    .option('--environment-name <name>', 'Environment name')
     .option('-e, --env-file <path>', 'Path to environment file')
-    .option('-n, --project-name <name>', 'Project name (used when creating a new project)', '')
+    .requiredOption('-v, --version-name <version>', 'The version to deploy')
+    .option('-d, --version-description <description>', 'The description of the version')
     .action((0, config_utils_1.handler)(async (arg, context) => {
     const listener = new cli_listener_1.CliListener(context);
     const builder = await (0, build_1.build)(listener);
@@ -30,9 +32,11 @@ cli_1.cloudCli
     const deployment = await cloud_api_1.cloudApi
         .createDeployment({
         apiKey: arg.apiKey,
-        versionName: arg.versionName,
-        environmentId: arg.environmentId,
         projectName: arg.projectName,
+        environmentId: arg.environmentId,
+        environmentName: arg.environmentName,
+        versionName: arg.versionName,
+        versionDescription: arg.versionDescription,
     })
         .catch((error) => {
         context.log('creating-deployment', (message) => message.tag('failed').append('Failed to create deployment'));

package/dist/cjs/cloud/endpoints.d.ts

@@ -0,0 +1,2 @@
+import { LockedData, MotiaServer } from '@motiadev/core';
+export declare const deployEndpoints: (server: MotiaServer, lockedData: LockedData) => void;

package/dist/cjs/cloud/endpoints.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployEndpoints = void 0;
+const crypto_1 = require("crypto");
+const build_validation_1 = require("./build/build-validation");
+const streaming_deployment_listener_1 = require("./new-deployment/listeners/streaming-deployment-listener");
+const build_1 = require("./new-deployment/build");
+const upload_artifacts_1 = require("./new-deployment/upload-artifacts");
+const deployment_stream_1 = require("./new-deployment/streams/deployment-stream");
+const cloud_api_1 = require("./new-deployment/cloud-api");
+const version_1 = require("../version");
+const deployEndpoints = (server, lockedData) => {
+    const { app } = server;
+    // Criar stream de deployment se não existir
+    const deploymentStream = lockedData.createStream({
+        filePath: '__motia.deployment',
+        hidden: true,
+        config: {
+            name: '__motia.deployment',
+            baseConfig: { storageType: 'default' },
+            schema: null,
+        },
+    })();
+    const deploymentManager = new deployment_stream_1.DeploymentStreamManager(deploymentStream);
+    app.get('/__motia', (_, res) => {
+        res.status(200).json({ version: version_1.version });
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    app.post('/__motia/cloud/deploy/start', async (req, res) => {
+        try {
+            const { deploymentToken, deploymentId, envs } = req.body;
+            const sessionId = deploymentId || (0, crypto_1.randomUUID)();
+            if (!deploymentToken || !deploymentId) {
+                return res.status(400).json({
+                    success: false,
+                    error: 'deploymentToken and deploymentId are required',
+                });
+            }
+            await deploymentManager.startDeployment(sessionId);
+            const listener = new streaming_deployment_listener_1.StreamingDeploymentListener(sessionId, deploymentStream);
+            res.json({
+                success: true,
+                message: 'Deployment started',
+                deploymentId: sessionId,
+                streamName: 'deployment-status',
+                groupId: 'deployments',
+                itemId: sessionId,
+            });
+            setImmediate(async () => {
+                try {
+                    await listener.startBuildPhase();
+                    const builder = await (0, build_1.build)(listener).catch(() => {
+                        throw new Error('Build failed, check the logs for more information');
+                    });
+                    const isValid = (0, build_validation_1.buildValidation)(builder, listener);
+                    if (!isValid) {
+                        await listener.onBuildErrors(listener.getErrors());
+                        return;
+                    }
+                    await listener.startUploadPhase();
+                    await (0, upload_artifacts_1.uploadArtifacts)(builder, deploymentToken, listener);
+                    await listener.startDeployPhase();
+                    await cloud_api_1.cloudApi.startDeployment({
+                        deploymentToken,
+                        envVars: envs,
+                        steps: builder.stepsConfig,
+                        streams: builder.streamsConfig,
+                        routers: builder.routersConfig,
+                    });
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (error) {
+                    console.error('Deployment failed:', error);
+                    // Update stream with error
+                    if (listener) {
+                        await listener.onDeployError(error.message);
+                    }
+                }
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            console.error('Failed to start deployment:', error);
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    app.get('/__motia/cloud/deploy/status/:deploymentId', async (req, res) => {
+        try {
+            const { deploymentId } = req.params;
+            const deployment = await deploymentManager.getDeployment(deploymentId);
+            return deployment
+                ? res.status(200).json({ success: true, deployment })
+                : res.status(404).json({ success: false, error: 'Deployment not found' });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+};
+exports.deployEndpoints = deployEndpoints;

package/dist/cjs/cloud/new-deployment/cloud-api/create-deployment.d.ts

@@ -1,8 +1,10 @@
 type CreateDeploymentRequest = {
     apiKey: string;
+    projectName?: string;
     environmentId?: string;
+    environmentName?: string;
     versionName: string;
-    projectName?: string;
+    versionDescription?: string;
 };
 type CreateDeploymentResult = {
     deploymentId: string;

package/dist/cjs/cloud/new-deployment/cloud-api/index.d.ts

@@ -11,9 +11,11 @@ export declare const cloudApi: {
     }>;
     createDeployment: (request: {
         apiKey: string;
+        projectName?: string;
         environmentId?: string;
+        environmentName?: string;
         versionName: string;
-        projectName?: string;
+        versionDescription?: string;
     }) => Promise<{
         deploymentId: string;
         deploymentToken: string;

package/dist/cjs/cloud/new-deployment/listeners/streaming-deployment-listener.d.ts

@@ -0,0 +1,44 @@
+import { Step, MotiaStream } from '@motiadev/core';
+import { Stream } from '@motiadev/core/dist/src/types-stream';
+import { BuildStepConfig } from '../../build/builder';
+import { ValidationError } from '../../build/build-validation';
+import { DeploymentListener, DeployData } from './listener.types';
+import { DeploymentData } from '../streams/deployment-stream';
+export declare class StreamingDeploymentListener implements DeploymentListener {
+    private deploymentId;
+    private errors;
+    private warnings;
+    private streamManager;
+    constructor(deploymentId: string, deploymentStream: MotiaStream<DeploymentData>);
+    private relativePath;
+    private getStepType;
+    private getLanguage;
+    private updateStream;
+    getErrors(): ValidationError[];
+    onBuildStart(step: Step): Promise<void>;
+    onBuildProgress(step: Step, message: string): Promise<void>;
+    onBuildEnd(step: Step, size: number): Promise<void>;
+    onBuildError(step: Step, error: Error): Promise<void>;
+    onBuildSkip(step: Step, reason: string): Promise<void>;
+    onStreamCreated(stream: Stream): Promise<void>;
+    onApiRouterBuilding(language: string): Promise<void>;
+    onApiRouterBuilt(language: string, size: number): Promise<void>;
+    onWarning(id: string, warning: string): Promise<void>;
+    onBuildWarning(warning: ValidationError): Promise<void>;
+    onBuildErrors(errors: ValidationError[]): Promise<void>;
+    stepUploadStart(stepPath: string, step: BuildStepConfig): Promise<void>;
+    stepUploadProgress(stepPath: string, step: BuildStepConfig, progress: number): Promise<void>;
+    stepUploadEnd(stepPath: string, step: BuildStepConfig): Promise<void>;
+    stepUploadError(stepPath: string, step: BuildStepConfig): Promise<void>;
+    routeUploadStart(path: string, language: string): Promise<void>;
+    routeUploadProgress(path: string, language: string, progress: number): Promise<void>;
+    routeUploadEnd(path: string, language: string): Promise<void>;
+    routeUploadError(path: string, language: string): Promise<void>;
+    onDeployStart(): Promise<void>;
+    onDeployProgress(data: DeployData): Promise<void>;
+    onDeployEnd(): Promise<void>;
+    onDeployError(errorMessage: string): Promise<void>;
+    startBuildPhase(): Promise<void>;
+    startUploadPhase(): Promise<void>;
+    startDeployPhase(): Promise<void>;
+}