@muggleai/mcp 1.0.0 → 1.0.2

package/README.md

@@ -1,160 +1,160 @@
-# @muggleai/mcp
-
-Unified MCP server for Muggle AI - combines Cloud QA and Local Testing tools into a single package.
-
-## Installation
-
-```bash
-npm install -g @muggleai/mcp
-```
-
-This automatically:
-1. Installs the package
-2. Downloads the Electron app binary (via postinstall)
-3. Sets up CLI commands
-
-## Quick Start
-
-### 1. Add to your MCP client
-
-**Cursor (`~/.cursor/mcp.json`):**
-
-```json
-{
-  "mcpServers": {
-    "muggle": {
-      "command": "muggle-mcp",
-      "args": ["serve"]
-    }
-  }
-}
-```
-
-### 2. Start using MCP tools
-
-Ask your AI assistant to test your application! Authentication happens automatically when needed.
-
-## CLI Commands
-
-```bash
-# Server (main command - starts MCP server for AI clients)
-muggle-mcp serve              # Start server with all tools (default)
-muggle-mcp serve --qa         # Cloud QA tools only
-muggle-mcp serve --local      # Local testing tools only
-
-# Setup & Diagnostics
-muggle-mcp setup              # Download/update Electron app
-muggle-mcp setup --force      # Force re-download
-muggle-mcp doctor             # Diagnose installation issues
-
-# Authentication (optional - auth happens automatically)
-muggle-mcp login              # Manually trigger login
-muggle-mcp logout             # Clear credentials
-muggle-mcp status             # Show auth status
-
-# Info
-muggle-mcp --version          # Show version
-muggle-mcp --help             # Show help
-```
-
-## Authentication
-
-Authentication happens automatically when you first use a tool that requires it:
-
-1. A browser window opens with a verification code
-2. You log in with your Muggle AI account
-3. The tool call continues with your credentials
-
-Your credentials are stored in `~/.muggle-ai/credentials.json` and persist across sessions.
-
-## Available Tools
-
-### Cloud QA Tools
-
-Tools that work with the Muggle AI cloud backend:
-
-- `qa_project_create` - Create QA project
-- `qa_project_list` - List projects
-- `qa_use_case_create_from_prompts` - Create use cases
-- `qa_test_case_generate_from_prompt` - Generate test cases
-- `qa_workflow_start_*` - Start various workflows
-- And more...
-
-### Local QA Tools
-
-Tools that work with local testing:
-
-- `muggle_project_create` - Create local project
-- `muggle_test_case_save` - Save test case locally
-- `muggle_execute_test_generation` - Generate test script
-- `muggle_execute_replay` - Replay test script
-- `muggle_cloud_pull_project` - Pull from cloud
-- `muggle_publish_project` - Publish to cloud
-- And more...
-
-## Data Directory
-
-All Muggle AI data is stored in `~/.muggle-ai/`:
-
-```
-~/.muggle-ai/
-├── credentials.json      # Auth credentials (auto-generated)
-├── projects/             # Local test projects
-├── sessions/             # Test execution sessions
-└── electron-app/         # Downloaded Electron app
-    └── 1.0.0/
-        └── MuggleAI.exe
-```
-
-## Requirements
-
-- Node.js 22 or higher
-- For local testing: Electron app (downloaded automatically)
-
-## Development
-
-### Building
-
-```bash
-npm install
-npm run build
-```
-
-### Testing
-
-```bash
-npm test              # Run tests once
-npm run test:watch    # Watch mode
-```
-
-### Linting
-
-```bash
-npm run lint          # Auto-fix issues
-npm run lint:check    # Check only
-```
-
-## CI/CD Workflows
-
-| Workflow | Trigger | Description |
-| :------- | :------ | :---------- |
-| `ci.yml` | Push/PR to main | Lint, test, build on multiple platforms/versions |
-| `publish-mcp.yml` | Tag `v*` | Publish package to npm |
-| `release-electron-app.yml` | Tag `electron-app@*` | Build and release Electron binaries |
-
-### Publishing a new version
-
-1. Update version in `package.json`
-2. Commit and push
-3. Create a git tag: `git tag v1.0.1 && git push --tags`
-4. The `publish-mcp.yml` workflow publishes to npm automatically
-
-### Releasing Electron app
-
-1. Update `muggleConfig.electronAppVersion` in `package.json`
-2. Run the `release-electron-app.yml` workflow manually
-3. Or create a tag: `git tag electron-app@1.0.1 && git push --tags`
-
-## License
-
-MIT
+# @muggleai/mcp
+
+Unified MCP server for Muggle AI - combines Cloud QA and Local Testing tools into a single package.
+
+## Installation
+
+```bash
+npm install -g @muggleai/mcp
+```
+
+This automatically:
+1. Installs the package
+2. Downloads the Electron app binary (via postinstall)
+3. Sets up CLI commands
+
+## Quick Start
+
+### 1. Add to your MCP client
+
+**Cursor (`~/.cursor/mcp.json`):**
+
+```json
+{
+  "mcpServers": {
+    "muggle": {
+      "command": "muggle-mcp",
+      "args": ["serve"]
+    }
+  }
+}
+```
+
+### 2. Start using MCP tools
+
+Ask your AI assistant to test your application! Authentication happens automatically when needed.
+
+## CLI Commands
+
+```bash
+# Server (main command - starts MCP server for AI clients)
+muggle-mcp serve              # Start server with all tools (default)
+muggle-mcp serve --qa         # Cloud QA tools only
+muggle-mcp serve --local      # Local testing tools only
+
+# Setup & Diagnostics
+muggle-mcp setup              # Download/update Electron app
+muggle-mcp setup --force      # Force re-download
+muggle-mcp doctor             # Diagnose installation issues
+
+# Authentication (optional - auth happens automatically)
+muggle-mcp login              # Manually trigger login
+muggle-mcp logout             # Clear credentials
+muggle-mcp status             # Show auth status
+
+# Info
+muggle-mcp --version          # Show version
+muggle-mcp --help             # Show help
+```
+
+## Authentication
+
+Authentication happens automatically when you first use a tool that requires it:
+
+1. A browser window opens with a verification code
+2. You log in with your Muggle AI account
+3. The tool call continues with your credentials
+
+Your credentials are stored in `~/.muggle-ai/credentials.json` and persist across sessions.
+
+## Available Tools
+
+### Cloud QA Tools
+
+Tools that work with the Muggle AI cloud backend:
+
+- `qa_project_create` - Create QA project
+- `qa_project_list` - List projects
+- `qa_use_case_create_from_prompts` - Create use cases
+- `qa_test_case_generate_from_prompt` - Generate test cases
+- `qa_workflow_start_*` - Start various workflows
+- And more...
+
+### Local QA Tools
+
+Tools that work with local testing:
+
+- `muggle_project_create` - Create local project
+- `muggle_test_case_save` - Save test case locally
+- `muggle_execute_test_generation` - Generate test script
+- `muggle_execute_replay` - Replay test script
+- `muggle_cloud_pull_project` - Pull from cloud
+- `muggle_publish_project` - Publish to cloud
+- And more...
+
+## Data Directory
+
+All Muggle AI data is stored in `~/.muggle-ai/`:
+
+```
+~/.muggle-ai/
+├── credentials.json      # Auth credentials (auto-generated)
+├── projects/             # Local test projects
+├── sessions/             # Test execution sessions
+└── electron-app/         # Downloaded Electron app
+    └── 1.0.0/
+        └── MuggleAI.exe
+```
+
+## Requirements
+
+- Node.js 22 or higher
+- For local testing: Electron app (downloaded automatically)
+
+## Development
+
+### Building
+
+```bash
+npm install
+npm run build
+```
+
+### Testing
+
+```bash
+npm test              # Run tests once
+npm run test:watch    # Watch mode
+```
+
+### Linting
+
+```bash
+npm run lint          # Auto-fix issues
+npm run lint:check    # Check only
+```
+
+## CI/CD Workflows
+
+| Workflow | Trigger | Description |
+| :------- | :------ | :---------- |
+| `ci.yml` | Push/PR to main | Lint, test, build on multiple platforms/versions |
+| `publish-mcp.yml` | Tag `v*` | Publish package to npm |
+| `release-electron-app.yml` | Tag `electron-app@*` | Build and release Electron binaries |
+
+### Publishing a new version
+
+1. Update version in `package.json`
+2. Commit and push
+3. Create a git tag: `git tag v1.0.1 && git push --tags`
+4. The `publish-mcp.yml` workflow publishes to npm automatically
+
+### Releasing Electron app
+
+1. Update `muggleConfig.electronAppVersion` in `package.json`
+2. Run the `release-electron-app.yml` workflow manually
+3. Or create a tag: `git tag electron-app@1.0.1 && git push --tags`
+
+## License
+
+MIT

