swallowkit 1.0.0-beta.9 → 1.0.0

package/dist/cli/commands/dev.js

@@ -35,25 +35,119 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.devCommand = void 0;
 exports.buildFunctionsStartArgs = buildFunctionsStartArgs;
+exports.parseCoreToolsVersion = parseCoreToolsVersion;
+exports.compareVersionNumbers = compareVersionNumbers;
+exports.buildFunctionsCoreToolsCommand = buildFunctionsCoreToolsCommand;
 exports.buildNextDevArgs = buildNextDevArgs;
+exports.buildFunctionsBaseUrl = buildFunctionsBaseUrl;
+exports.buildSwaStartArgs = buildSwaStartArgs;
+exports.getSwaCliInstallCommand = getSwaCliInstallCommand;
+exports.getFunctionsReadinessTimeoutMs = getFunctionsReadinessTimeoutMs;
+exports.waitForHttpServerReady = waitForHttpServerReady;
 exports.getPythonVirtualEnvPaths = getPythonVirtualEnvPaths;
+exports.getCSharpFunctionsBuildArtifactPaths = getCSharpFunctionsBuildArtifactPaths;
 exports.buildPythonFunctionsEnv = buildPythonFunctionsEnv;
+exports.buildFunctionsCosmosEnvironment = buildFunctionsCosmosEnvironment;
+exports.buildDevCommand = buildDevCommand;
 const commander_1 = require("commander");
 const child_process_1 = require("child_process");
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
+const net = __importStar(require("net"));
 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");
+const python_uv_1 = require("../../utils/python-uv");
+const connector_mock_server_1 = require("../../core/mock/connector-mock-server");
+const MINIMUM_CSHARP_CORE_TOOLS_VERSION = '4.6.0';
+const NPM_CORE_TOOLS_PACKAGE = 'azure-functions-core-tools@4';
+function normalizeParsedDevOptions(options) {
+    return {
+        ...options,
+        noFunctions: options.noFunctions ?? options.functions === false,
+        noSwa: options.noSwa ?? options.swa === false,
+    };
+}
 function buildFunctionsStartArgs(functionsPort) {
     return ['start', '--port', functionsPort];
 }
+function parseCoreToolsVersion(output) {
+    const match = output.match(/\d+\.\d+\.\d+/);
+    return match ? match[0] : null;
+}
+function compareVersionNumbers(left, right) {
+    const leftParts = left.split('.').map((value) => Number.parseInt(value, 10));
+    const rightParts = right.split('.').map((value) => Number.parseInt(value, 10));
+    const length = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftPart = leftParts[index] ?? 0;
+        const rightPart = rightParts[index] ?? 0;
+        if (leftPart !== rightPart) {
+            return leftPart - rightPart;
+        }
+    }
+    return 0;
+}
+function buildFunctionsCoreToolsCommand(backendLanguage, installedVersion) {
+    if (backendLanguage === 'csharp' &&
+        (!installedVersion || compareVersionNumbers(installedVersion, MINIMUM_CSHARP_CORE_TOOLS_VERSION) < 0)) {
+        const reason = installedVersion
+            ? `installed func ${installedVersion} is too old for C# isolated`
+            : 'func is not installed';
+        return {
+            command: 'npm',
+            argsPrefix: ['exec', '--yes', NPM_CORE_TOOLS_PACKAGE, '--'],
+            label: `npm exec ${NPM_CORE_TOOLS_PACKAGE} (${reason})`,
+        };
+    }
+    return {
+        command: 'func',
+        argsPrefix: [],
+        label: installedVersion ? `func ${installedVersion}` : 'func',
+    };
+}
 function buildNextDevArgs(pm, port) {
     const baseArgs = ['next', 'dev', '--port', port, '--webpack'];
     return pm === 'pnpm' ? ['exec', ...baseArgs] : baseArgs;
 }
