swallowkit 0.4.0-beta.3 → 1.0.0-beta.10

package/dist/cli/commands/dev.js

@@ -34,19 +34,68 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.devCommand = void 0;
+exports.buildFunctionsStartArgs = buildFunctionsStartArgs;
+exports.buildNextDevArgs = buildNextDevArgs;
+exports.getPythonVirtualEnvPaths = getPythonVirtualEnvPaths;
+exports.buildPythonFunctionsEnv = buildPythonFunctionsEnv;
 const commander_1 = require("commander");
 const child_process_1 = require("child_process");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const cosmos_1 = require("@azure/cosmos");
 const config_1 = require("../../core/config");
+const dev_seeds_1 = require("./dev-seeds");
+const package_manager_1 = require("../../utils/package-manager");
+function buildFunctionsStartArgs(functionsPort) {
+    return ['start', '--port', functionsPort];
+}
+function buildNextDevArgs(pm, port) {
+    const baseArgs = ['next', 'dev', '--port', port, '--webpack'];
+    return pm === 'pnpm' ? ['exec', ...baseArgs] : baseArgs;
+}
+function getPythonVirtualEnvPaths(functionsDir) {
+    const venvDir = path.join(functionsDir, '.venv');
+    const binDir = process.platform === 'win32'
+        ? path.join(venvDir, 'Scripts')
+        : path.join(venvDir, 'bin');
+    const pythonExecutable = process.platform === 'win32'
+        ? path.join(binDir, 'python.exe')
+        : path.join(binDir, 'python');
+    return { venvDir, binDir, pythonExecutable };
+}
+function buildPythonFunctionsEnv(baseEnv, functionsDir) {
+    const { venvDir, binDir, pythonExecutable } = getPythonVirtualEnvPaths(functionsDir);
+    const pathKey = getPathEnvKey(baseEnv);
+    const currentPath = baseEnv[pathKey] || '';
+    return {
+        ...baseEnv,
+        [pathKey]: currentPath ? `${binDir}${path.delimiter}${currentPath}` : binDir,
+        VIRTUAL_ENV: venvDir,
+        languageWorkers__python__defaultExecutablePath: pythonExecutable,
+    };
+}
+function getPathEnvKey(env) {
+    return Object.keys(env).find((key) => key.toUpperCase() === 'PATH') || 'PATH';
+}
+function prependToPathEnv(env, entry) {
+    const pathKey = getPathEnvKey(env);
+    const currentPath = env[pathKey] || '';
+    return {
+        ...env,
+        [pathKey]: currentPath ? `${entry}${path.delimiter}${currentPath}` : entry,
+    };
+}
 /**
  * Check if Azure Functions Core Tools is installed
  */
 async function checkCoreTools() {
+    return checkCommand('func', ['--version']);
+}
+async function checkCommand(command, args = ['--version']) {
     return new Promise((resolve) => {
-        const checkProcess = (0, child_process_1.spawn)('func', ['--version'], {
-            shell: true,
+        const checkProcess = (0, child_process_1.spawn)(command, args, {
+            shell: false,
             stdio: 'pipe',
         });
         checkProcess.on('close', (code) => {
@@ -57,6 +106,131 @@ async function checkCoreTools() {
         });
     });
 }
+async function resolvePythonBootstrapCommand() {
+    const candidates = process.platform === 'win32'
+        ? [
+            { command: 'py', argsPrefix: ['-3.11'], label: 'py -3.11' },
+            { command: 'python', argsPrefix: [], label: 'python' },
+        ]
+        : [
+            { command: 'python3', argsPrefix: [], label: 'python3' },
+            { command: 'python', argsPrefix: [], label: 'python' },
+        ];
+    for (const candidate of candidates) {
+        if (await checkCommand(candidate.command, [...candidate.argsPrefix, '--version'])) {
+            return candidate;
+        }
+    }
+    throw new Error('Python 3.11 was not found. Install Python 3.11 and make sure `python`, `python3`, or `py -3.11` is available.');
+}
+async function getCommandPath(command) {
+    const locator = process.platform === 'win32' ? 'where' : 'which';
+    const result = await captureCommandOutput(locator, [command]);
+    const firstLine = result
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean);
+    return firstLine || null;
+}
+async function captureCommandOutput(command, args, cwd, env) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, {
+            cwd,
+            env,
+            shell: false,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve(stdout);
+            }
+            else {
+                reject(new Error(stderr || stdout || `${command} exited with code ${code}`));
+            }
+        });
+        child.on('error', reject);
+    });
+}
+async function resolvePythonRuntimeDetails(functionsDir, env) {
+    const { pythonExecutable } = getPythonVirtualEnvPaths(functionsDir);
+    const output = await captureCommandOutput(pythonExecutable, [
+        '-c',
+        'import platform; import sys; print(str(sys.version_info.major) + "." + str(sys.version_info.minor)); print(platform.machine())',
+    ], functionsDir, env);
+    const [version, architecture] = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    if (!version || !architecture) {
+        throw new Error('Failed to determine Python runtime details.');
+    }
+    return { version, architecture };
+}
+async function bridgePythonCoreToolsForWindowsArm64(functionsDir, env) {
+    if (process.platform !== 'win32' || process.arch !== 'arm64') {
+        return env;
+    }
+    const funcPath = await getCommandPath('func');
+    if (!funcPath) {
+        return env;
+    }
+    const { version, architecture } = await resolvePythonRuntimeDetails(functionsDir, env);
+    if (architecture.toUpperCase() !== 'AMD64') {
+        return env;
+    }
+    const coreToolsRoot = path.dirname(funcPath);
+    const armWorkerDir = path.join(coreToolsRoot, 'workers', 'python', version, 'WINDOWS', 'Arm64');
+    if (fs.existsSync(armWorkerDir)) {
+        return env;
+    }
+    const x64WorkerDir = path.join(coreToolsRoot, 'workers', 'python', version, 'WINDOWS', 'X64');
+    if (!fs.existsSync(x64WorkerDir)) {
+        return env;
+    }
+    const patchedRoot = path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'SwallowKit', 'azure-functions-core-tools-python-bridge');
+    if (!fs.existsSync(path.join(patchedRoot, 'func.exe'))) {
+        console.log('🩹 Creating a local Azure Functions Core Tools bridge for Windows Arm64 Python...');
+        fs.mkdirSync(path.dirname(patchedRoot), { recursive: true });
+        fs.cpSync(coreToolsRoot, patchedRoot, { recursive: true });
+    }
+    const patchedArmWorkerDir = path.join(patchedRoot, 'workers', 'python', version, 'WINDOWS', 'Arm64');
+    const patchedX64WorkerDir = path.join(patchedRoot, 'workers', 'python', version, 'WINDOWS', 'X64');
+    if (!fs.existsSync(patchedArmWorkerDir) && fs.existsSync(patchedX64WorkerDir)) {
+        fs.cpSync(patchedX64WorkerDir, patchedArmWorkerDir, { recursive: true });
+    }
+    console.log(`🩹 Using bridged Azure Functions Core Tools from ${patchedRoot}`);
+    return prependToPathEnv(env, patchedRoot);
+}
+async function preparePythonFunctionsEnvironment(functionsDir) {
+    const { pythonExecutable } = getPythonVirtualEnvPaths(functionsDir);
+    const hasUv = await checkCommand('uv', ['--version']);
+    if (!fs.existsSync(pythonExecutable)) {
+        if (hasUv) {
+            console.log('📦 Creating Python virtual environment with uv...');
+            await runCommand('uv', ['venv', '.venv', '--python', '3.11'], functionsDir, 'python virtual environment setup');
+        }
+        else {
+            const bootstrap = await resolvePythonBootstrapCommand();
+            console.log(`📦 Creating Python virtual environment with ${bootstrap.label}...`);
+            await runCommand(bootstrap.command, [...bootstrap.argsPrefix, '-m', 'venv', '.venv'], functionsDir, 'python virtual environment setup');
+        }
+    }
+    const pythonEnv = buildPythonFunctionsEnv(process.env, functionsDir);
+    console.log(`📦 Installing Python Azure Functions dependencies${hasUv ? ' with uv' : ''}...`);
+    if (hasUv) {
+        await runCommand('uv', ['pip', 'install', '--python', pythonExecutable, '-r', 'requirements.txt'], functionsDir, 'python dependency installation', pythonEnv);
+    }
+    else {
+        await runCommand('python', ['-m', 'pip', 'install', '--upgrade', 'pip'], functionsDir, 'python pip upgrade', pythonEnv);
+        await runCommand('python', ['-m', 'pip', 'install', '-r', 'requirements.txt'], functionsDir, 'python dependency installation', pythonEnv);
+    }
+    return bridgePythonCoreToolsForWindowsArm64(functionsDir, pythonEnv);
+}
 /**
  * Check if Cosmos DB Emulator is running by checking if port 8081 is open
  */