package/bin/muggle-mcp.js

@@ -1,2 +1,2 @@
-#!/usr/bin/env node
-import "../dist/cli.js";
+#!/usr/bin/env node
+import "../dist/cli.js";

package/dist/{chunk-6DQWAMGJ.js → chunk-CL6YSSTI.js}

@@ -15,6 +15,12 @@ import { ulid } from 'ulid';
 import * as fs6 from 'fs/promises';
 
 var __defProp = Object.defineProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -51,14 +57,19 @@ function getMuggleConfig() {
     const packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
     const config = packageJson.muggleConfig;
     if (config?.electronAppVersion && config?.downloadBaseUrl) {
-      muggleConfigCache = config;
-      return config;
+      muggleConfigCache = {
+        electronAppVersion: config.electronAppVersion,
+        downloadBaseUrl: config.downloadBaseUrl,
+        checksums: config.checksums
+      };
+      return muggleConfigCache;
     }
   } catch {
   }
   muggleConfigCache = {
-    electronAppVersion: "1.0.0",
-    downloadBaseUrl: "https://github.com/multiplex-ai/muggle-ai-mcp/releases/download"
+    electronAppVersion: "1.0.1",
+    downloadBaseUrl: "https://github.com/multiplex-ai/muggle-ai-mcp/releases/download",
+    checksums: {}
   };
   return muggleConfigCache;
 }
