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

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/add-package-to-archive.d.ts

@@ -0,0 +1,2 @@
+import { Archiver } from '../archiver';
+export declare const addPackageToArchive: (archive: Archiver, sitePackagesDir: string, packageName: string) => Promise<void>;

package/dist/cjs/cloud/build/builders/python/add-package-to-archive.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addPackageToArchive = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const colors_1 = __importDefault(require("colors"));
+const shouldIgnore = (filePath) => {
+    const ignorePatterns = [/\.pyc$/, /\.egg$/, /__pycache__/, /\.dist-info$/];
+    return ignorePatterns.some((pattern) => pattern.test(filePath));
+};
+const addDirectoryToArchive = async (archive, baseDir, dirPath) => {
+    const files = fs_1.default.readdirSync(dirPath);
+    await Promise.all(files
+        .map(async (file) => {
+        const fullPath = path_1.default.join(dirPath, file);
+        const relativePath = path_1.default.relative(baseDir, fullPath);
+        if (shouldIgnore(relativePath)) {
+            return;
+        }
+        const stat = fs_1.default.statSync(fullPath);
+        if (stat.isDirectory()) {
+            await addDirectoryToArchive(archive, baseDir, fullPath);
+        }
+        else {
+            archive.append(fs_1.default.createReadStream(fullPath), relativePath);
+        }
+    })
+        .filter(Boolean));
+};
+const addPackageToArchive = async (archive, sitePackagesDir, packageName) => {
+    // First try the package name as is
+    let fullPath = path_1.default.join(sitePackagesDir, packageName);
+    // If not found, try with .py extension
+    if (!fs_1.default.existsSync(fullPath)) {
+        const pyPath = path_1.default.join(sitePackagesDir, `${packageName}.py`);
+        if (fs_1.default.existsSync(pyPath)) {
+            fullPath = pyPath;
+        }
+    }
+    if (!fs_1.default.existsSync(fullPath)) {
+        console.log(colors_1.default.yellow(`Warning: Package not found in site-packages: ${packageName}`));
+        return;
+    }
+    const stat = fs_1.default.statSync(fullPath);
+    if (stat.isDirectory()) {
+        await addDirectoryToArchive(archive, sitePackagesDir, fullPath);
+    }
+    else {
+        const relativePath = path_1.default.relative(sitePackagesDir, fullPath);
+        archive.append(fs_1.default.createReadStream(fullPath), relativePath);
+    }
+};
+exports.addPackageToArchive = addPackageToArchive;

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

@@ -4,18 +4,9 @@ import { BuildListener } from '../../../new-deployment/listeners/listener.types'
 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>;
+    private buildStep;
     build(step: Step): Promise<void>;
-    private addStepToArchive;
-    private addPackagesToArchive;
-    private shouldIgnoreFile;
-    private normalizeStepPath;
-    private createRouterTemplate;
-    private findInternalFiles;
-    private resolveModulePaths;
-    private getModuleName;
+    buildApiSteps(steps: Step<ApiRouteConfig>[]): Promise<RouterBuildResult>;
+    private getPythonBuilderData;
 }

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

@@ -4,252 +4,116 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PythonBuilder = void 0;
+const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const activate_python_env_1 = require("../../../../utils/activate-python-env");
 const archiver_1 = require("../archiver");
 const include_static_files_1 = require("../include-static-files");
+const add_package_to_archive_1 = require("./add-package-to-archive");
 const constants_1 = require("../../../new-deployment/constants");
-const uv_packager_1 = require("./uv-packager");
 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);
+        (0, activate_python_env_1.activatePythonVenv)({ baseDir: this.builder.projectDir });
     }