@@ -89,6 +263,7 @@ exports.devCommand = new commander_1.Command()
     .option('--open', 'Open browser automatically', false)
     .option('--verbose', 'Show verbose logs', false)
     .option('--no-functions', 'Skip Azure Functions startup', false)
+    .option('--seed-env <environment>', 'Replace Cosmos DB Emulator data from dev-seeds/<environment> before startup')
     .action(async (options) => {
     // SwallowKit プロジェクトディレクトリかどうかを検証
     (0, config_1.ensureSwallowKitProject)("dev");
@@ -105,14 +280,14 @@ async function initializeCosmosDB(databaseName) {
         const localSettingsPath = path.join(functionsDir, 'local.settings.json');
         if (!fs.existsSync(localSettingsPath)) {
             console.log('⚠️  local.settings.json not found. Skipping Cosmos DB initialization.');
-            return;
+            return null;
         }
         const localSettings = JSON.parse(fs.readFileSync(localSettingsPath, 'utf-8'));
         const connectionString = localSettings.Values?.CosmosDBConnection;
         const dbName = localSettings.Values?.COSMOS_DB_DATABASE_NAME || databaseName;
         if (!connectionString) {
             console.log('⚠️  CosmosDBConnection not found in local.settings.json. Skipping Cosmos DB initialization.');
-            return;
+            return null;
         }
         console.log('🗄️  Initializing Cosmos DB...');
         // Parse connection string
@@ -120,7 +295,7 @@ async function initializeCosmosDB(databaseName) {
         const keyMatch = connectionString.match(/AccountKey=([^;]+)/);
         if (!endpointMatch || !keyMatch) {
             console.log('⚠️  Invalid CosmosDB connection string format.');
-            return;
+            return null;
         }
         const endpoint = endpointMatch[1];
         const client = new cosmos_1.CosmosClient({
@@ -130,62 +305,52 @@ async function initializeCosmosDB(databaseName) {
         // Create database if not exists
         const { database } = await client.databases.createIfNotExists({ id: dbName });
         console.log(`✅ Database "${dbName}" ready`);
-        // Read lib/scaffold-config.ts to get list of models
-        const scaffoldConfigPath = path.join(process.cwd(), 'lib', 'scaffold-config.ts');
-        if (fs.existsSync(scaffoldConfigPath)) {
-            const scaffoldConfigContent = fs.readFileSync(scaffoldConfigPath, 'utf-8');
-            // Parse TypeScript file to extract models array
-            const modelsMatch = scaffoldConfigContent.match(/models:\s*\[([\s\S]*?)\]\s*as\s*ScaffoldModel\[\]/);
-            if (modelsMatch) {
-                const modelsArrayContent = modelsMatch[1];
-                // Extract model names from objects like { name: 'Task', path: '/task', label: 'Task' }
-                const modelMatches = modelsArrayContent.matchAll(/\{\s*name:\s*['"](\w+)['"]/g);
-                const models = Array.from(modelMatches, m => m[1]);
-                for (const modelName of models) {
-                    const containerName = `${modelName}s`; // Pluralize model name
-                    // Try creating container with full partition key definition first
-                    let containerCreated = false;
-                    try {
-                        console.log(`🔧 Creating container "${containerName}" with partition key /id...`);
-                        const containerResponse = await database.containers.createIfNotExists({
-                            id: containerName,
-                            partitionKey: {
-                                paths: ['/id'],
-                                kind: cosmos_1.PartitionKeyKind.Hash,
-                                version: 2
-                            }
-                        });
-                        console.log(`✅ Container "${containerName}" ready (status: ${containerResponse.statusCode})`);
-                        containerCreated = true;
-                    }
-                    catch (error) {
-                        console.log(`⚠️  Failed with full partition key definition: ${error.message}`);
-                        console.log(`🔄 Retrying with simple partition key...`);
+        const models = await (0, dev_seeds_1.loadProjectModels)();
+        for (const model of models) {
+            const containerName = (0, dev_seeds_1.getContainerNameForModel)(model);
+            // Try creating container with full partition key definition first
+            let containerCreated = false;
+            try {
+                console.log(`🔧 Creating container "${containerName}" with partition key /id...`);
+                const containerResponse = await database.containers.createIfNotExists({
+                    id: containerName,
+                    partitionKey: {
+                        paths: ['/id'],
+                        kind: cosmos_1.PartitionKeyKind.Hash,
+                        version: 2
                     }
-                    // If first attempt failed, try with simple partition key definition
-                    if (!containerCreated) {
-                        try {
-                            const containerResponse = await database.containers.createIfNotExists({
-                                id: containerName,
-                                partitionKey: {
-                                    paths: ['/id']
-                                }
-                            });
-                            console.log(`✅ Container "${containerName}" ready (status: ${containerResponse.statusCode})`);
-                        }
-                        catch (containerError) {
-                            console.error(`❌ Failed to create container "${containerName}":`, containerError.message);
-                            console.error(`Error code: ${containerError.code}`);
-                            if (containerError.body) {
-                                console.error(`Response body:`, JSON.stringify(containerError.body, null, 2));
-                            }
-                            // Continue with other containers
+                });
+                console.log(`✅ Container "${containerName}" ready (status: ${containerResponse.statusCode})`);
+                containerCreated = true;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.log(`⚠️  Failed with full partition key definition: ${message}`);
+                console.log(`🔄 Retrying with simple partition key...`);
+            }
+            // If first attempt failed, try with simple partition key definition
+            if (!containerCreated) {
+                try {
+                    const containerResponse = await database.containers.createIfNotExists({
+                        id: containerName,
+                        partitionKey: {
+                            paths: ['/id']
                         }
+                    });
+                    console.log(`✅ Container "${containerName}" ready (status: ${containerResponse.statusCode})`);
+                }
+                catch (containerError) {
+                    console.error(`❌ Failed to create container "${containerName}":`, containerError.message);
+                    console.error(`Error code: ${containerError.code}`);
+                    if (containerError.body) {
+                        console.error(`Response body:`, JSON.stringify(containerError.body, null, 2));
                     }
+                    // Continue with other containers
                 }
             }
         }
         console.log('✅ Cosmos DB initialization complete\n');
+        return { endpoint, key: keyMatch[1], databaseName: dbName, models };
     }
     catch (error) {
         console.error('⚠️  Cosmos DB initialization failed:', error.message);
@@ -193,13 +358,19 @@ async function initializeCosmosDB(databaseName) {
             console.error('Stack trace:', error.stack);
         }
         console.log('💡 Make sure Cosmos DB Emulator is running');
+        return null;
     }
 }
 async function startDevEnvironment(options) {
     const port = options.port || '3000';
     const functionsPort = options.functionsPort || '7071';
+    // Detect package manager from project lockfile
+    const pm = (0, package_manager_1.detectFromProject)();
+    const pmCmd = (0, package_manager_1.getCommands)(pm);
+    const backendLanguage = (0, config_1.getBackendLanguage)();
     // プロセスを管理する配列
     const processes = [];
+    let functionsEnv = process.env;
     // Cleanup processes on Ctrl+C
     process.on('SIGINT', () => {
         console.log('\n🛑 Stopping development servers...');
@@ -226,8 +397,7 @@ async function startDevEnvironment(options) {
         }
         // 2. Check if Azure Functions exists
         const functionsDir = path.join(process.cwd(), 'functions');
-        const hasFunctions = fs.existsSync(functionsDir) &&
-            fs.existsSync(path.join(functionsDir, 'package.json'));
+        const hasFunctions = fs.existsSync(functionsDir) && hasFunctionsProject(functionsDir, backendLanguage);
         if (hasFunctions && !options.noFunctions) {
             // Check if Azure Functions Core Tools is installed
             const coreToolsInstalled = await checkCoreTools();
@@ -248,7 +418,7 @@ async function startDevEnvironment(options) {
                 if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
                     console.log('📦 Installing Azure Functions Core Tools...');
                     console.log('   This may take a few minutes.');
-                    const installProcess = (0, child_process_1.spawn)('npm', ['install', '-g', 'azure-functions-core-tools@4'], {
+                    const installProcess = (0, child_process_1.spawn)(pm, pm === 'pnpm' ? ['add', '-g', 'azure-functions-core-tools@4'] : ['install', '-g', 'azure-functions-core-tools@4'], {
                         shell: true,
                         stdio: 'inherit',
                     });
@@ -261,7 +431,7 @@ async function startDevEnvironment(options) {
                             else {
                                 console.error('❌ Installation failed.');
                                 console.log('💡 Please install manually:');
-                                console.log('   npm install -g azure-functions-core-tools@4');
+                                console.log(`   ${pmCmd.addGlobal} azure-functions-core-tools@4`);
                                 reject(new Error(`Installation failed with code ${code}`));
                             }
                         });
@@ -272,7 +442,7 @@ async function startDevEnvironment(options) {
                     console.log('');
                     console.log('ℹ️  Skipping Azure Functions startup.');
                     console.log('💡 To install later:');
-                    console.log('   npm install -g azure-functions-core-tools@4');
+                    console.log(`   ${pmCmd.addGlobal} azure-functions-core-tools@4`);
                     console.log('');
                     // Skip Azure Functions startup
                     options.noFunctions = true;
@@ -296,29 +466,33 @@ async function startDevEnvironment(options) {
                 const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
                 const appName = packageJson.name || 'App';
                 const databaseName = `${appName.charAt(0).toUpperCase() + appName.slice(1)}Database`;
-                await initializeCosmosDB(databaseName);
+                const cosmosInitialization = await initializeCosmosDB(databaseName);
+                if (options.seedEnv && cosmosInitialization) {
+                    await (0, dev_seeds_1.applyDevSeedEnvironment)({
+                        client: new cosmos_1.CosmosClient({
+                            endpoint: cosmosInitialization.endpoint,
+                            key: cosmosInitialization.key,
+                        }),
+                        databaseName: cosmosInitialization.databaseName,
+                        environment: options.seedEnv,
+                        models: cosmosInitialization.models,
+                    });
+                }
                 console.log('');
                 console.log('🚀 Starting Azure Functions...');
-                // Check if npm install has been run in functions directory
-                const functionsNodeModules = path.join(functionsDir, 'node_modules');
-                if (!fs.existsSync(functionsNodeModules)) {
-                    console.log('📦 Installing Azure Functions dependencies...');
-                    const npmInstall = (0, child_process_1.spawn)('npm', ['install'], {
-                        cwd: functionsDir,
-                        shell: true,
-                        stdio: 'inherit',
-                    });
-                    await new Promise((resolve, reject) => {
-                        npmInstall.on('close', (code) => {
-                            if (code === 0) {
-                                resolve();
-                            }
-                            else {
-                                reject(new Error(`npm install failed with code ${code}`));
-                            }
-                        });
-                        npmInstall.on('error', reject);
-                    });
+                if (backendLanguage === 'typescript') {
+                    const functionsNodeModules = path.join(functionsDir, 'node_modules');
+                    if (!fs.existsSync(functionsNodeModules)) {
+                        console.log('📦 Installing Azure Functions dependencies...');
+                        await runCommand(pm, ['install'], functionsDir, `${pm} install`);
+                    }
+                }
+                else if (backendLanguage === 'csharp') {
+                    console.log('📦 Building C# Azure Functions project...');
+                    await runCommand('dotnet', ['build'], functionsDir, 'dotnet build');
+                }
+                else {
+                    functionsEnv = await preparePythonFunctionsEnvironment(functionsDir);
                 }
             }
         }
@@ -327,7 +501,10 @@ async function startDevEnvironment(options) {
             const sharedDir = path.join(process.cwd(), 'shared');
             if (fs.existsSync(sharedDir) && fs.existsSync(path.join(sharedDir, 'package.json'))) {
                 console.log('📦 Building shared package...');
-                const sharedBuild = (0, child_process_1.spawn)('npm', ['run', 'build', '-w', 'shared'], {
+                const filterArgs = pm === 'pnpm'
+                    ? ['run', '--filter', 'shared', 'build']
+                    : ['run', '--workspace=shared', 'build'];
+                const sharedBuild = (0, child_process_1.spawn)(pm, filterArgs, {
                     cwd: process.cwd(),
                     shell: true,
                     stdio: 'inherit',
@@ -346,13 +523,13 @@ async function startDevEnvironment(options) {
                 });
             }
             // Azure Functions を起動
-            const funcEnv = { ...process.env, FUNCTIONS_PORT: functionsPort };
-            const funcProcess = (0, child_process_1.spawn)('npm', ['start'], {
+            const funcProcess = (0, child_process_1.spawn)('func', buildFunctionsStartArgs(functionsPort), {
                 cwd: functionsDir,
                 shell: true,
                 stdio: 'pipe', // Always pipe to capture output
-                env: funcEnv
+                env: functionsEnv
             });
+            let pythonWorkerMissing = false;
             // Functions の出力をそのまま表示（プレフィックス付き）
             if (funcProcess.stdout) {
                 funcProcess.stdout.on('data', (data) => {
@@ -360,6 +537,10 @@ async function startDevEnvironment(options) {
                     // 各行にプレフィックスを付けて出力
                     const lines = output.split('\n').filter((line) => line.trim());
                     lines.forEach((line) => {
+                        if (backendLanguage === 'python' &&
+                            (line.includes('WorkerConfig for runtime: python not found') || line.includes('DefaultWorkerPath:'))) {
+                            pythonWorkerMissing = true;
+                        }
                         console.log(`[Functions] ${line}`);
                     });
                 });
@@ -369,6 +550,10 @@ async function startDevEnvironment(options) {
                     const output = data.toString();
                     const lines = output.split('\n').filter((line) => line.trim());
                     lines.forEach((line) => {
+                        if (backendLanguage === 'python' &&
+                            (line.includes('WorkerConfig for runtime: python not found') || line.includes('DefaultWorkerPath:'))) {
+                            pythonWorkerMissing = true;
+                        }
                         console.error(`[Functions Error] ${line}`);
                     });
                 });
@@ -377,11 +562,16 @@ async function startDevEnvironment(options) {
             funcProcess.on('error', (error) => {
                 console.error('⚠️  Azure Functions startup error:', error.message);
                 console.log('💡 Please ensure Azure Functions Core Tools is installed');
-                console.log('   npm install -g azure-functions-core-tools@4');
+                console.log(`   ${pmCmd.addGlobal} azure-functions-core-tools@4`);
             });
             funcProcess.on('close', (code) => {
                 if (code !== 0) {
                     console.log(`\n⏹️  Azure Functions exited (exit code: ${code})`);
+                    if (backendLanguage === 'python' && pythonWorkerMissing) {
+                        console.log('💡 Your Azure Functions Core Tools installation is missing the Python worker for this OS/architecture.');
+                        console.log('   Reinstall a matching Core Tools v4 package (Windows users should prefer the official x64/x86 MSI for their machine).');
+                        console.log('   SwallowKit local Python dev uses functions/.venv and requirements.txt, but Core Tools still needs its own bundled Python worker.');
+                    }
                 }
             });
             console.log(`✅ Azure Functions started (port: ${functionsPort})`);
@@ -397,7 +587,7 @@ async function startDevEnvironment(options) {
         console.log('');
         console.log('🚀 Starting Next.js development server...');
         // 5. Start Next.js development server
-        const nextArgs = ['next', 'dev', '--port', port];
+        const nextArgs = buildNextDevArgs(pm, port);
         if (options.open) {
             // Next.js 14+ deprecated --open option, so we open browser manually
             setTimeout(() => {
@@ -408,10 +598,16 @@ async function startDevEnvironment(options) {
                 (0, child_process_1.spawn)(start, [url], { shell: true });
             }, 3000);
         }
-        const nextProcess = (0, child_process_1.spawn)('npx', nextArgs, {
+        const nextEnv = {
+            ...process.env,
+            BACKEND_FUNCTIONS_BASE_URL: `http://${options.host || 'localhost'}:${functionsPort}`,
+            FUNCTIONS_BASE_URL: `http://${options.host || 'localhost'}:${functionsPort}`,
+        };
+        const nextProcess = (0, child_process_1.spawn)(pm === 'pnpm' ? 'pnpm' : 'npx', nextArgs, {
             cwd: process.cwd(),
             shell: true,
             stdio: options.verbose ? 'inherit' : 'inherit',
+            env: nextEnv,
         });
         processes.push(nextProcess);
         nextProcess.on('error', (error) => {
@@ -455,4 +651,29 @@ async function startDevEnvironment(options) {
         process.exit(1);
     }
 }
+async function runCommand(command, args, cwd, label, env) {
+    await new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, {
+            cwd,
+            shell: true,
+            stdio: 'inherit',
+            env,
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`${label} failed with code ${code}`));
+            }
+        });
+        child.on('error', reject);
+    });
+}
+function hasFunctionsProject(functionsDir, backendLanguage) {
+    if (backendLanguage === 'typescript') {
+        return fs.existsSync(path.join(functionsDir, 'package.json'));
+    }
+    return fs.existsSync(path.join(functionsDir, 'host.json'));
+}
 //# sourceMappingURL=dev.js.map