@@ -201,12 +212,51 @@ function resetConfig() {
   configInstance = null;
   muggleConfigCache = null;
 }
+var VERSION_OVERRIDE_FILE = "electron-app-version-override.json";
+var ELECTRON_APP_VERSION_ENV = "ELECTRON_APP_VERSION";
 function getElectronAppVersion() {
+  const envVersion = process.env[ELECTRON_APP_VERSION_ENV];
+  if (envVersion && /^\d+\.\d+\.\d+$/.test(envVersion)) {
+    return envVersion;
+  }
+  const overridePath = path4.join(getDataDir(), VERSION_OVERRIDE_FILE);
+  if (fs4.existsSync(overridePath)) {
+    try {
+      const content = JSON.parse(fs4.readFileSync(overridePath, "utf-8"));
+      if (content.version && typeof content.version === "string") {
+        return content.version;
+      }
+    } catch {
+    }
+  }
+  return getMuggleConfig().electronAppVersion;
+}
+function getElectronAppVersionSource() {
+  const envVersion = process.env[ELECTRON_APP_VERSION_ENV];
+  if (envVersion && /^\d+\.\d+\.\d+$/.test(envVersion)) {
+    return "env";
+  }
+  const overridePath = path4.join(getDataDir(), VERSION_OVERRIDE_FILE);
+  if (fs4.existsSync(overridePath)) {
+    try {
+      const content = JSON.parse(fs4.readFileSync(overridePath, "utf-8"));
+      if (content.version && typeof content.version === "string") {
+        return "override";
+      }
+    } catch {
+    }
+  }
+  return "bundled";
+}
+function getBundledElectronAppVersion() {
   return getMuggleConfig().electronAppVersion;
 }
 function getDownloadBaseUrl() {
   return getMuggleConfig().downloadBaseUrl;
 }
+function getElectronAppChecksums() {
+  return getMuggleConfig().checksums;
+}
 function isElectronAppInstalled() {
   return getDownloadedElectronAppPath() !== null;
 }
@@ -5376,6 +5426,8 @@ function buildSecretOptionsFromLocalSecrets(params) {
 }
 var DEFAULT_GENERATION_TIMEOUT_MS = 3e5;
 var DEFAULT_REPLAY_TIMEOUT_MS = 18e4;