+function buildFunctionsBaseUrl(host, functionsPort) {
+    return `http://${host || 'localhost'}:${functionsPort}`;
+}
+function buildSwaStartArgs(host, nextPort, swaPort) {
+    return [
+        'start',
+        `http://${host || 'localhost'}:${nextPort}`,
+        '--swa-config-location',
+        '.',
+        '--port',
+        swaPort,
+    ];
+}
+function getSwaCliInstallCommand(pm) {
+    return pm === 'pnpm'
+        ? 'pnpm add -Dw @azure/static-web-apps-cli'
+        : 'npm install -D @azure/static-web-apps-cli';
+}
+function getFunctionsReadinessTimeoutMs(backendLanguage) {
+    return backendLanguage === 'csharp' ? 90000 : 30000;
+}
+async function waitForHttpServerReady(url, timeoutMs = 30000, intervalMs = 500) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+        if (await probeHttpServer(url)) {
+            return true;
+        }
+        if (Date.now() + intervalMs > deadline) {
+            break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    return probeHttpServer(url);
+}
 function getPythonVirtualEnvPaths(functionsDir) {
     const venvDir = path.join(functionsDir, '.venv');
     const binDir = process.platform === 'win32'
@@ -64,6 +158,12 @@ function getPythonVirtualEnvPaths(functionsDir) {
         : path.join(binDir, 'python');
     return { venvDir, binDir, pythonExecutable };
 }
+function getCSharpFunctionsBuildArtifactPaths(functionsDir) {
+    return [
+        path.join(functionsDir, 'bin'),
+        path.join(functionsDir, 'obj'),
+    ];
+}
 function buildPythonFunctionsEnv(baseEnv, functionsDir) {
     const { venvDir, binDir, pythonExecutable } = getPythonVirtualEnvPaths(functionsDir);
     const pathKey = getPathEnvKey(baseEnv);
@@ -75,6 +175,12 @@ function buildPythonFunctionsEnv(baseEnv, functionsDir) {
         languageWorkers__python__defaultExecutablePath: pythonExecutable,
     };
 }
+function buildFunctionsCosmosEnvironment(baseEnv, databaseName) {
+    return {
+        ...baseEnv,
+        COSMOS_DB_DATABASE_NAME: databaseName,
+    };
+}
 function getPathEnvKey(env) {
     return Object.keys(env).find((key) => key.toUpperCase() === 'PATH') || 'PATH';
 }
@@ -92,10 +198,12 @@ function prependToPathEnv(env, entry) {
 async function checkCoreTools() {
     return checkCommand('func', ['--version']);
 }
-async function checkCommand(command, args = ['--version']) {
+async function checkCommand(command, args = ['--version'], options) {
     return new Promise((resolve) => {
         const checkProcess = (0, child_process_1.spawn)(command, args, {
-            shell: false,
+            cwd: options?.cwd,
+            env: options?.env ?? process.env,
+            shell: options?.shell ?? true,
             stdio: 'pipe',
         });
         checkProcess.on('close', (code) => {
@@ -106,22 +214,22 @@ async function checkCommand(command, args = ['--version']) {
         });
     });
 }
-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;
-        }
+async function resolveProjectLocalUvCommand(projectRoot) {
+    const uvEnv = (0, python_uv_1.buildProjectLocalUvEnv)(process.env, projectRoot);
+    const { localUvExecutable } = (0, python_uv_1.getProjectLocalUvPaths)(projectRoot);
+    if (await checkCommand('uv', ['--version'], { shell: false })) {
+        return { command: 'uv', env: uvEnv };
+    }
+    if (fs.existsSync(localUvExecutable) && await checkCommand(localUvExecutable, ['--version'], { shell: false })) {
+        return { command: localUvExecutable, env: uvEnv };
     }
-    throw new Error('Python 3.11 was not found. Install Python 3.11 and make sure `python`, `python3`, or `py -3.11` is available.');
+    console.log('📦 Installing project-local uv...');
+    const installer = (0, python_uv_1.getProjectLocalUvInstallerCommand)();
+    await runCommand(installer.command, installer.args, projectRoot, 'uv installation', (0, python_uv_1.buildProjectLocalUvInstallerEnv)(process.env, projectRoot), false);
+    if (!(fs.existsSync(localUvExecutable) && await checkCommand(localUvExecutable, ['--version'], { shell: false }))) {
+        throw new Error('Failed to install project-local uv.');
+    }
+    return { command: localUvExecutable, env: uvEnv };
 }
 async function getCommandPath(command) {
     const locator = process.platform === 'win32' ? 'where' : 'which';
@@ -132,6 +240,17 @@ async function getCommandPath(command) {
         .find(Boolean);
     return firstLine || null;
 }
+async function resolveInstalledCoreToolsVersion() {
+    if (!(await checkCoreTools())) {
+        return null;
+    }
+    try {
+        return parseCoreToolsVersion(await captureCommandOutput('func', ['--version']));
+    }
+    catch {
+        return null;
+    }
+}
 async function captureCommandOutput(command, args, cwd, env) {
     return new Promise((resolve, reject) => {
         const child = (0, child_process_1.spawn)(command, args, {
@@ -159,6 +278,35 @@ async function captureCommandOutput(command, args, cwd, env) {
         child.on('error', reject);
     });
 }
+async function probeHttpServer(url) {
+    return new Promise((resolve) => {
+        const target = new URL(url);
+        const requestFactory = target.protocol === 'https:' ? https.request : http.request;
+        let settled = false;
+        const finish = (value) => {
+            if (!settled) {
+                settled = true;
+                resolve(value);
+            }
+        };
+        const request = requestFactory({
+            hostname: target.hostname,
+            port: target.port,
+            path: target.pathname || '/',
+            method: 'GET',
+            timeout: 1000,
+        }, (response) => {
+            response.resume();
+            finish(true);
+        });
+        request.on('timeout', () => {
+            request.destroy();
+            finish(false);
+        });
+        request.on('error', () => finish(false));
+        request.end();
+    });
+}
 async function resolvePythonRuntimeDetails(functionsDir, env) {
     const { pythonExecutable } = getPythonVirtualEnvPaths(functionsDir);
     const output = await captureCommandOutput(pythonExecutable, [
@@ -207,28 +355,25 @@ async function bridgePythonCoreToolsForWindowsArm64(functionsDir, env) {
     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 projectRoot = (0, python_uv_1.getPythonProjectRoot)(functionsDir);
+    const { command: uvCommand, env: uvEnv } = await resolveProjectLocalUvCommand(projectRoot);
+    const { venvDir, pythonExecutable } = getPythonVirtualEnvPaths(functionsDir);
+    const hasUsableVirtualEnv = fs.existsSync(pythonExecutable) && await checkCommand(pythonExecutable, ['--version'], {
+        cwd: functionsDir,
+        env: uvEnv,
+        shell: false,
+    });
+    if (!hasUsableVirtualEnv) {
+        const venvArgs = (0, python_uv_1.buildUvVenvArgs)('.venv');
+        if (fs.existsSync(venvDir)) {
+            venvArgs.push('--clear');
         }
+        console.log('📦 Creating Python virtual environment with uv...');
+        await runCommand(uvCommand, venvArgs, functionsDir, 'python virtual environment setup', uvEnv, false);
     }
-    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);
-    }
+    console.log('📦 Installing Python Azure Functions dependencies with uv...');
+    await runCommand(uvCommand, (0, python_uv_1.buildUvPipInstallArgs)(pythonExecutable, 'requirements.txt'), functionsDir, 'python dependency installation', uvEnv, false);
+    const pythonEnv = buildPythonFunctionsEnv(uvEnv, functionsDir);
     return bridgePythonCoreToolsForWindowsArm64(functionsDir, pythonEnv);
 }
 /**
@@ -236,7 +381,6 @@ async function preparePythonFunctionsEnvironment(functionsDir) {
  */
 async function checkCosmosDBEmulator() {
     return new Promise((resolve) => {
-        const net = require('net');
         const socket = new net.Socket();
         const timeout = setTimeout(() => {
             socket.destroy();
@@ -254,53 +398,56 @@ async function checkCosmosDBEmulator() {
         socket.connect(8081, 'localhost');
     });
 }
-exports.devCommand = new commander_1.Command()
-    .name('dev')
-    .description('Start SwallowKit development server (Cosmos DB + Next.js + Azure Functions)')
-    .option('-p, --port <port>', 'Next.js port', '3000')
-    .option('-f, --functions-port <port>', 'Azure Functions port', '7071')
-    .option('--host <host>', 'Host name', 'localhost')
-    .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");
-    console.log('🚀 Starting SwallowKit development environment...');
-    if (options.verbose) {
-        console.log('⚙️  Options:', options);
-    }
-    await startDevEnvironment(options);
-});
+function buildDevCommand(runDevEnvironment = startDevEnvironment, verifyProject = config_1.ensureSwallowKitProject) {
+    return new commander_1.Command()
+        .name('dev')
+        .description('Start SwallowKit development server (Cosmos DB + Next.js + Azure Functions)')
+        .option('-p, --port <port>', 'Next.js port', '3000')
+        .option('-f, --functions-port <port>', 'Azure Functions port', '7071')
+        .option('--host <host>', 'Host name', 'localhost')
+        .option('--open', 'Open browser automatically', false)
+        .option('--verbose', 'Show verbose logs', false)
+        .option('--no-functions', 'Skip Azure Functions startup')
+        .option('--seed-env <environment>', 'Replace Cosmos DB Emulator data from dev-seeds/<environment> before startup')
+        .option('--mock-connectors', 'Start mock server for connector models (serves Zod-generated data)', false)
+        .option('--swa-port <port>', 'SWA authentication emulator port', '4280')
+        .option('--no-swa', 'Skip the SWA authentication emulator')
+        .action(async (options) => {
+        const normalizedOptions = normalizeParsedDevOptions(options);
+        // SwallowKit プロジェクトディレクトリかどうかを検証
+        verifyProject("dev");
+        console.log('🚀 Starting SwallowKit development environment...');
+        if (normalizedOptions.verbose) {
+            console.log('⚙️  Options:', normalizedOptions);
+        }
+        await runDevEnvironment(normalizedOptions);
+    });
+}
+exports.devCommand = buildDevCommand();
 async function initializeCosmosDB(databaseName) {
     try {
-        // Read local.settings.json from functions directory
-        const functionsDir = path.join(process.cwd(), 'functions');
-        const localSettingsPath = path.join(functionsDir, 'local.settings.json');
-        if (!fs.existsSync(localSettingsPath)) {
-            console.log('⚠️  local.settings.json not found. Skipping Cosmos DB initialization.');
-            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.');
+        const connectionInfoResult = (0, dev_seeds_1.resolveLocalCosmosConnectionInfo)(databaseName);
+        if (!connectionInfoResult.ok) {
+            if (connectionInfoResult.reason === 'missing-local-settings') {
+                console.log('⚠️  local.settings.json not found. Skipping Cosmos DB initialization.');
+            }
+            else if (connectionInfoResult.reason === 'missing-connection-string') {
+                console.log('⚠️  CosmosDBConnection not found in local.settings.json. Skipping Cosmos DB initialization.');
+            }
+            else {
+                console.log('⚠️  Invalid CosmosDB connection string format.');
+            }
             return null;
         }
         console.log('🗄️  Initializing Cosmos DB...');
-        // Parse connection string
-        const endpointMatch = connectionString.match(/AccountEndpoint=([^;]+)/);
-        const keyMatch = connectionString.match(/AccountKey=([^;]+)/);
-        if (!endpointMatch || !keyMatch) {
-            console.log('⚠️  Invalid CosmosDB connection string format.');
-            return null;
+        const { endpoint, key, databaseName: dbName, worktreeIsolationEnabled } = connectionInfoResult.value;
+        console.log(`📦 Cosmos DB database: ${dbName}`);
+        if (worktreeIsolationEnabled) {
+            console.log('🌳 Worktree isolation: enabled');
         }
-        const endpoint = endpointMatch[1];
         const client = new cosmos_1.CosmosClient({
             endpoint: endpoint,
-            key: keyMatch[1]
+            key,
         });
         // Create database if not exists
         const { database } = await client.databases.createIfNotExists({ id: dbName });
@@ -311,11 +458,11 @@ async function initializeCosmosDB(databaseName) {
             // Try creating container with full partition key definition first
             let containerCreated = false;
             try {
-                console.log(`🔧 Creating container "${containerName}" with partition key /id...`);
+                console.log(`🔧 Creating container "${containerName}" with partition key ${model.partitionKey}...`);
                 const containerResponse = await database.containers.createIfNotExists({
                     id: containerName,
                     partitionKey: {
-                        paths: ['/id'],
+                        paths: [model.partitionKey],
                         kind: cosmos_1.PartitionKeyKind.Hash,
                         version: 2
                     }
@@ -334,7 +481,7 @@ async function initializeCosmosDB(databaseName) {
                     const containerResponse = await database.containers.createIfNotExists({
                         id: containerName,
                         partitionKey: {
-                            paths: ['/id']
+                            paths: [model.partitionKey]
                         }
                     });
                     console.log(`✅ Container "${containerName}" ready (status: ${containerResponse.statusCode})`);
@@ -350,7 +497,7 @@ async function initializeCosmosDB(databaseName) {
             }
         }
         console.log('✅ Cosmos DB initialization complete\n');
-        return { endpoint, key: keyMatch[1], databaseName: dbName, models };
+        return { endpoint, key, databaseName: dbName, models };
     }
     catch (error) {
         console.error('⚠️  Cosmos DB initialization failed:', error.message);
@@ -364,16 +511,52 @@ async function initializeCosmosDB(databaseName) {
 async function startDevEnvironment(options) {
     const port = options.port || '3000';
     const functionsPort = options.functionsPort || '7071';
+    const swaPort = options.swaPort || '4280';
     // 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 authConfig = (0, config_1.getAuthConfig)();
+    const normalizedAuth = (0, config_1.normalizeAuthConfig)(authConfig);
+    const useSwaEmulator = Boolean(normalizedAuth && Object.values(normalizedAuth.schemes).some(scheme => scheme.provider === 'swa')) && !options.noSwa;
+    const swaCommand = useSwaEmulator ? await resolveSwaCliCommand(process.cwd()) : null;
+    if (useSwaEmulator && !swaCommand) {
+        const installCommand = getSwaCliInstallCommand(pm);
+        console.error('❌ SWA authentication requires Azure Static Web Apps CLI for local development.');
+        console.error('   Install it in this project and retry:');
+        console.error(`\n   ${installCommand}\n`);
+        process.exitCode = 1;
+        return;
+    }
     // プロセスを管理する配列
     const processes = [];
     let functionsEnv = process.env;
+    let mockServer = null;
+    let envLocalPath = '';
+    let envLocalDefaultUrl = ''; // default Functions URL to restore on shutdown
+    const functionsBaseUrl = buildFunctionsBaseUrl(options.host, functionsPort);
+    let functionsReadinessPromise = null;
+    let functionsReady = !!options.noFunctions;
     // Cleanup processes on Ctrl+C
-    process.on('SIGINT', () => {
+    process.on('SIGINT', async () => {
         console.log('\n🛑 Stopping development servers...');
+        // Restore .env.local to default Functions port on shutdown
+        if (envLocalPath && envLocalDefaultUrl) {
+            try {
+                if (fs.existsSync(envLocalPath)) {
+                    const content = fs.readFileSync(envLocalPath, 'utf-8');
+                    if (content.includes('BACKEND_FUNCTIONS_BASE_URL=') &&
+                        !content.includes(`BACKEND_FUNCTIONS_BASE_URL=${envLocalDefaultUrl}`)) {
+                        const restored = content.replace(/^BACKEND_FUNCTIONS_BASE_URL=.*/m, `BACKEND_FUNCTIONS_BASE_URL=${envLocalDefaultUrl}`);
+                        fs.writeFileSync(envLocalPath, restored, 'utf-8');
+                    }
+                }
+            }
+            catch { /* ignore */ }
+        }
+        if (mockServer) {
+            await mockServer.stop();
+        }
         processes.forEach((proc) => {
             if (proc && !proc.killed) {
                 proc.kill();
@@ -398,10 +581,12 @@ async function startDevEnvironment(options) {
         // 2. Check if Azure Functions exists
         const functionsDir = path.join(process.cwd(), 'functions');
         const hasFunctions = fs.existsSync(functionsDir) && hasFunctionsProject(functionsDir, backendLanguage);
+        let functionsCoreToolsCommand = null;
+        let installedCoreToolsVersion = null;
         if (hasFunctions && !options.noFunctions) {
-            // Check if Azure Functions Core Tools is installed
-            const coreToolsInstalled = await checkCoreTools();
-            if (!coreToolsInstalled) {
+            installedCoreToolsVersion = await resolveInstalledCoreToolsVersion();
+            functionsCoreToolsCommand = buildFunctionsCoreToolsCommand(backendLanguage, installedCoreToolsVersion);
+            if (functionsCoreToolsCommand.command === 'func' && !installedCoreToolsVersion) {
                 console.log('');
                 console.log('⚠️  Azure Functions Core Tools not found.');
                 console.log('');
@@ -448,6 +633,9 @@ async function startDevEnvironment(options) {
                     options.noFunctions = true;
                 }
             }
+            else if (functionsCoreToolsCommand.command !== 'func') {
+                console.log(`ℹ️  Using ${functionsCoreToolsCommand.label}.`);
+            }
             if (!options.noFunctions) {
                 // Check if Cosmos DB Emulator is running
                 const cosmosRunning = await checkCosmosDBEmulator();
@@ -463,9 +651,7 @@ async function startDevEnvironment(options) {
                     process.exit(1);
                 }
                 // Initialize Cosmos DB before starting Functions
-                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-                const appName = packageJson.name || 'App';
-                const databaseName = `${appName.charAt(0).toUpperCase() + appName.slice(1)}Database`;
+                const databaseName = (0, dev_seeds_1.getDefaultCosmosDatabaseName)();
                 const cosmosInitialization = await initializeCosmosDB(databaseName);
                 if (options.seedEnv && cosmosInitialization) {
                     await (0, dev_seeds_1.applyDevSeedEnvironment)({
@@ -488,42 +674,63 @@ async function startDevEnvironment(options) {
                     }
                 }
                 else if (backendLanguage === 'csharp') {
-                    console.log('📦 Building C# Azure Functions project...');
-                    await runCommand('dotnet', ['build'], functionsDir, 'dotnet build');
+                    console.log('ℹ️  C# Azure Functions can take longer on cold start while the worker builds.');
                 }
                 else {
                     functionsEnv = await preparePythonFunctionsEnvironment(functionsDir);
                 }
+                if (cosmosInitialization) {
+                    functionsEnv = buildFunctionsCosmosEnvironment(functionsEnv, cosmosInitialization.databaseName);
+                }
             }
         }
         if (hasFunctions && !options.noFunctions) {
             // Build shared package before starting Functions
             const sharedDir = path.join(process.cwd(), 'shared');
-            if (fs.existsSync(sharedDir) && fs.existsSync(path.join(sharedDir, 'package.json'))) {
-                console.log('📦 Building shared package...');
-                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',
-                });
-                await new Promise((resolve, reject) => {
-                    sharedBuild.on('close', (code) => {
-                        if (code === 0) {
-                            console.log('✅ Shared package built successfully');
-                            resolve();
-                        }
-                        else {
-                            reject(new Error(`Shared package build failed with code ${code}`));
-                        }
+            const sharedPkgPath = path.join(sharedDir, 'package.json');
+            if (fs.existsSync(sharedDir) && fs.existsSync(sharedPkgPath)) {
+                const sharedPkg = JSON.parse(fs.readFileSync(sharedPkgPath, 'utf-8'));
+                if (sharedPkg.scripts?.build) {
+                    console.log('📦 Building shared package...');
+                    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',
                     });
-                    sharedBuild.on('error', reject);
-                });
+                    await new Promise((resolve, reject) => {
+                        sharedBuild.on('close', (code) => {
+                            if (code === 0) {
+                                console.log('✅ Shared package built successfully');
+                                resolve();
+                            }
+                            else {
+                                reject(new Error(`Shared package build failed with code ${code}`));
+                            }
+                        });
+                        sharedBuild.on('error', reject);
+                    });
+                }
+                else {
+                    console.log('⚠️  Shared package has no build script — skipping build. Run "swallowkit add-auth" to fix.');
+                }
+            }
+            // Build TypeScript functions after shared package (functions import from shared)
+            if (backendLanguage === 'typescript') {
+                const functionsPkgPath = path.join(functionsDir, 'package.json');
+                if (fs.existsSync(functionsPkgPath)) {
+                    const functionsPkg = JSON.parse(fs.readFileSync(functionsPkgPath, 'utf-8'));
+                    if (functionsPkg.scripts?.build) {
+                        console.log('📦 Building TypeScript Azure Functions...');
+                        await runCommand(pm, ['run', 'build'], functionsDir, `${pm} run build`);
+                    }
+                }
             }
             // Azure Functions を起動
-            const funcProcess = (0, child_process_1.spawn)('func', buildFunctionsStartArgs(functionsPort), {
+            const functionsCommand = functionsCoreToolsCommand ?? buildFunctionsCoreToolsCommand(backendLanguage, installedCoreToolsVersion);
+            const funcProcess = (0, child_process_1.spawn)(functionsCommand.command, [...functionsCommand.argsPrefix, ...buildFunctionsStartArgs(functionsPort)], {
                 cwd: functionsDir,
                 shell: true,
                 stdio: 'pipe', // Always pipe to capture output
@@ -574,7 +781,8 @@ async function startDevEnvironment(options) {
                     }
                 }
             });
-            console.log(`✅ Azure Functions started (port: ${functionsPort})`);
+            console.log(`⏳ Waiting for Azure Functions to accept requests at ${functionsBaseUrl}...`);
+            functionsReadinessPromise = waitForHttpServerReady(functionsBaseUrl, getFunctionsReadinessTimeoutMs(backendLanguage));
         }
         else if (!hasFunctions) {
             console.log('');
@@ -586,22 +794,91 @@ async function startDevEnvironment(options) {
         }
         console.log('');
         console.log('🚀 Starting Next.js development server...');
+        // Mock connector server — start proxy if --mock-connectors is enabled
+        let bffTargetPort = functionsPort;
+        if (options.mockConnectors) {
+            const allModels = await (0, dev_seeds_1.loadProjectModels)();
+            const connectorModels = allModels.filter((m) => m.connectorConfig);
+            // Resolve auth config — auth functions use RDB connectors, mocked alongside other models
+            let mockAuthConfig;
+            if (authConfig?.provider === 'custom-jwt' && authConfig.customJwt) {
+                // Read JWT_SECRET from functions/local.settings.json if available
+                let jwtSecret = 'dev-jwt-secret-change-in-production-min-32-chars!!';
+                try {
+                    const localSettingsPath = path.join(process.cwd(), 'functions', 'local.settings.json');
+                    if (fs.existsSync(localSettingsPath)) {
+                        const localSettings = JSON.parse(fs.readFileSync(localSettingsPath, 'utf-8'));
+                        jwtSecret = localSettings.Values?.[authConfig.customJwt.jwtSecretEnv || 'JWT_SECRET'] || jwtSecret;
+                    }
+                }
+                catch { /* ignore */ }
+                mockAuthConfig = {
+                    jwtSecret,
+                    tokenExpiry: authConfig.customJwt.tokenExpiry,
+                    customJwt: {
+                        userTable: authConfig.customJwt.userTable,
+                        loginIdColumn: authConfig.customJwt.loginIdColumn,
+                        passwordHashColumn: authConfig.customJwt.passwordHashColumn,
+                        rolesColumn: authConfig.customJwt.rolesColumn,
+                    },
+                    defaultPolicy: authConfig.authorization?.defaultPolicy === "public" ? "anonymous" :
+                        authConfig.authorization?.defaultPolicy === "authenticated" || authConfig.authorization?.defaultPolicy === "anonymous"
+                            ? authConfig.authorization.defaultPolicy : undefined,
+                };
+            }
+            if (connectorModels.length > 0 || mockAuthConfig) {
+                const mockPort = parseInt(functionsPort, 10) + 1;
+                mockServer = new connector_mock_server_1.ConnectorMockServer({
+                    port: mockPort,
+                    functionsTarget: `${options.host || 'localhost'}:${functionsPort}`,
+                    connectorModels,
+                    allModels,
+                    seedEnv: options.seedEnv,
+                    host: options.host || 'localhost',
+                    authConfig: mockAuthConfig,
+                });
+                await mockServer.start();
+                bffTargetPort = String(mockPort);
+                const modelCount = connectorModels.length + (mockAuthConfig ? 1 : 0);
+                console.log('');
+                console.log(`🔌 Mock server started (port: ${mockPort}) — ${modelCount} model(s) mocked via Zod/seed data`);
+                for (const m of connectorModels) {
+                    const ops = m.connectorConfig.operations.join(', ');
+                    console.log(`     - ${m.name} [${ops}]`);
+                }
+                if (mockAuthConfig) {
+                    console.log(`     - auth [login, me, logout]`);
+                }
+                console.log(`   Other routes → proxied to Azure Functions (port: ${functionsPort})`);
+            }
+            else {
+                console.log('');
+                console.log('ℹ️  --mock-connectors specified but no connector models found. Skipping mock server.');
+            }
+        }
         // 5. Start Next.js development server
         const nextArgs = buildNextDevArgs(pm, port);
-        if (options.open) {
-            // Next.js 14+ deprecated --open option, so we open browser manually
-            setTimeout(() => {
-                const url = `http://${options.host || 'localhost'}:${port}`;
-                console.log(`\n🌐 Opening browser: ${url}`);
-                const start = process.platform === 'darwin' ? 'open' :
-                    process.platform === 'win32' ? 'start' : 'xdg-open';
-                (0, child_process_1.spawn)(start, [url], { shell: true });
-            }, 3000);
+        // Ensure .env.local points to bffTargetPort so Next.js reads the correct backend URL.
+        // When --mock-connectors is active, bffTargetPort = mock port (7072); otherwise = Functions port (7071).
+        // Next.js may load .env.local values that override spawn env vars, so we must keep them in sync.
+        envLocalPath = path.join(process.cwd(), '.env.local');
+        envLocalDefaultUrl = functionsBaseUrl;
+        const bffTargetUrl = buildFunctionsBaseUrl(options.host, bffTargetPort);
+        try {
+            if (fs.existsSync(envLocalPath)) {
+                const envContent = fs.readFileSync(envLocalPath, 'utf-8');
+                if (envContent.includes('BACKEND_FUNCTIONS_BASE_URL=') &&
+                    !envContent.includes(`BACKEND_FUNCTIONS_BASE_URL=${bffTargetUrl}`)) {
+                    const updated = envContent.replace(/^BACKEND_FUNCTIONS_BASE_URL=.*/m, `BACKEND_FUNCTIONS_BASE_URL=${bffTargetUrl}`);
+                    fs.writeFileSync(envLocalPath, updated, 'utf-8');
+                }
+            }
         }
+        catch { /* ignore */ }
         const nextEnv = {
             ...process.env,
-            BACKEND_FUNCTIONS_BASE_URL: `http://${options.host || 'localhost'}:${functionsPort}`,
-            FUNCTIONS_BASE_URL: `http://${options.host || 'localhost'}:${functionsPort}`,
+            BACKEND_FUNCTIONS_BASE_URL: bffTargetUrl,
+            FUNCTIONS_BASE_URL: bffTargetUrl,
         };
         const nextProcess = (0, child_process_1.spawn)(pm === 'pnpm' ? 'pnpm' : 'npx', nextArgs, {
             cwd: process.cwd(),
@@ -619,6 +896,9 @@ async function startDevEnvironment(options) {
                 console.log(`\n⏹️  Next.js exited (exit code: ${code})`);
             }
             // Exit all processes when Next.js exits
+            if (mockServer) {
+                mockServer.stop().catch(() => { });
+            }
             processes.forEach((proc) => {
                 if (proc && !proc.killed) {
                     proc.kill();
@@ -626,18 +906,90 @@ async function startDevEnvironment(options) {
             });
             process.exit(code || 0);
         });
+        if (functionsReadinessPromise) {
+            functionsReady = await functionsReadinessPromise;
+            console.log('');
+            if (functionsReady) {
+                console.log(`✅ Azure Functions ready (port: ${functionsPort})`);
+            }
+            else {
+                console.log(`⚠️  Azure Functions is still starting: ${functionsBaseUrl}`);
+            }
+        }
+        let swaReady = false;
+        if (useSwaEmulator && swaCommand) {
+            const nextUrl = `http://${options.host || 'localhost'}:${port}`;
+            console.log(`⏳ Waiting for Next.js before starting the SWA emulator at ${nextUrl}...`);
+            const nextReady = await waitForHttpServerReady(nextUrl);
+            if (!nextReady) {
+                throw new Error(`Next.js did not become ready at ${nextUrl}`);
+            }
+            console.log(`🔐 Starting SWA authentication emulator (port: ${swaPort})...`);
+            const swaProcess = (0, child_process_1.spawn)(swaCommand, buildSwaStartArgs(options.host, port, swaPort), {
+                cwd: process.cwd(),
+                shell: true,
+                stdio: 'inherit',
+                env: process.env,
+            });
+            processes.push(swaProcess);
+            swaProcess.on('error', (error) => {
+                console.error('❌ SWA CLI startup error:', error.message);
+            });
+            const swaUrl = `http://${options.host || 'localhost'}:${swaPort}`;
+            swaReady = await waitForHttpServerReady(swaUrl);
+            if (!swaReady) {
+                throw new Error(`SWA authentication emulator did not become ready at ${swaUrl}`);
+            }
+        }
         console.log('');
         console.log('✅ SwallowKit development environment is running!');
         console.log('');
-        console.log(`📱 Next.js: http://${options.host || 'localhost'}:${port}`);
+        if (useSwaEmulator) {
+            const swaUrl = `http://${options.host || 'localhost'}:${swaPort}`;
+            console.log('🔐 SWA authenticated app:');
+            console.log(`   ${swaUrl}`);
+            console.log('');
+            console.log('🔑 Local sign-in:');
+            console.log(`   ${swaUrl}/.auth/login/aad`);
+            console.log('   Enter any username and select Login.');
+            console.log('   The "authenticated" role is added automatically.');
+            console.log('');
+            console.log('📱 Next.js direct access (authentication is not emulated):');
+            console.log(`   http://${options.host || 'localhost'}:${port}`);
+        }
+        else {
+            console.log(`📱 Next.js: http://${options.host || 'localhost'}:${port}`);
+        }
         if (hasFunctions && !options.noFunctions) {
-            console.log(`⚡ Azure Functions: http://${options.host || 'localhost'}:${functionsPort}`);
+            console.log(`${functionsReady ? '⚡ Azure Functions' : '⏳ Azure Functions (starting)'}: ${functionsBaseUrl}`);
+        }
+        if (mockServer) {
+            console.log(`🔌 Mock Proxy: ${bffTargetUrl} (BFF → here)`);
         }
         console.log('');
-        if (hasFunctions && !options.noFunctions) {
+        if (hasFunctions && !options.noFunctions && functionsReady) {
             console.log('💡 Azure Functions and Next.js BFF are connected');
         }
+        else if (hasFunctions && !options.noFunctions) {
+            console.log('💡 Azure Functions is still warming up; BFF routes can fail until the backend responds.');
+        }
+        if (mockServer) {
+            console.log('💡 Connector models served from mock server (Zod-generated data)');
+        }
+        if (swaReady) {
+            console.log('💡 Open the app through the SWA port when testing authenticated pages and CRUD APIs.');
+        }
         console.log('');
+        if (options.open) {
+            const url = useSwaEmulator
+                ? `http://${options.host || 'localhost'}:${swaPort}`
+                : `http://${options.host || 'localhost'}:${port}`;
+            console.log(`🌐 Opening browser: ${url}`);
+            const start = process.platform === 'darwin' ? 'open' :
+                process.platform === 'win32' ? 'start' : 'xdg-open';
+            (0, child_process_1.spawn)(start, [url], { shell: true });
+            console.log('');
+        }
         console.log('🛑 Press Ctrl+C to stop');
         console.log('');
     }
@@ -651,11 +1003,25 @@ async function startDevEnvironment(options) {
         process.exit(1);
     }
 }
-async function runCommand(command, args, cwd, label, env) {
+async function resolveSwaCliCommand(projectRoot) {
+    const binaryName = process.platform === 'win32' ? 'swa.cmd' : 'swa';
+    const localCommand = path.join(projectRoot, 'node_modules', '.bin', binaryName);
+    if (fs.existsSync(localCommand) && await checkCommand(localCommand, ['--version'], {
+        cwd: projectRoot,
+        shell: process.platform === 'win32',
+    })) {
+        return localCommand;
+    }
+    if (await checkCommand('swa', ['--version'], { cwd: projectRoot })) {
+        return 'swa';
+    }
+    return null;
+}
+async function runCommand(command, args, cwd, label, env, shell = true) {
     await new Promise((resolve, reject) => {
         const child = (0, child_process_1.spawn)(command, args, {
             cwd,
-            shell: true,
+            shell,
             stdio: 'inherit',
             env,
         });