-    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 {};
-    }
-    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));
-            await this.addPackagesToArchive(archive, tempSitePackages);
-            for (const step of steps) {
-                await this.addStepToArchive(step, archive);
-            }
-            const routerTemplate = this.createRouterTemplate(steps);
-            archive.append(routerTemplate, 'router.py');
-            (0, include_static_files_1.includeStaticFiles)(steps, this.builder, archive);
-            const size = await archive.finalize();
-            return { size, path: zipName };
-        }
-        catch (error) {
-            throw new Error(`Failed to build Python API router: ${error}`);
-        }
-        finally {
-            if (fs_1.default.existsSync(tempSitePackages)) {
-                fs_1.default.rmSync(tempSitePackages, { recursive: true, force: true });
-            }
+    async buildStep(step, archive) {
+        const entrypointPath = step.filePath.replace(this.builder.projectDir, '');
+        const normalizedEntrypointPath = entrypointPath.replace(/[.]step.py$/, '_step.py');
+        const sitePackagesDir = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
+        // Get Python builder response
+        const { packages } = await this.getPythonBuilderData(step);
+        // Add main file to archive
+        if (!fs_1.default.existsSync(step.filePath)) {
+            throw new Error(`Source file not found: ${step.filePath}`);
         }
+        archive.append(fs_1.default.createReadStream(step.filePath), path_1.default.relative(this.builder.projectDir, normalizedEntrypointPath));
+        await Promise.all(packages.map(async (packageName) => (0, add_package_to_archive_1.addPackageToArchive)(archive, sitePackagesDir, packageName)));
+        return normalizedEntrypointPath;
     }
     async build(step) {
         const entrypointPath = step.filePath.replace(this.builder.projectDir, '');
         const bundlePath = path_1.default.join('python', entrypointPath.replace(/(.*)\.py$/, '$1.zip'));
+        const normalizedEntrypointPath = entrypointPath.replace(/[.]step.py$/, '_step.py');
         const outfile = path_1.default.join(constants_1.distDir, bundlePath);
-        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');
-            }
+            // Create output directory
             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.addStepToArchive(step, archive);
-                await this.addPackagesToArchive(archive, tempSitePackages);
-                (0, include_static_files_1.includeStaticFiles)([step], this.builder, archive);
-                const size = await archive.finalize();
-                this.listener.onBuildEnd(step, size);
+            this.listener.onBuildStart(step);
+            // Get Python builder response
+            const { packages } = await this.getPythonBuilderData(step);
+            const stepArchiver = new archiver_1.Archiver(outfile);
+            const stepPath = await this.buildStep(step, stepArchiver);
+            // Add main file to archive
+            if (!fs_1.default.existsSync(step.filePath)) {
+                throw new Error(`Source file not found: ${step.filePath}`);
             }
-            finally {
-                if (fs_1.default.existsSync(tempSitePackages)) {
-                    fs_1.default.rmSync(tempSitePackages, { recursive: true, force: true });
-                }
+            stepArchiver.append(fs_1.default.createReadStream(step.filePath), path_1.default.relative(this.builder.projectDir, normalizedEntrypointPath));
+            // Add all imported files to archive
+            this.listener.onBuildProgress(step, 'Adding imported files to archive...');
+            const sitePackagesDir = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
+            (0, include_static_files_1.includeStaticFiles)([step], this.builder, stepArchiver);
+            if (packages.length > 0) {
+                await Promise.all(packages.map(async (packageName) => (0, add_package_to_archive_1.addPackageToArchive)(stepArchiver, sitePackagesDir, packageName)));
+                this.listener.onBuildProgress(step, `Added ${packages.length} packages to archive`);
             }
+            // Finalize the archive and wait for completion
+            const size = await stepArchiver.finalize();
+            this.builder.registerStep({ entrypointPath: stepPath, bundlePath, step, type: 'python' });
+            this.listener.onBuildEnd(step, size);
         }
         catch (err) {
             this.listener.onBuildError(step, err);
             throw err;
         }
     }
