chrome-devtools-mcp-for-extension 0.18.0 → 0.18.2

package/build/src/roots-manager.js

@@ -32,8 +32,9 @@ export async function fetchRootsFromClient(server) {
 }
 /**
  * Generate stable profile key from roots and client info
+ * Format: projectName_hash (e.g., "my-app_2ca5dbf5")
  */
-export function generateProfileKey(rootsUris, clientName, clientVersion) {
+export function generateProfileKey(rootsUris, clientName, clientVersion, projectName) {
     // Sort URIs for consistent hashing across multi-root workspaces
     const sortedUris = [...rootsUris].sort();
     const keyMaterial = JSON.stringify({
@@ -41,8 +42,13 @@ export function generateProfileKey(rootsUris, clientName, clientVersion) {
         client: clientName,
         version: clientVersion,
     });
-    // Use first 12 chars of SHA-256 for stable, collision-resistant key
-    const hash = createHash('sha256').update(keyMaterial).digest('hex').slice(0, 12);
+    // Use first 8 chars of SHA-256 for stable, collision-resistant key
+    const hash = createHash('sha256').update(keyMaterial).digest('hex').slice(0, 8);
+    // Include project name for clarity (if available)
+    if (projectName) {
+        const sanitized = projectName.replace(/[^a-z0-9_-]/gi, '-').toLowerCase();
+        return `${sanitized}_${hash}`;
+    }
     return hash;
 }
 /**
@@ -88,8 +94,8 @@ export async function resolveRoots(server, fallbackOptions) {
     const rootsResult = await fetchRootsFromClient(server);
     if (rootsResult && rootsResult.roots.length > 0) {
         const rootsUris = rootsResult.roots.map(r => r.uri);
-        const profileKey = generateProfileKey(rootsUris, clientName, clientVersion);
         const projectName = extractProjectName(rootsResult.roots);
+        const profileKey = generateProfileKey(rootsUris, clientName, clientVersion, projectName);
         console.error(`[roots] Resolved via roots/list: key=${profileKey}, project=${projectName}, client=${clientName}`);
         return {
             profileKey,
@@ -103,8 +109,8 @@ export async function resolveRoots(server, fallbackOptions) {
     // 2) Fallback: CLI argument --project-root
     if (fallbackOptions.cliProjectRoot) {
         const uri = pathToFileUri(fallbackOptions.cliProjectRoot);
-        const profileKey = generateProfileKey([uri], clientName, clientVersion);
         const projectName = extractProjectName([{ uri }]);
+        const profileKey = generateProfileKey([uri], clientName, clientVersion, projectName);
         console.error(`[roots] Resolved via --project-root: key=${profileKey}, project=${projectName}`);
         return {
             profileKey,
@@ -118,8 +124,8 @@ export async function resolveRoots(server, fallbackOptions) {
     // 3) Fallback: Environment variable MCP_PROJECT_ROOT
     if (fallbackOptions.envProjectRoot) {
         const uri = pathToFileUri(fallbackOptions.envProjectRoot);
-        const profileKey = generateProfileKey([uri], clientName, clientVersion);
         const projectName = extractProjectName([{ uri }]);
+        const profileKey = generateProfileKey([uri], clientName, clientVersion, projectName);
         console.error(`[roots] Resolved via MCP_PROJECT_ROOT: key=${profileKey}, project=${projectName}`);
         return {
             profileKey,
@@ -133,8 +139,8 @@ export async function resolveRoots(server, fallbackOptions) {
     // 4) Fallback: AUTO (cwd-based, last resort)
     if (fallbackOptions.autoCwd) {
         const uri = pathToFileUri(fallbackOptions.autoCwd);
-        const profileKey = generateProfileKey([uri], clientName, clientVersion);
         const projectName = extractProjectName([{ uri }]);
+        const profileKey = generateProfileKey([uri], clientName, clientVersion, projectName);
         console.error(`[roots] Resolved via AUTO (cwd): key=${profileKey}, project=${projectName}`);
         return {
             profileKey,
@@ -147,11 +153,12 @@ export async function resolveRoots(server, fallbackOptions) {
     }
     // Absolute fallback
     const fallbackUri = 'file:///unknown';
-    const profileKey = generateProfileKey([fallbackUri], clientName, clientVersion);
+    const fallbackProjectName = 'unknown';
+    const profileKey = generateProfileKey([fallbackUri], clientName, clientVersion, fallbackProjectName);
     console.error('[roots] WARNING: No roots available, using fallback');
     return {
         profileKey,
-        projectName: 'unknown',
+        projectName: fallbackProjectName,
         rootsUris: [fallbackUri],
         clientName,
         clientVersion,

package/build/src/selectors/gemini.json

@@ -0,0 +1,24 @@
+{
+    "version": "1.0.0",
+    "lastUpdated": "2025-11-27",
+    "description": "Selectors for Gemini web interface",
+    "elements": {
+        "editor": {
+            "css": "div[contenteditable='true']",
+            "description": "Main input editor"
+        },
+        "sendButton": {
+            "ax": {
+                "ariaLabel": "送信"
+            },
+            "description": "Send message button"
+        },
+        "response": {
+            "css": "model-response",
+            "description": "Response container"
+        }
+    },
+    "placeholders": {
+        "normalMode": "プロンプトを入力"
+    }
+}

package/build/src/selectors/loader.js

@@ -99,4 +99,36 @@ export function checkPlaceholder(placeholder, mode) {
  */
 export function clearCache() {
     cachedSelectors = null;
+    cachedGeminiSelectors = null;
+}
+let cachedGeminiSelectors = null;
+/**
+ * Load Gemini selectors from JSON file
+ */
+export function loadGeminiSelectors() {
+    if (cachedGeminiSelectors) {
+        return cachedGeminiSelectors;
+    }
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const selectorsPath = path.join(__dirname, 'gemini.json');
+    try {
+        const data = fs.readFileSync(selectorsPath, 'utf-8');
+        cachedGeminiSelectors = JSON.parse(data);
+        return cachedGeminiSelectors;
+    }
+    catch (error) {
+        throw new Error(`Failed to load selectors from ${selectorsPath}: ${error}`);
+    }
+}
+/**
+ * Get a specific Gemini selector definition
+ */
+export function getGeminiSelector(elementName) {
+    const selectors = loadGeminiSelectors();
+    const selector = selectors.elements[elementName];
+    if (!selector) {
+        throw new Error(`Selector not found: ${elementName}`);
+    }
+    return selector;
 }

package/build/src/tools/diagnose-ui.js

@@ -9,6 +9,7 @@ import z from 'zod';
 import { ToolCategories } from './categories.js';
 import { defineTool } from './ToolDefinition.js';
 import { CHATGPT_CONFIG } from '../config.js';
+import { isLoginRequired } from '../login-helper.js';
 /**
  * Known important elements in ChatGPT UI
  */
@@ -216,6 +217,14 @@ export const diagnoseChatgptUi = defineTool({
             // Navigate to ChatGPT
             response.appendResponseLine(`📡 Navigating to ${url}...`);
             await page.goto(url, { waitUntil: 'networkidle0', timeout: 30000 });
+            // Check if login is required
+            const needsLogin = await isLoginRequired(page);
+            if (needsLogin) {
+                response.appendResponseLine('\n❌ ChatGPTへのログインが必要です');
+                response.appendResponseLine('📱 ブラウザウィンドウでログインしてから再実行してください');
+                return;
+            }
+            response.appendResponseLine('✅ Login check passed');
             // Wait for page to stabilize
             response.appendResponseLine(`⏳ Waiting ${waitForLoad}ms for page to stabilize...`);
             await new Promise(resolve => setTimeout(resolve, waitForLoad));

package/build/src/tools/gemini-web.js

@@ -0,0 +1,357 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import z from 'zod';
+import { ToolCategories } from './categories.js';
+import { defineTool } from './ToolDefinition.js';
+import { GEMINI_CONFIG } from '../config.js';
+import { isLoginRequired } from '../login-helper.js';
+/**
+ * Path to store chat session data
+ */
+const CHAT_SESSIONS_FILE = path.join(process.cwd(), 'docs/ask/gemini/.chat-sessions.json');
+/**
+ * Load chat sessions from JSON file
+ */
+async function loadChatSessions() {
+    try {
+        const data = await fs.promises.readFile(CHAT_SESSIONS_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Save a chat session for a project
+ */
+async function saveChatSession(projectName, session) {
+    const sessions = await loadChatSessions();
+    if (!sessions[projectName]) {
+        sessions[projectName] = [];
+    }
+    const existingIndex = sessions[projectName].findIndex(s => s.chatId === session.chatId);
+    if (existingIndex >= 0) {
+        sessions[projectName][existingIndex] = {
+            ...sessions[projectName][existingIndex],
+            ...session,
+            lastUsed: new Date().toISOString(),
+        };
+    }
+    else {
+        sessions[projectName].push({
+            ...session,
+            createdAt: session.createdAt || new Date().toISOString(),
+        });
+    }
+    const dir = path.dirname(CHAT_SESSIONS_FILE);
+    await fs.promises.mkdir(dir, { recursive: true });
+    await fs.promises.writeFile(CHAT_SESSIONS_FILE, JSON.stringify(sessions, null, 2), 'utf-8');
+}
+/**
+ * Sanitize question
+ */
+function sanitizeQuestion(text) {
+    const passwordPatterns = [
+        /password\s*[:=]\s*\S+/gi,
+        /パスワード\s*[:：=]\s*\S+/gi,
+        /pwd\s*[:=]\s*\S+/gi,
+        /secret\s*[:=]\s*\S+/gi,
+    ];
+    let sanitized = text;
+    for (const pattern of passwordPatterns) {
+        sanitized = sanitized.replace(pattern, '[パスワードは除外されました]');
+    }
+    return sanitized;
+}
+/**
+ * Save conversation log
+ */
+async function saveConversationLog(projectName, question, response, metadata) {
+    const now = new Date();
+    const timestamp = [
+        String(now.getFullYear()).slice(2).padStart(2, '0'),
+        String(now.getMonth() + 1).padStart(2, '0'),
+        String(now.getDate()).padStart(2, '0'),
+        '_',
+        String(now.getHours()).padStart(2, '0'),
+        String(now.getMinutes()).padStart(2, '0'),
+        String(now.getSeconds()).padStart(2, '0'),
+    ].join('');
+    const topicSlug = question
+        .substring(0, 50)
+        .replace(/[^a-z0-9\u3040-\u309f\u30a0-\u30ff\u4e00-\u9faf]+/gi, '-')
+        .toLowerCase()
+        .slice(0, 30);
+    let logPath;
+    if (metadata.chatId) {
+        const conversationNum = String(metadata.conversationNumber || 1).padStart(3, '0');
+        const filename = `${conversationNum}-${timestamp}-${topicSlug}.md`;
+        const logDir = path.join('docs/ask/gemini', metadata.chatId);
+        logPath = path.join(process.cwd(), logDir, filename);
+        await fs.promises.mkdir(path.join(process.cwd(), logDir), { recursive: true });
+    }
+    else {
+        const filename = `${timestamp}-${projectName}-${topicSlug}.md`;
+        const logDir = 'docs/ask/gemini';
+        logPath = path.join(process.cwd(), logDir, filename);
+        await fs.promises.mkdir(path.dirname(logPath), { recursive: true });
+    }
+    const content = `# ${topicSlug}
+
+## 📅 メタ情報
+- **日時**: ${now.toLocaleString('ja-JP')}
+- **プロジェクト**: ${projectName}
+- **AIモデル**: ${metadata.model || 'Gemini'}
+${metadata.chatId ? `- **チャットID**: ${metadata.chatId}\n` : ''}${metadata.conversationNumber ? `- **会話番号**: ${metadata.conversationNumber}\n` : ''}${metadata.chatUrl ? `- **チャットURL**: ${metadata.chatUrl}\n` : ''}
+## ❓ 質問
+
+${question}
+
+## 💬 回答
+
+${response}
+`;
+    await fs.promises.writeFile(logPath, content, 'utf-8');
+    return path.relative(process.cwd(), logPath);
+}
+export const askGeminiWeb = defineTool({
+    name: 'ask_gemini_web',
+    description: `Ask Gemini a question via web browser automation. Conversations are organized by project name and logged to docs/ask/gemini/.`,
+    annotations: {
+        category: ToolCategories.NAVIGATION_AUTOMATION,
+        readOnlyHint: false,
+    },
+    schema: {
+        question: z
+            .string()
+            .describe('The question to ask Gemini.'),
+        projectName: z
+            .string()
+            .optional()
+            .describe('Project name for organizing conversations. Defaults to current working directory name.'),
+        createNewChat: z
+            .boolean()
+            .optional()
+            .describe('Force creation of a new chat. Default: false'),
+    },
+    handler: async (request, response, context) => {
+        const { question, projectName, createNewChat = false } = request.params;
+        const sanitizedQuestion = sanitizeQuestion(question);
+        const project = projectName || path.basename(process.cwd()) || 'unknown-project';
+        const page = context.getSelectedPage();
+        try {
+            response.appendResponseLine('Geminiに接続中...');
+            await page.goto(GEMINI_CONFIG.DEFAULT_URL, { waitUntil: 'networkidle2' });
+            const needsLogin = await isLoginRequired(page);
+            if (needsLogin) {
+                response.appendResponseLine('\n❌ Geminiへのログインが必要です');
+                response.appendResponseLine('ブラウザでログインしてください。');
+                return;
+            }
+            response.appendResponseLine('✅ ログイン確認完了');
+            let isNewChat = false;
+            let sessionChatId;
+            if (!createNewChat) {
+                const sessions = await loadChatSessions();
+                const projectSessions = sessions[project] || [];
+                if (projectSessions.length > 0) {
+                    const sortedSessions = [...projectSessions].sort((a, b) => new Date(b.lastUsed).getTime() - new Date(a.lastUsed).getTime());
+                    const latestSession = sortedSessions[0];
+                    response.appendResponseLine(`既存のチャットを使用: ${latestSession.url}`);
+                    await page.goto(latestSession.url, { waitUntil: 'networkidle2' });
+                    sessionChatId = latestSession.chatId;
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                }
+                else {
+                    isNewChat = true;
+                }
+            }
+            else {
+                isNewChat = true;
+            }
+            if (isNewChat) {
+                response.appendResponseLine('新規チャットを作成中...');
+                await page.goto(GEMINI_CONFIG.BASE_URL + 'app', { waitUntil: 'networkidle2' });
+            }
+            response.appendResponseLine('質問を送信中...');
+            // Input text using the textbox element
+            // Gemini uses a textbox with role="textbox" or a div with contenteditable
+            const questionSent = await page.evaluate((questionText) => {
+                // Try textbox first (Gemini's current implementation)
+                const textbox = document.querySelector('[role="textbox"]');
+                if (textbox) {
+                    textbox.focus();
+                    // Clear existing content
+                    textbox.innerHTML = '';
+                    // Insert text
+                    const p = document.createElement('p');
+                    p.textContent = questionText;
+                    textbox.appendChild(p);
+                    textbox.dispatchEvent(new Event('input', { bubbles: true }));
+                    return true;
+                }
+                // Fallback to contenteditable
+                const editor = document.querySelector('div[contenteditable="true"]');
+                if (editor) {
+                    editor.innerHTML = '';
+                    const p = document.createElement('p');
+                    p.textContent = questionText;
+                    editor.appendChild(p);
+                    editor.dispatchEvent(new Event('input', { bubbles: true }));
+                    return true;
+                }
+                return false;
+            }, sanitizedQuestion);
+            if (!questionSent) {
+                response.appendResponseLine('❌ 入力欄が見つかりません');
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            // Click send button - look for "プロンプトを送信" or similar
+            const sent = await page.evaluate(() => {
+                const buttons = Array.from(document.querySelectorAll('button'));
+                // Primary: look for "プロンプトを送信" button
+                let sendButton = buttons.find(b => b.textContent?.includes('プロンプトを送信') ||
+                    b.textContent?.includes('送信') ||
+                    b.getAttribute('aria-label')?.includes('送信') ||
+                    b.getAttribute('aria-label')?.includes('Send'));
+                // Fallback: look for send icon
+                if (!sendButton) {
+                    sendButton = buttons.find(b => b.querySelector('mat-icon[data-mat-icon-name="send"]') ||
+                        b.querySelector('[data-icon="send"]'));
+                }
+                if (sendButton && !sendButton.disabled) {
+                    sendButton.click();
+                    return true;
+                }
+                return false;
+            });
+            if (!sent) {
+                // Fallback: try Enter key
+                await page.keyboard.press('Enter');
+                response.appendResponseLine('⚠️ 送信ボタンが見つかりません (Enterキーを試行)');
+            }
+            response.appendResponseLine('回答を待機中...');
+            // Wait for response using actual Gemini UI indicators:
+            // - Generating: "回答を停止" button appears, "Gemini が入力中です" text
+            // - Complete: "Gemini が回答しました" text appears
+            const startTime = Date.now();
+            let stableCount = 0;
+            let lastResponseText = '';
+            while (true) {
+                await new Promise((resolve) => setTimeout(resolve, 1500));
+                const status = await page.evaluate(() => {
+                    // Check for generating indicators
+                    const buttons = Array.from(document.querySelectorAll('button'));
+                    const stopButton = buttons.find(b => b.textContent?.includes('回答を停止') ||
+                        b.textContent?.includes('Stop') ||
+                        b.getAttribute('aria-label')?.includes('Stop'));
+                    // Check for status text
+                    const bodyText = document.body.innerText;
+                    const isTyping = bodyText.includes('Gemini が入力中です') ||
+                        bodyText.includes('Gemini is typing');
+                    const isComplete = bodyText.includes('Gemini が回答しました') ||
+                        bodyText.includes('Gemini has responded');
+                    const isGenerating = !!stopButton || isTyping;
+                    // Get the response content from model-response elements
+                    const modelResponses = Array.from(document.querySelectorAll('model-response'));
+                    let responseContent = '';
+                    if (modelResponses.length > 0) {
+                        // Get the last model response
+                        const lastResponse = modelResponses[modelResponses.length - 1];
+                        responseContent = lastResponse.textContent || '';
+                    }
+                    // Fallback: get text from main area
+                    if (!responseContent) {
+                        const main = document.querySelector('main');
+                        responseContent = main?.innerText || '';
+                    }
+                    return {
+                        isGenerating,
+                        isComplete,
+                        responseContent
+                    };
+                });
+                // If explicitly marked as complete, we're done
+                if (status.isComplete && !status.isGenerating) {
+                    break;
+                }
+                // If not generating and response text is stable for 2 iterations, we're done
+                if (!status.isGenerating && status.responseContent === lastResponseText && status.responseContent.length > 0) {
+                    stableCount++;
+                    if (stableCount >= 2) {
+                        break;
+                    }
+                }
+                else {
+                    stableCount = 0;
+                }
+                lastResponseText = status.responseContent;
+                if (Date.now() - startTime > 180000) { // 3 mins timeout
+                    response.appendResponseLine('⚠️ タイムアウト（3分）');
+                    break;
+                }
+            }
+            // Get the final response content
+            const responseText = await page.evaluate(() => {
+                // Get content from model-response elements
+                const modelResponses = Array.from(document.querySelectorAll('model-response'));
+                if (modelResponses.length > 0) {
+                    // Get the last model response
+                    const lastResponse = modelResponses[modelResponses.length - 1];
+                    return lastResponse.textContent?.trim() || '';
+                }
+                // Fallback: get text from main area
+                const main = document.querySelector('main');
+                return main?.innerText.slice(-5000) || '';
+            });
+            response.appendResponseLine('✅ 回答完了');
+            // Save session
+            if (isNewChat) {
+                const chatUrl = page.url();
+                const chatIdMatch = chatUrl.match(/\/app\/([a-f0-9]+)/);
+                const chatId = chatIdMatch ? chatIdMatch[1] : 'unknown-' + Date.now();
+                await saveChatSession(project, {
+                    chatId,
+                    url: chatUrl,
+                    lastUsed: new Date().toISOString(),
+                    createdAt: new Date().toISOString(),
+                    title: `[Project: ${project}]`,
+                    conversationCount: 1,
+                });
+                sessionChatId = chatId;
+            }
+            // Save log
+            const logPath = await saveConversationLog(project, sanitizedQuestion, responseText, {
+                chatUrl: page.url(),
+                chatId: sessionChatId,
+            });
+            response.appendResponseLine(`📝 会話ログ保存: ${logPath}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            response.appendResponseLine(`❌ エラー: ${errorMessage}`);
+            // Error snapshot
+            try {
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                const debugDir = path.join(process.cwd(), 'docs/ask/gemini/debug');
+                await fs.promises.mkdir(debugDir, { recursive: true });
+                const screenshotPath = path.join(debugDir, `error-${timestamp}.png`);
+                await page.screenshot({ path: screenshotPath });
+                response.appendResponseLine(`📸 エラー時のスクリーンショット: ${screenshotPath}`);
+                const htmlPath = path.join(debugDir, `error-${timestamp}.html`);
+                const html = await page.content();
+                await fs.promises.writeFile(htmlPath, html, 'utf-8');
+                response.appendResponseLine(`📄 エラー時のHTML: ${htmlPath}`);
+            }
+            catch (snapshotError) {
+                console.error('Failed to capture error snapshot:', snapshotError);
+            }
+        }
+    },
+});

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "chrome-devtools-mcp-for-extension",
-  "version": "0.18.0",
+  "version": "0.18.2",
   "description": "MCP server for Chrome extension development with Web Store automation. Fork of chrome-devtools-mcp with extension-specific tools.",
   "type": "module",
-  "bin": "./build/src/index.js",
+  "bin": "./scripts/cli.mjs",
   "main": "index.js",
   "scripts": {
     "build": "tsc && node --experimental-strip-types --no-warnings=ExperimentalWarning scripts/post-build.ts",
+    "dev": "MCP_ENV=development node scripts/mcp-wrapper.mjs",
     "typecheck": "tsc --noEmit",
     "format": "eslint --cache --fix . && prettier --write --cache .",
     "check-format": "eslint --cache . && prettier --check --cache .;",
@@ -68,15 +69,16 @@
     "@types/yargs": "^17.0.33",
     "@typescript-eslint/eslint-plugin": "^8.43.0",
     "@typescript-eslint/parser": "^8.43.0",
+    "chokidar": "^4.0.3",
     "chrome-devtools-frontend": "1.0.1520535",
     "eslint": "^9.35.0",
-    "eslint-plugin-import": "^2.32.0",
     "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
     "globals": "^16.4.0",
     "prettier": "^3.6.2",
     "sinon": "^21.0.0",
-    "typescript-eslint": "^8.43.0",
-    "typescript": "^5.9.2"
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.43.0"
   },
   "engines": {
     "node": ">=22.12.0"

package/scripts/cli.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+/**
+ * CLI Entry Point for chrome-devtools-mcp-for-extension
+ *
+ * This is the entry point when users run:
+ *   npx chrome-devtools-mcp-for-extension
+ *   chrome-devtools-mcp-for-extension (if globally installed)
+ *
+ * Launches the MCP server with browser globals mock:
+ * - Loads browser-globals-mock.mjs BEFORE main.js
+ * - Ensures chrome-devtools-frontend modules work in Node.js
+ * - Simple execution: no wrapper, no hot-reload
+ */
+
+import { spawn } from "node:child_process";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+// Resolve paths
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const mockPath = path.join(__dirname, "browser-globals-mock.mjs");
+const mainPath = path.join(__dirname, "..", "build", "src", "main.js");
+
+// Launch MCP server with --import flag
+const child = spawn(process.execPath, [
+  "--import", mockPath,
+  mainPath,
+  ...process.argv.slice(2) // Forward CLI arguments
+], {
+  stdio: "inherit",
+  env: process.env,
+});
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    process.exit(1);
+  }
+  process.exit(code ?? 0);
+});
+
+// Forward signals
+process.on("SIGTERM", () => child?.kill("SIGTERM"));
+process.on("SIGINT", () => child?.kill("SIGINT"));