firebase-tools 15.9.2-ct-studioexport3.0 → 15.10.1

package/lib/firebase_studio/migrate.js

@@ -15,6 +15,66 @@ const track = require("../track");
 const secrets_1 = require("../apphosting/secrets");
 const env = require("../functions/env");
 const error_1 = require("../error");
+const os = require("os");
+async function setupAntigravityMcpServer(rootPath, appType) {
+    const mcpConfigDir = path.join(os.homedir(), ".gemini", "antigravity");
+    const mcpConfigPath = path.join(mcpConfigDir, "mcp_config.json");
+    let mcpConfig = { mcpServers: {} };
+    try {
+        await fs.mkdir(mcpConfigDir, { recursive: true });
+        const content = await fs
+            .readFile(mcpConfigPath, "utf-8")
+            .catch((err) => {
+            if (err.code === "ENOENT") {
+                return null;
+            }
+            throw err;
+        });
+        if (content) {
+            mcpConfig = JSON.parse(content);
+            if (!mcpConfig.mcpServers) {
+                mcpConfig.mcpServers = {};
+            }
+        }
+        let updated = false;
+        if (!mcpConfig.mcpServers["firebase"]) {
+            mcpConfig.mcpServers["firebase"] = {
+                command: "npx",
+                args: ["-y", "firebase-tools@latest", "mcp", "--dir", path.resolve(rootPath)],
+            };
+            updated = true;
+            logger_1.logger.info(`✅ Configured Firebase MCP server in ${mcpConfigPath}`);
+        }
+        else {
+            logger_1.logger.info("ℹ️ Firebase MCP server already configured in Antigravity, skipping.");
+        }
+        if (appType === "FLUTTER") {
+            if (utils.commandExistsSync("dart")) {
+                if (!mcpConfig.mcpServers["dart"]) {
+                    mcpConfig.mcpServers["dart"] = {
+                        command: "dart",
+                        args: ["mcp-server"],
+                    };
+                    updated = true;
+                    logger_1.logger.info(`✅ Configured Dart MCP server in ${mcpConfigPath}`);
+                }
+                else {
+                    logger_1.logger.info("ℹ️ Dart MCP server already configured in Antigravity, skipping.");
+                }
+            }
+            else {
+                utils.logWarning("Couldn't find Dart/Flutter on PATH. Install Flutter by following the instruction at https://docs.flutter.dev/install.");
+            }
+        }
+        if (updated) {
+            await fs.writeFile(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        utils.logWarning(`Could not configure Antigravity MCP server: ${message}`);
+    }
+}
 async function detectAppType(rootPath) {
     try {
         await fs.access(path.join(rootPath, "pubspec.yaml"));
@@ -52,36 +112,23 @@ async function detectAppType(rootPath) {
     }
     return "OTHER";
 }
-async function downloadGitHubDir(apiUrl, localPath) {
-    const response = await fetch(apiUrl);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch directory listing: ${apiUrl}`);
-    }
-    const items = (await response.json());
-    await fs.mkdir(localPath, { recursive: true });
-    for (const item of items) {
-        const itemLocalPath = path.join(localPath, item.name);
-        if (item.type === "dir") {
-            await downloadGitHubDir(item.url, itemLocalPath);
-        }
-        else if (item.type === "file") {
-            const fileResponse = await fetch(item.download_url);
-            if (fileResponse.ok) {
-                const content = await fileResponse.arrayBuffer();
-                await fs.writeFile(itemLocalPath, Buffer.from(content));
-            }
-        }
-    }
-}
+const isValidFirebaseProjectId = (projectId) => {
+    const projectIdRegex = /^[a-z][a-z0-9-]{4,28}[a-z0-9]$/;
+    return projectIdRegex.test(projectId);
+};
 async function extractMetadata(rootPath, overrideProjectId) {
+    const studioJsonPath = path.join(rootPath, "studio.json");
     const metadataPath = path.join(rootPath, "metadata.json");
     let metadata = {};
-    try {
-        const metadataContent = await fs.readFile(metadataPath, "utf8");
-        metadata = JSON.parse(metadataContent);
-    }
-    catch (err) {
-        logger_1.logger.debug(`Could not read metadata.json at ${metadataPath}: ${err}`);
+    for (const metadataFile of [metadataPath, studioJsonPath]) {
+        try {
+            const metadataContent = await fs.readFile(metadataFile, "utf8");
+            metadata = JSON.parse(metadataContent);
+            logger_1.logger.info(`✅ Read ${metadataFile}`);
+        }
+        catch (err) {
+            logger_1.logger.debug(`Could not read metadata at ${metadataFile}: ${err}`);
+        }
     }
     logger_1.logger.debug(`overrideProjectId ${overrideProjectId}`);
     logger_1.logger.debug(`metadata.projectId ${metadata.projectId}`);
@@ -97,17 +144,21 @@ async function extractMetadata(rootPath, overrideProjectId) {
         }
     }
     if (projectId) {
-        logger_1.logger.info(`✅ Detected Firebase Project: ${projectId}`);
+        if (!isValidFirebaseProjectId(projectId)) {
+            throw new error_1.FirebaseError(`Invalid project ID: ${projectId}.`, {
+                exit: 1,
+            });
+        }
+        logger_1.logger.info(`✅ Using Firebase Project: ${projectId}`);
     }
     else {
-        logger_1.logger.info(`❌ Failed to determine the Firebase Project ID. You can set a project later with 'firebase use <project-id>' or by setting the '--project' flag.`);
+        logger_1.logger.debug(`❌ Failed to determine the Firebase Project ID. You can set a project later by setting the '--project' flag.`);
     }
     let appName = "firebase-studio-export";
-    let blueprintContent = "";
     const blueprintPath = path.join(rootPath, "docs", "blueprint.md");
     try {
-        blueprintContent = await fs.readFile(blueprintPath, "utf8");
-        const nameMatch = blueprintContent.match(/# \*\*App Name\*\*: (.*)/);
+        const content = await fs.readFile(blueprintPath, "utf8");
+        const nameMatch = content.match(/# \*\*App Name\*\*: (.*)/);
         if (nameMatch && nameMatch[1]) {
             appName = nameMatch[1].trim();
         }
@@ -118,72 +169,75 @@ async function extractMetadata(rootPath, overrideProjectId) {
     if (appName !== "firebase-studio-export") {
         logger_1.logger.info(`✅ Detected App Name: ${appName}`);
     }
-    return { projectId, appName, blueprintContent };
+    return { projectId, appName };
 }
-async function updateReadme(rootPath, blueprintContent, appName) {
+async function updateReadme(rootPath, framework) {
     const readmePath = path.join(rootPath, "README.md");
     const readmeTemplate = await (0, templates_1.readTemplate)("firebase-studio-export/readme_template.md");
-    const newReadme = readmeTemplate
-        .replace(/\${appName}/g, appName)
+    const frameworkConfigs = {
+        NEXT_JS: { startCommand: "npm run dev", localUrl: "http://localhost:9002" },
+        ANGULAR: { startCommand: "npm run start", localUrl: "http://localhost:4200" },
+        FLUTTER: {
+            startCommand: "flutter run -d chrome --web-port=8080",
+            localUrl: "http://localhost:8080",
+        },
+        OTHER: { startCommand: "npm run dev", localUrl: "http://localhost:9002" },
+    };
+    const { startCommand, localUrl } = frameworkConfigs[framework];
+    let existingReadme = "";
+    try {
+        existingReadme = await fs.readFile(readmePath, "utf8");
+    }
+    catch (err) {
+    }
+    let newReadme = readmeTemplate
         .replace("${exportDate}", new Date().toISOString().split("T")[0])
-        .replace("${blueprintContent}", blueprintContent.replace(/# \*\*App Name\*\*: .*/, "").trim());
+        .replace("${startCommand}", startCommand)
+        .replace("${localUrl}", localUrl);
+    if (existingReadme.trim()) {
+        newReadme += `\n\n---\n\n## Previous README.md contents:\n\n${existingReadme}`;
+    }
     await fs.writeFile(readmePath, newReadme);
     logger_1.logger.info("✅ Updated README.md with project details and origin info");
 }
-async function injectAgyContext(rootPath, projectId, appName) {
-    const agentDir = path.join(rootPath, ".agent");
+async function injectAntigravityContext(rootPath, projectId, appName) {
+    const agentDir = path.join(rootPath, ".agents");
     const rulesDir = path.join(agentDir, "rules");
     const workflowsDir = path.join(agentDir, "workflows");
     const skillsDir = path.join(agentDir, "skills");
     await fs.mkdir(rulesDir, { recursive: true });
     await fs.mkdir(workflowsDir, { recursive: true });
     await fs.mkdir(skillsDir, { recursive: true });
-    logger_1.logger.info("⏳ Fetching AGY skills from firebase/agent-skills...");
+    logger_1.logger.info("⏳ Adding Antigravity skills...");
     try {
-        const skillsResponse = await fetch("https://api.github.com/repos/firebase/agent-skills/contents/skills");
-        if (!skillsResponse.ok) {
-            throw new Error(`GitHub API returned ${skillsResponse.status}`);
-        }
-        const skillsData = (await skillsResponse.json());
-        if (Array.isArray(skillsData)) {
-            for (const item of skillsData) {
-                if (item.type === "dir") {
-                    const skillName = item.name;
-                    const skillDir = path.join(skillsDir, skillName);
-                    await downloadGitHubDir(item.url, skillDir);
-                }
-            }
+        const result = (0, child_process_1.spawnSync)("npx", ["-y", "skills", "add", "firebase/agent-skills", "-a", "antigravity", "--skill", "*", "-y"], {
+            cwd: rootPath,
+            stdio: "ignore",
+            shell: process.platform === "win32",
+        });
+        if (result.error) {
+            throw result.error;
         }
-        else {
-            utils.logWarning("GitHub API response for skills is not an array.");
+        if (result.status !== 0) {
+            throw new Error(`npx skills add exited with code ${result.status}`);
         }
-        logger_1.logger.info(`✅ Downloaded Firebase skills`);
-    }
-    catch (err) {
-        utils.logWarning(`Could not download AGY skills, skipping. ${err}`);
-    }
-    logger_1.logger.info("⏳ Fetching Genkit skill...");
-    try {
-        const genkitSkillDir = path.join(skillsDir, "developing-genkit-js");
-        await downloadGitHubDir("https://api.github.com/repos/genkit-ai/skills/contents/skills/developing-genkit-js?ref=main", genkitSkillDir);
-        logger_1.logger.info(`✅ Downloaded Genkit skill`);
+        logger_1.logger.info(`✅ Added Antigravity skills`);
     }
     catch (err) {
-        utils.logWarning(`Could not download Genkit skill, skipping. ${err}`);
+        utils.logWarning(`Could not add Antigravity skills, skipping. ${err}`);
     }
     const systemInstructionsTemplate = await (0, templates_1.readTemplate)("firebase-studio-export/system_instructions_template.md");
-    const systemInstructions = systemInstructionsTemplate
-        .replace("${projectId}", projectId || "None")
-        .replace("${appName}", appName);
+    const systemInstructions = systemInstructionsTemplate.replace("${appName}", appName);
     await fs.writeFile(path.join(rulesDir, "migration-context.md"), systemInstructions);
-    logger_1.logger.info("✅ Injected AGY rules");
+    logger_1.logger.info("✅ Injected Antigravity rules");
     try {
-        const startupWorkflow = await (0, templates_1.readTemplate)("firebase-studio-export/workflows/startup_workflow.md");
-        await fs.writeFile(path.join(workflowsDir, "startup.md"), startupWorkflow);
-        logger_1.logger.info("✅ Created AGY startup workflow");
+        const cleanupWorkflow = await (0, templates_1.readTemplate)("firebase-studio-export/workflows/cleanup.md");
+        await fs.writeFile(path.join(workflowsDir, "cleanup.md"), cleanupWorkflow);
+        logger_1.logger.info("✅ Created Antigravity startup workflow");
     }
     catch (err) {
-        logger_1.logger.debug(`Could not read or write startup workflow: ${err}`);
+        const message = err instanceof Error ? err.message : String(err);
+        logger_1.logger.debug(`Could not read or write startup workflow: ${message}`);
     }
 }
 async function getAgyCommand(startAgy) {
@@ -193,7 +247,7 @@ async function getAgyCommand(startAgy) {
     const commands = ["agy", "antigravity"];
     for (const cmd of commands) {
         if (utils.commandExistsSync(cmd)) {
-            logger_1.logger.info(`✅ Antigravity IDE CLI (${cmd}) detected`);
+            logger_1.logger.info(`✅ Antigravity IDE detected`);
             return cmd;
         }
     }
@@ -201,14 +255,24 @@ async function getAgyCommand(startAgy) {
         const macPath = "/Applications/Antigravity.app/Contents/Resources/app/bin/agy";
         try {
             await fs.access(macPath);
-            logger_1.logger.info(`✅ Antigravity IDE CLI detected at ${macPath}`);
+            logger_1.logger.info(`✅ Antigravity IDE detected at ${macPath}`);
             return macPath;
         }
         catch {
         }
     }
+    if (process.platform === "win32") {
+        const winPath = path.join(process.env.LOCALAPPDATA || "", "Programs", "Antigravity", "bin", "agy.exe");
+        try {
+            await fs.access(winPath);
+            logger_1.logger.info(`✅ Antigravity IDE CLI detected at ${winPath}`);
+            return winPath;
+        }
+        catch {
+        }
+    }
     const downloadLink = "https://antigravity.google/download";
-    logger_1.logger.info(`⚠️ Antigravity IDE CLI (agy) not found in your PATH. To ensure a seamless migration, please download and install Antigravity: ${downloadLink}`);
+    logger_1.logger.info(`⚠️ Antigravity IDE not found in your PATH. To ensure a seamless migration, please download and install Antigravity: ${downloadLink}`);
     return undefined;
 }
 async function createFirebaseConfigs(rootPath, projectId) {
@@ -234,12 +298,35 @@ async function createFirebaseConfigs(rootPath, projectId) {
             const backendsData = await apphosting.listBackends(projectId, "-");
             const backends = backendsData.backends || [];
             if (backends.length > 0) {
+                const backendIds = backends.map((b) => b.name.split("/").pop());
                 const studioBackend = backends.find((b) => b.name.endsWith("/studio") || b.name.toLowerCase().includes("studio"));
+                let selectedBackendId = "";
                 if (studioBackend) {
-                    backendId = studioBackend.name.split("/").pop();
+                    selectedBackendId = studioBackend.name.split("/").pop();
                 }
                 else {
-                    backendId = backends[0].name.split("/").pop();
+                    selectedBackendId = backendIds[0];
+                }
+                const confirmBackend = await prompt.confirm({
+                    message: `Would you like to use the App Hosting backend "${selectedBackendId}"?`,
+                    default: true,
+                    nonInteractive: process.env.NODE_ENV === "test",
+                });
+                if (confirmBackend) {
+                    backendId = selectedBackendId;
+                }
+                else {
+                    logger_1.logger.info("Available App Hosting backends:");
+                    for (const id of backendIds) {
+                        logger_1.logger.info(`  - ${id}`);
+                    }
+                    const inputBackendId = await prompt.input({
+                        message: "Please enter the name of the backend you would like to use:",
+                    });
+                    if (!backendIds.includes(inputBackendId)) {
+                        throw new error_1.FirebaseError(`Invalid backend selected: ${inputBackendId}`, { exit: 1 });
+                    }
+                    backendId = inputBackendId;
                 }
                 logger_1.logger.info(`✅ Selected App Hosting backend: ${backendId}`);
             }
@@ -248,7 +335,8 @@ async function createFirebaseConfigs(rootPath, projectId) {
             }
         }
         catch (err) {
-            utils.logWarning(`Could not fetch backends from Firebase CLI, using default "studio". ${err}`);
+            const message = err instanceof Error ? err.message : String(err);
+            utils.logWarning(`Could not fetch backends from Firebase CLI, using default "studio". ${message}`);
         }
         const firebaseJson = {
             apphosting: {
@@ -256,7 +344,7 @@ async function createFirebaseConfigs(rootPath, projectId) {
                 ignore: [
                     "node_modules",
                     ".git",
-                    ".agent",
+                    ".agents",
                     ".idx",
                     "firebase-debug.log",
                     "firebase-debug.*.log",
@@ -268,20 +356,33 @@ async function createFirebaseConfigs(rootPath, projectId) {
         logger_1.logger.info(`✅ Created firebase.json with backendId: ${backendId}`);
     }
 }
-async function writeAgyConfigs(rootPath) {
+async function writeAntigravityConfigs(rootPath, framework) {
     const vscodeDir = path.join(rootPath, ".vscode");
     await fs.mkdir(vscodeDir, { recursive: true });
     const tasksJson = {
         version: "2.0.0",
-        tasks: [
-            {
-                label: "npm-install",
-                type: "shell",
-                command: "npm install",
-                problemMatcher: [],
-            },
-        ],
+        tasks: [],
     };
+    if (framework === "FLUTTER") {
+        tasksJson.tasks.push({
+            label: "flutter-pub-get",
+            type: "shell",
+            command: "flutter pub get",
+            problemMatcher: [],
+            group: {
+                kind: "build",
+                isDefault: true,
+            },
+        });
+    }
+    else {
+        tasksJson.tasks.push({
+            label: "npm-install",
+            type: "shell",
+            command: "npm install",
+            problemMatcher: [],
+        });
+    }
     await fs.writeFile(path.join(vscodeDir, "tasks.json"), JSON.stringify(tasksJson, null, 2));
     logger_1.logger.info("✅ Created .vscode/tasks.json");
     const settingsPath = path.join(vscodeDir, "settings.json");
@@ -291,7 +392,8 @@ async function writeAgyConfigs(rootPath) {
         settings = JSON.parse(settingsContent);
     }
     catch (err) {
-        logger_1.logger.debug(`Could not read ${settingsPath}: ${err}`);
+        const message = err instanceof Error ? err.message : String(err);
+        logger_1.logger.debug(`Could not read ${settingsPath}: ${message}`);
     }
     const cleanSettings = {};
     for (const [key, value] of Object.entries(settings)) {
@@ -304,32 +406,48 @@ async function writeAgyConfigs(rootPath) {
     logger_1.logger.info("✅ Updated .vscode/settings.json with startup preferences");
     const launchJson = {
         version: "0.2.0",
-        configurations: [
-            {
-                type: "node",
-                request: "launch",
-                name: "Next.js: debug server-side",
-                runtimeExecutable: "npm",
-                runtimeArgs: ["run", "dev"],
-                port: 9002,
-                console: "integratedTerminal",
-                preLaunchTask: "npm-install",
-            },
-        ],
+        configurations: [],
     };
+    if (framework === "ANGULAR") {
+        launchJson.configurations.push({
+            type: "node",
+            request: "launch",
+            name: "Angular: debug server-side",
+            runtimeExecutable: "npm",
+            runtimeArgs: ["run", "start"],
+            port: 4200,
+            console: "integratedTerminal",
+            preLaunchTask: "npm-install",
+        });
+    }
+    else if (framework === "NEXT_JS") {
+        launchJson.configurations.push({
+            type: "node",
+            request: "launch",
+            name: "Next.js: debug server-side",
+            runtimeExecutable: "npm",
+            runtimeArgs: ["run", "dev"],
+            port: 9002,
+            console: "integratedTerminal",
+            preLaunchTask: "npm-install",
+        });
+    }
+    else if (framework === "FLUTTER") {
+        launchJson.configurations.push({
+            name: "Flutter",
+            request: "launch",
+            type: "dart",
+            preLaunchTask: "flutter-pub-get",
+        });
+    }
+    else {
+        return;
+    }
     await fs.writeFile(path.join(vscodeDir, "launch.json"), JSON.stringify(launchJson, null, 2));
     logger_1.logger.info("✅ Created .vscode/launch.json");
 }
 async function cleanupUnusedFiles(rootPath) {
     const docsDir = path.join(rootPath, "docs");
-    const blueprintPath = path.join(docsDir, "blueprint.md");
-    try {
-        await fs.unlink(blueprintPath);
-        logger_1.logger.info("✅ Cleaned up docs/blueprint.md");
-    }
-    catch (err) {
-        logger_1.logger.debug(`Could not delete ${blueprintPath}: ${err}`);
-    }
     try {
         const files = await fs.readdir(docsDir);
         if (files.length === 0) {
@@ -338,23 +456,57 @@ async function cleanupUnusedFiles(rootPath) {
         }
     }
     catch (err) {
-        logger_1.logger.debug(`Could not remove ${docsDir}: ${err}`);
+        const message = err instanceof Error ? err.message : String(err);
+        logger_1.logger.debug(`Could not remove ${docsDir}: ${message}`);
     }
-    const metadataPath = path.join(rootPath, "metadata.json");
+    const modifiedPath = path.join(rootPath, ".modified");
+    try {
+        await fs.unlink(modifiedPath);
+        logger_1.logger.info("✅ Cleaned up .modified");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger_1.logger.debug(`Could not delete ${modifiedPath}: ${message}`);
+    }
+    const mcpJsonPath = path.join(rootPath, ".idx", "mcp.json");
     try {
-        await fs.unlink(metadataPath);
-        logger_1.logger.info("✅ Cleaned up metadata.json");
+        await fs.unlink(mcpJsonPath);
+        logger_1.logger.info("✅ Cleaned up .idx/mcp.json");
     }
     catch (err) {
-        logger_1.logger.debug(`Could not delete ${metadataPath}: ${err}`);
+        const message = err instanceof Error ? err.message : String(err);
+        logger_1.logger.debug(`Could not delete ${mcpJsonPath}: ${message}`);
     }
-    const modifiedPath = path.join(rootPath, ".modified");
+}
+async function upgradeGenkitVersion(rootPath) {
+    const packageJsonPath = path.join(rootPath, "package.json");
     try {
-        await fs.unlink(modifiedPath);
-        logger_1.logger.info("✅ Cleaned up .modified");
+        const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
+        const packageJson = JSON.parse(packageJsonContent);
+        let modified = false;
+        const upgradeDeps = (deps) => {
+            if (!deps) {
+                return;
+            }
+            for (const [name, version] of Object.entries(deps)) {
+                if (name === "genkit" || name === "genkit-cli" || name.startsWith("@genkit-ai/")) {
+                    if (version !== "1.29") {
+                        deps[name] = "1.29";
+                        modified = true;
+                    }
+                }
+            }
+        };
+        upgradeDeps(packageJson.dependencies);
+        upgradeDeps(packageJson.devDependencies);
+        if (modified) {
+            await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+            logger_1.logger.info("✅ Upgraded Genkit version to 1.29 in package.json");
+        }
     }
     catch (err) {
-        logger_1.logger.debug(`Could not delete ${modifiedPath}: ${err}`);
+        const message = err instanceof Error ? err.message : String(err);
+        logger_1.logger.debug(`Could not upgrade Genkit version: ${message}`);
     }
 }
 async function uploadSecrets(rootPath, projectId) {
@@ -382,57 +534,76 @@ async function uploadSecrets(rootPath, projectId) {
         }
     }
     catch (err) {
-        utils.logWarning(`Failed to upload GEMINI_API_KEY secret: ${err}`);
+        const message = err instanceof Error ? err.message : String(err);
+        utils.logWarning(`Failed to upload GEMINI_API_KEY secret: ${message}`);
     }
 }
-async function askToOpenAntigravity(rootPath, appName, startAgy) {
-    const agyCommand = await getAgyCommand(startAgy);
-    if (!startAgy || !agyCommand) {
-        logger_1.logger.info('\n👉 Next steps: Open this folder in Antigravity and run the "Initial Project Setup" workflow.');
+async function askToOpenAntigravity(rootPath, appName, startAntigravity) {
+    const agyCommand = await getAgyCommand(startAntigravity);
+    logger_1.logger.info(`\n🎉 Your Firebase Studio project "${appName}" is now ready for Antigravity!`);
+    logger_1.logger.info("Antigravity is Google's agentic IDE, where you can collaborate with AI agents to build, test, and deploy your application.");
+    logger_1.logger.info("\nWhat to do next inside Antigravity:");
+    logger_1.logger.info("  1.  Review the README.md: It has been updated with specifics about this migrated project.");
+    logger_1.logger.info("  2.  Open the Agent Chat: Use the side panel or press Cmd+L (Ctrl+L on Windows/Linux). This is your main interface with the AI.");
+    logger_1.logger.info("\nFile any bugs at https://github.com/firebase/firebase-tools/issues");
+    if (!startAntigravity || !agyCommand) {
         return;
     }
     const answer = await prompt.confirm({
-        message: `Migration complete for ${appName}! Would you like to open it in Antigravity now?`,
+        message: "Would you like to open it in Antigravity now?",
         default: true,
     });
     if (answer) {
         logger_1.logger.info(`⏳ Opening ${appName} in Antigravity...`);
         try {
-            const agyProcess = (0, child_process_1.spawn)(agyCommand, ["."], {
+            const antigravityProcess = (0, child_process_1.spawn)(agyCommand, ["."], {
                 cwd: rootPath,
                 stdio: "ignore",
                 detached: true,
+                shell: process.platform === "win32",
             });
-            agyProcess.unref();
+            antigravityProcess.unref();
         }
         catch (err) {
             utils.logWarning("Could not open Antigravity IDE automatically. Please open it manually.");
         }
     }
-    else {
-        logger_1.logger.info('\n👉 Next steps: Open this folder in Antigravity and run the "Initial Project Setup" workflow.');
-    }
 }
-async function migrate(rootPath, options = { startAgy: true }) {
-    if (process.platform === "win32") {
-        throw new error_1.FirebaseError("Firebase Studio migration is currently not supported on Windows.", {
-            exit: 1,
-        });
+async function checkDirectoryExists(dir) {
+    try {
+        const stat = await fs.stat(dir);
+        if (!stat.isDirectory()) {
+            throw new error_1.FirebaseError(`The path ${dir} is not a directory.`, { exit: 1 });
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            throw new error_1.FirebaseError(`The directory ${dir} does not exist.`, { exit: 1 });
+        }
+        throw err;
     }
+}
+async function migrate(rootPath, options = { startAntigravity: true }) {
+    await checkDirectoryExists(rootPath);
     const appType = await detectAppType(rootPath);
     void track.trackGA4("firebase_studio_migrate", { app_type: appType, result: "started" });
     logger_1.logger.info("🚀 Starting Firebase Studio to Antigravity migration...");
-    const { projectId, appName, blueprintContent } = await extractMetadata(rootPath, options.project);
-    await updateReadme(rootPath, blueprintContent, appName);
+    const { projectId, appName } = await extractMetadata(rootPath, options.project);
+    if (appType) {
+        logger_1.logger.info(`✅ Detected framework: ${appType}`);
+    }
+    await updateReadme(rootPath, appType);
     await createFirebaseConfigs(rootPath, projectId);
     await uploadSecrets(rootPath, projectId);
-    await injectAgyContext(rootPath, projectId, appName);
-    await writeAgyConfigs(rootPath);
+    await upgradeGenkitVersion(rootPath);
+    await injectAntigravityContext(rootPath, projectId, appName);
+    await writeAntigravityConfigs(rootPath, appType);
+    await setupAntigravityMcpServer(rootPath, appType);
     await cleanupUnusedFiles(rootPath);
     const currentFolderName = path.basename(rootPath);
     if (currentFolderName === "download") {
-        logger_1.logger.info(`\n💡 Tip: You might want to rename this folder to "${appName.toLowerCase().replace(/\s+/g, "-")}"`);
+        logger_1.logger.info(`\n💡 Tip: You may want to rename this folder to "${appName.toLowerCase().replace(/\s+/g, "-")}"`);
     }
     await track.trackGA4("firebase_studio_migrate", { app_type: appType, result: "success" });
-    await askToOpenAntigravity(rootPath, appName, options.startAgy);
+    await askToOpenAntigravity(rootPath, appName, options.startAntigravity);
 }