-    async addStepToArchive(step, archive) {
-        const normalizedPath = this.normalizeStepPath(step, false);
-        archive.append(fs_1.default.createReadStream(step.filePath), normalizedPath);
-        const internalFiles = await this.findInternalFiles(step.filePath);
-        for (const file of internalFiles) {
-            const fullPath = path_1.default.join(this.builder.projectDir, file);
-            if (fs_1.default.existsSync(fullPath) && fullPath !== step.filePath) {
-                const archivePath = file.replace(/\.step\.py$/, '_step.py');
-                archive.append(fs_1.default.createReadStream(fullPath), archivePath);
-            }
-        }
-    }
-    async addPackagesToArchive(archive, sitePackagesDir) {
-        if (!fs_1.default.existsSync(sitePackagesDir)) {
-            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);
-        }
-        catch (error) {
-            console.warn(`Warning: Cannot access site packages directory: ${sitePackagesDir}`);
-            return;
-        }
-        const addDirectory = (dirPath, basePath = sitePackagesDir) => {
-            try {
-                const items = fs_1.default.readdirSync(dirPath);
-                for (const item of items) {
-                    const fullPath = path_1.default.join(dirPath, item);
-                    const relativePath = path_1.default.relative(basePath, fullPath);
-                    if (this.shouldIgnoreFile(relativePath)) {
-                        continue;
-                    }
-                    try {
-                        const stat = fs_1.default.statSync(fullPath);
-                        if (stat.isDirectory()) {
-                            addDirectory(fullPath, basePath);
-                        }
-                        else {
-                            archive.append(fs_1.default.createReadStream(fullPath), relativePath);
-                        }
-                    }
-                    catch (error) {
-                        console.warn(`Warning: Could not process file ${fullPath}: ${error}`);
-                    }
-                }
-            }
-            catch (error) {
-                console.warn(`Warning: Could not read directory ${dirPath}: ${error}`);
-            }
+    async buildApiSteps(steps) {
+        const getStepPath = (step) => {
+            const normalizedEntrypointPath = step.filePath.replace(/[.]step.py$/, '_step.py');
+            return normalizedEntrypointPath
+                .replace(`${this.builder.projectDir}/`, '')
+                .replace(/(.*)\.py$/, '$1')
+                .replace(/\\/g, '.')
+                .replace(/\//g, '.');
         };
-        addDirectory(sitePackagesDir);
-    }
-    shouldIgnoreFile(filePath) {
-        const ignorePatterns = [
-            /\.pyc$/,
-            /\.pyo$/,
-            /\.egg$/,
-            /\.egg-info$/,
-            /__pycache__/,
-            /\.dist-info$/,
-            /^tests?\//,
-            /^docs?\//,
-            /^examples?\//,
-            /\.pytest_cache/,
-        ];
-        return ignorePatterns.some((pattern) => pattern.test(filePath));
-    }
-    normalizeStepPath(step, normalizePythonModulePath) {
-        let normalizedStepPath = step.filePath
-            .replace(/[.]step.py$/, '_step.py') // Replace .step.py with _step.py
-            .replace(`${this.builder.projectDir}/`, ''); // Remove the project directory from the path
-        const pathParts = normalizedStepPath.split(path_1.default.sep).map((part) => part
-            .replace(/^[0-9]+/g, '') // Remove numeric prefixes
-            .replace(/[^a-zA-Z0-9._]/g, '_') // Replace any non-alphanumeric characters (except dots) with underscores
-            .replace(/^_/, '')); // Remove leading underscore
-        normalizedStepPath = normalizePythonModulePath
-            ? pathParts.join('.') // Convert path delimiter to dot (python module separator)
-            : '/' + pathParts.join(path_1.default.sep);
-        return normalizedStepPath;
-    }
-    createRouterTemplate(steps) {
-        const imports = steps
-            .map((step, index) => {
-            const moduleName = this.getModuleName(step);
-            return `from ${moduleName} import handler as route${index}_handler, config as route${index}_config`;
-        })
-            .join('\n');
-        const routerPaths = steps
-            .map((step, index) => {
-            const method = step.config.method.toUpperCase();
-            const path = step.config.path;
-            return `    '${method} ${path}': RouterPath('${step.config.name}', '${step.config.method.toLowerCase()}', route${index}_handler, route${index}_config)`;
-        })
-            .join(',\n');
-        return fs_1.default
+        const zipName = 'router-python.zip';
+        const archive = new archiver_1.Archiver(path_1.default.join(constants_1.distDir, zipName));
+        const dependencies = ['uvicorn', 'pydantic', 'pydantic_core', 'uvloop', 'starlette', 'typing_inspection'];
+        const lambdaSitePackages = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
+        await Promise.all(dependencies.map(async (packageName) => (0, add_package_to_archive_1.addPackageToArchive)(archive, lambdaSitePackages, packageName)));
+        for (const step of steps) {
+            await this.buildStep(step, archive);
+        }
+        const file = fs_1.default
             .readFileSync(path_1.default.join(__dirname, 'router_template.py'), 'utf-8')
-            .replace('# {{imports}}', imports)
-            .replace('# {{router paths}}', routerPaths);
+            .replace('# {{imports}}', steps
+            .map((step, index) => `from ${getStepPath(step)} import handler as route${index}_handler, config as route${index}_config`)
+            .join('\n'))
+            .replace('# {{router paths}}', steps
+            .map((step, index) => `'${step.config.method} ${step.config.path}': RouterPath('${step.config.name}', '${step.config.method.toLowerCase()}', route${index}_handler, route${index}_config)`)
+            .join(',\n    '));
+        archive.append(file, 'router.py');
+        (0, include_static_files_1.includeStaticFiles)(steps, this.builder, archive);
+        // Finalize the archive and wait for completion
+        const size = await archive.finalize();
+        return { size, path: zipName };
     }
-    async findInternalFiles(entryFile) {
-        const files = [];
-        const visited = new Set();
-        const analyzeFile = (filePath) => {
-            if (visited.has(filePath) || !fs_1.default.existsSync(filePath)) {
-                return;
-            }
-            visited.add(filePath);
-            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 => {
-                        if (fs_1.default.existsSync(possiblePath)) {
-                            analyzeFile(possiblePath);
-                        }
-                    });
+    async getPythonBuilderData(step) {
+        return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)('python', [path_1.default.join(__dirname, 'python-builder.py'), step.filePath], {
+                cwd: this.builder.projectDir,
+                stdio: [undefined, undefined, 'pipe', 'ipc'],
+            });
+            const err = [];
+            child.on('stderr', (data) => err.push(data.toString()));
+            child.on('message', resolve);
+            child.on('close', (code) => {
+                if (code !== 0) {
+                    reject(new Error(err.join('')));
                 }
-            }
-            catch (error) {
-                console.warn(`Could not analyze file: ${filePath}`);
-            }
-        };
-        analyzeFile(entryFile);
-        return files;
-    }
-    resolveModulePaths(moduleName, currentDir) {
-        const parts = moduleName.split('.');
-        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, '.');
+            });
+        });
     }
 }
 exports.PythonBuilder = PythonBuilder;