+var INACTIVITY_TIMEOUT_MS = 12e4;
+var INACTIVITY_CHECK_INTERVAL_MS = 5e3;
 var activeProcesses = /* @__PURE__ */ new Map();
 function generateRunId() {
   return `run_${ulid()}`;
@@ -5646,6 +5698,7 @@ async function spawnElectronApp(params) {
   if (!childProcess.pid) {
     throw new Error("Failed to spawn electron-app process");
   }
+  const now = Date.now();
   const executionProcess = {
     runId,
     projectId,
@@ -5653,11 +5706,61 @@ async function spawnElectronApp(params) {
     runType,
     process: childProcess,
     pid: childProcess.pid,
-    startedAt: Date.now(),
+    startedAt: now,
     status: "running" /* RUNNING */,
     inputFilePath,
-    outputFilePath
+    outputFilePath,
+    capturedStdout: "",
+    capturedStderr: "",
+    hasExited: false,
+    lastOutputAt: now,
+    killedDueToInactivity: false
   };
+  childProcess.stdout?.on("data", (data) => {
+    executionProcess.capturedStdout += data.toString();
+    executionProcess.lastOutputAt = Date.now();
+  });
+  childProcess.stderr?.on("data", (data) => {
+    executionProcess.capturedStderr += data.toString();
+    executionProcess.lastOutputAt = Date.now();
+  });
+  const inactivityCheck = setInterval(() => {
+    if (executionProcess.hasExited) {
+      clearInterval(inactivityCheck);
+      return;
+    }
+    const inactiveDuration = Date.now() - executionProcess.lastOutputAt;
+    if (inactiveDuration >= INACTIVITY_TIMEOUT_MS) {
+      executionProcess.killedDueToInactivity = true;
+      executionProcess.status = "failed" /* FAILED */;
+      clearInterval(inactivityCheck);
+      try {
+        executionProcess.process.kill("SIGKILL");
+      } catch {
+      }
+    }
+  }, INACTIVITY_CHECK_INTERVAL_MS);
+  executionProcess.inactivityCheckInterval = inactivityCheck;
+  childProcess.on("close", (code, signal) => {
+    executionProcess.hasExited = true;
+    executionProcess.earlyExitInfo = {
+      code,
+      signal,
+      stdout: executionProcess.capturedStdout,
+      stderr: executionProcess.capturedStderr
+    };
+  });
+  childProcess.on("error", (error) => {
+    executionProcess.hasExited = true;
+    executionProcess.capturedStderr += `
+Spawn error: ${error.message}`;
+    executionProcess.earlyExitInfo = {
+      code: -1,
+      signal: null,
+      stdout: executionProcess.capturedStdout,
+      stderr: executionProcess.capturedStderr
+    };
+  });
   const timeoutTimer = setTimeout(() => {
     handleTimeout({ executionProcess });
   }, timeoutMs);
@@ -5669,63 +5772,107 @@ function handleTimeout(params) {
   const { executionProcess } = params;
   if (executionProcess.status === "running" /* RUNNING */) {
     executionProcess.status = "failed" /* FAILED */;
+    if (executionProcess.inactivityCheckInterval) {
+      clearInterval(executionProcess.inactivityCheckInterval);
+    }
     try {
       executionProcess.process.kill("SIGTERM");
     } catch {
     }
   }
 }
+async function handleProcessExit(params) {
+  const { executionProcess, code, stderr } = params;
+  if (executionProcess.timeoutTimer) {
+    clearTimeout(executionProcess.timeoutTimer);
+  }
+  if (executionProcess.inactivityCheckInterval) {
+    clearInterval(executionProcess.inactivityCheckInterval);
+  }
+  activeProcesses.delete(executionProcess.runId);
+  if (executionProcess.status === "cancelled" /* CANCELLED */) {
+    return {
+      success: false,
+      status: "FAILURE",
+      summary: "Execution was cancelled",
+      error: "Cancelled by user"
+    };
+  }
+  if (executionProcess.killedDueToInactivity) {
+    executionProcess.status = "failed" /* FAILED */;
+    const stderrSummary = stderr.trim().slice(0, 500);
+    return {
+      success: false,
+      status: "FAILURE",
+      summary: "Process became unresponsive",
+      error: `Process killed after ${INACTIVITY_TIMEOUT_MS / 1e3}s of inactivity (likely stuck on error dialog). ` + (stderrSummary ? `Last stderr: ${stderrSummary}` : "No stderr captured.")
+    };
+  }
+  if (code !== 0 || executionProcess.status === "failed" /* FAILED */) {
+    executionProcess.status = "failed" /* FAILED */;
+    const errorMessage = stderr || `Process exited with code ${code}`;
+    return {
+      success: false,
+      status: "FAILURE",
+      summary: "Execution failed",
+      error: code === -1 ? errorMessage : `Process exited with code ${code}. ${errorMessage}`
+    };
+  }
+  const outputData = await readTempFile(executionProcess.outputFilePath);
+  executionProcess.status = "passed" /* PASSED */;
+  return {
+    success: true,
+    status: "SUCCESS",
+    summary: "Execution completed successfully",
+    actionScript: outputData
+  };
+}
 async function waitForCompletion(params) {
   const { executionProcess } = params;
-  return new Promise((resolve2) => {
-    let stdout = "";
-    let stderr = "";
-    executionProcess.process.stdout?.on("data", (data) => {
-      stdout += data.toString();
-    });
-    executionProcess.process.stderr?.on("data", (data) => {
-      stderr += data.toString();
+  if (executionProcess.hasExited && executionProcess.earlyExitInfo) {
+    const earlyExit = executionProcess.earlyExitInfo;
+    return handleProcessExit({
+      executionProcess,
+      code: earlyExit.code,
+      stderr: earlyExit.stderr
     });
-    executionProcess.process.on("close", async (code) => {
-      if (executionProcess.timeoutTimer) {
-        clearTimeout(executionProcess.timeoutTimer);
-      }
-      activeProcesses.delete(executionProcess.runId);
-      if (executionProcess.status === "cancelled" /* CANCELLED */) {
-        resolve2({
-          success: false,
-          status: "FAILURE",
-          summary: "Execution was cancelled",
-          error: "Cancelled by user"
-        });
-        return;
+  }
+  return new Promise((resolve2) => {
+    let resolved = false;
+    const resolveOnce = (result) => {
+      if (!resolved) {
+        resolved = true;
+        resolve2(result);
       }
-      if (code !== 0 || executionProcess.status === "failed" /* FAILED */) {
-        executionProcess.status = "failed" /* FAILED */;
-        resolve2({
-          success: false,
-          status: "FAILURE",
-          summary: "Execution failed",
-          error: stderr || `Process exited with code ${code}`
-        });
-        return;
+    };
+    const checkEarlyExit = setInterval(() => {
+      if (executionProcess.hasExited && executionProcess.earlyExitInfo) {
+        clearInterval(checkEarlyExit);
+        const earlyExit = executionProcess.earlyExitInfo;
+        handleProcessExit({
+          executionProcess,
+          code: earlyExit.code,
+          stderr: earlyExit.stderr
+        }).then(resolveOnce);
       }
-      const outputData = await readTempFile(executionProcess.outputFilePath);
-      executionProcess.status = "passed" /* PASSED */;
-      resolve2({
-        success: true,
-        status: "SUCCESS",
-        summary: "Execution completed successfully",
-        actionScript: outputData
+    }, 100);
+    executionProcess.process.on("close", async (code) => {
+      clearInterval(checkEarlyExit);
+      const result = await handleProcessExit({
+        executionProcess,
+        code,
+        stderr: executionProcess.capturedStderr
       });
+      resolveOnce(result);
     });
-    executionProcess.process.on("error", (error) => {
+    executionProcess.process.on("error", async (error) => {
+      clearInterval(checkEarlyExit);
       if (executionProcess.timeoutTimer) {
         clearTimeout(executionProcess.timeoutTimer);
       }
       activeProcesses.delete(executionProcess.runId);
       executionProcess.status = "failed" /* FAILED */;
-      resolve2({
+      resolveOnce({
         success: false,
         status: "FAILURE",
         summary: "Execution error",
@@ -5998,6 +6145,9 @@ function cancelExecution(params) {
   if (executionProcess.timeoutTimer) {
     clearTimeout(executionProcess.timeoutTimer);
   }
+  if (executionProcess.inactivityCheckInterval) {
+    clearInterval(executionProcess.inactivityCheckInterval);
+  }
   try {
     executionProcess.process.kill("SIGTERM");
   } catch {
@@ -7621,6 +7771,6 @@ function isLocalOnlyTool(toolName) {
   return localOnlyTools.includes(toolName);
 }
 
-export { __export, createApiKeyWithToken, createChildLogger, createUnifiedMcpServer, deleteCredentials, getAuthStatus, getCallerCredentials, getConfig, getCredentialsFilePath, getDataDir, getDownloadBaseUrl, getElectronAppDir, getElectronAppVersion, getLocalQaTools, getLogger, getQaTools, getValidCredentials, isCredentialsExpired, isElectronAppInstalled, loadCredentials, local_qa_exports, openBrowserUrl, performLogin, performLogout, pollDeviceCode, qa_exports, registerTools, resetConfig, resetLogger, saveCredentials, server_exports, startDeviceCodeFlow, startStdioServer, toolRequiresAuth };
-//# sourceMappingURL=chunk-6DQWAMGJ.js.map
-//# sourceMappingURL=chunk-6DQWAMGJ.js.map
+export { __export, __require, createApiKeyWithToken, createChildLogger, createUnifiedMcpServer, deleteCredentials, getAuthStatus, getBundledElectronAppVersion, getCallerCredentials, getConfig, getCredentialsFilePath, getDataDir, getDownloadBaseUrl, getElectronAppChecksums, getElectronAppDir, getElectronAppVersion, getElectronAppVersionSource, getLocalQaTools, getLogger, getQaTools, getValidCredentials, isCredentialsExpired, isElectronAppInstalled, loadCredentials, local_qa_exports, openBrowserUrl, performLogin, performLogout, pollDeviceCode, qa_exports, registerTools, resetConfig, resetLogger, saveCredentials, server_exports, startDeviceCodeFlow, startStdioServer, toolRequiresAuth };
+//# sourceMappingURL=chunk-CL6YSSTI.js.map
+//# sourceMappingURL=chunk-CL6YSSTI.js.map