package/dist/cjs/cloud/build/builders/python/python-builder.py

@@ -0,0 +1,226 @@
+import os
+import sys
+import json
+import importlib.util
+import traceback
+import site
+import builtins
+import ast
+import importlib.metadata
+import subprocess
+import re
+from typing import Set, List, Tuple, Optional, Dict, Any
+from pathlib import Path
+from functools import lru_cache
+
+NODEIPCFD = int(os.environ["NODE_CHANNEL_FD"])
+
+# Cache for built-in modules to avoid repeated checks
+_builtin_modules_cache: Set[str] = set()
+
+@lru_cache(maxsize=1024)
+def is_valid_package_name(name: str) -> bool:
+    """Check if a name is a valid package name."""
+    if not name or name.startswith('_'):
+        return False
+    
+    # Skip common special cases
+    invalid_names = {'__main__', 'module', 'cython_runtime', 'builtins'}
+    return name not in invalid_names
+
+@lru_cache(maxsize=1024)
+def get_package_name(module_name: str) -> str:
+    """Get the top-level package name from a module name."""
+    return module_name.split('.')[0]
+
+@lru_cache(maxsize=1024)
+def clean_package_name(package_name: str) -> str:
+    """Clean package name by removing version specifiers and other metadata."""
+    # Remove version specifiers and conditions using regex
+    package_name = re.sub(r'[<>=~!;].*$', '', package_name)
+    # Remove any remaining whitespace and convert underscores to hyphens
+    return package_name.strip().replace('_', '-')
+
+@lru_cache(maxsize=1024)
+def extract_base_package_name(dependency_spec: str) -> str:
+    """
+    Extract the base package name from a complex dependency specification.
+    Handles cases like:
+    - 'package (>=1.2.1,<2.0.0)'
+    - 'package[extra] (>=1.2.1)'
+    - 'package ; extra == "vlm"'
+    - 'package (>=1.2.1) ; sys_platform == "darwin"'
+    """
+    # First, remove any conditions after semicolon
+    base_spec = dependency_spec.split(';')[0].strip()
+    
+    # Extract the package name before any version specifiers or extras
+    match = re.match(r'^([a-zA-Z0-9_.-]+)(?:\[[^\]]+\])?(?:\s*\([^)]*\))?$', base_spec)
+    
+    return clean_package_name(match.group(1) if match else base_spec)
+
+@lru_cache(maxsize=1024)
+def is_package_installed(package_name: str) -> bool:
+    """Check if a package is installed in the current environment."""
+    try:
+        # Try both hyphenated and non-hyphenated versions
+        try:
+            importlib.metadata.distribution(package_name)
+            return True
+        except importlib.metadata.PackageNotFoundError:
+            # Try with hyphens replaced by underscores
+            alt_name = package_name.replace('-', '_')
+            if alt_name != package_name:
+                importlib.metadata.distribution(alt_name)
+                return True
+            return False
+    except importlib.metadata.PackageNotFoundError:
+        return False
+
+@lru_cache(maxsize=1024)
+def is_builtin_module(module_name: str) -> bool:
+    """Check if a module is a Python built-in module."""
+    if module_name in _builtin_modules_cache:
+        return True
+        
+    try:
+        module = importlib.import_module(module_name)
+        
+        # Built-in modules either have no __file__ attribute or their file is in the standard library
+        if not hasattr(module, '__file__'):
+            _builtin_modules_cache.add(module_name)
+            return True
+            
+        # Get the standard library path
+        stdlib_path = os.path.dirname(os.__file__)
+        
+        # Check if the module's file is in the standard library
+        is_builtin = module.__file__ and module.__file__.startswith(stdlib_path)
+        if is_builtin:
+            _builtin_modules_cache.add(module_name)
+        return is_builtin
+    except ImportError:
+        return False
+
+def get_direct_imports(file_path: str) -> Set[str]:
+    """Extract direct imports from a Python file using AST parsing."""
+    direct_imports = set()
+    
+    try:
+        with open(file_path, 'r') as f:
+            content = f.read()
+        
+        tree = ast.parse(content)
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for name in node.names:
+                    base_pkg = name.name.split('.')[0]
+                    if is_valid_package_name(base_pkg) and not is_builtin_module(base_pkg):
+                        direct_imports.add(base_pkg)
+            elif isinstance(node, ast.ImportFrom):
+                if node.module:
+                    base_pkg = node.module.split('.')[0]
+                    if is_valid_package_name(base_pkg) and not is_builtin_module(base_pkg):
+                        direct_imports.add(base_pkg)
+    except Exception as e:
+        print(f"Warning: Could not parse imports from {file_path}: {str(e)}")
+    
+    return direct_imports
+
+@lru_cache(maxsize=1024)
+def is_optional_dependency(req: str) -> bool:
+    """Check if a dependency is an optional dependency."""
+    return '[' in req or 'extra ==' in req
+
+def get_package_dependencies(package_name: str, processed: Set[str] = None) -> Set[str]:
+    """Get all dependencies (including sub-dependencies) for a given package."""
+    if processed is None:
+        processed = set()
+    
+    if package_name in processed or is_builtin_module(package_name):
+        return set()
+    
+    processed.add(package_name)
+    all_dependencies = set()
+    
+    try:
+        # Try to get the distribution
+        try:
+            dist = importlib.metadata.distribution(package_name)
+        except importlib.metadata.PackageNotFoundError:
+            print(f'Warning: Package {package_name} not found')
+            return all_dependencies
+
+        # Filter out optional dependencies
+        sub_dependencies = list(filter(lambda dep: not is_optional_dependency(dep), dist.requires or []))
+        
+        # Get direct dependencies
+        for req in sub_dependencies:                
+            base_pkg = extract_base_package_name(req)
+            
+            if base_pkg and base_pkg not in processed:
+                # Try both hyphenated and non-hyphenated versions
+                for dep_name in [base_pkg, base_pkg.replace('-', '_'), base_pkg.replace('_', '-')]:
+                    try:
+                        importlib.import_module(dep_name)
+                        all_dependencies.add(dep_name)
+                        # Recursively get sub-dependencies
+                        all_dependencies.update(get_package_dependencies(dep_name, processed))
+                        break
+                    except ImportError:
+                        continue
+            
+    except Exception as e:
+        print(f"Warning: Error processing {package_name}: {str(e)}")
+    
+    return all_dependencies
+
+def trace_imports(entry_file: str) -> List[str]:
+    """Find all imported Python packages and files starting from an entry file."""
+    entry_file = os.path.abspath(entry_file)
+    module_dir = os.path.dirname(entry_file)
+    
+    if module_dir not in sys.path:
+        sys.path.insert(0, module_dir)
+    
+    # Get direct imports from the entry file
+    direct_imports = get_direct_imports(entry_file)
+    
+    # Initialize sets to track packages
+    all_packages = set()
+    processed_packages = set()
+    
+    # Process each direct import and its dependencies
+    for package_name in direct_imports:
+        if is_valid_package_name(package_name):
+            all_packages.add(package_name)
+            # Get all dependencies including sub-dependencies
+            all_packages.update(get_package_dependencies(package_name, processed_packages))
+    
+    # Filter out built-in packages
+    non_builtin_packages = {pkg for pkg in all_packages if not is_builtin_module(pkg)}
+    
+    return sorted(list(non_builtin_packages))
+
+def main() -> None:
+    """Main entry point for the script."""
+    if len(sys.argv) != 2:
+        print("Usage: python python-builder.py <entry_file>", file=sys.stderr)
+        sys.exit(1)
+
+    entry_file = sys.argv[1]
+    try:
+        packages = trace_imports(entry_file)
+        output = {
+            'packages': packages
+        }
+        bytes_message = (json.dumps(output) + '\n').encode('utf-8')
+        os.write(NODEIPCFD, bytes_message)
+        sys.exit(0)
+    except Exception as e:
+        print(f"Error: {str(e)}", file=sys.stderr)
+        traceback.print_exc(file=sys.stderr)
+        sys.exit(3)
+
+if __name__ == "__main__":
+    main()

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;