@muggleai/works 4.7.0 → 4.8.1

package/README.md

@@ -55,7 +55,9 @@ This installs:
 npm install -g @muggleai/works
 ```
 
-Then configure your MCP client:
+For Cursor, that's it — the install automatically configures `~/.cursor/mcp.json` and syncs `muggle-*` skills to `~/.cursor/skills/`. Just restart Cursor.
+
+For other MCP clients, add this to your client's config:
 
 ```json
 {
@@ -71,7 +73,7 @@ Then configure your MCP client:
 }
 ```
 
-`npm install` also syncs `muggle-*` skills to `~/.cursor/skills/` for Cursor discovery. Claude slash commands are plugin-managed, so update those with `/plugin update muggleai@muggle-works`.
+Claude slash commands are plugin-managed, so update those with `/plugin update muggleai@muggle-works`.
 
 ### 2. Verify
 
@@ -519,7 +521,7 @@ muggle-ai-works/
 │   ├── verify-plugin-marketplace.mjs  # Validates plugin/marketplace consistency
 │   ├── verify-compatibility-contracts.mjs # Validates long-term surface contracts
 │   ├── verify-upgrade-experience.mjs  # Validates in-place upgrade behavior
-│   └── postinstall.mjs      #   npm postinstall (Electron app download)
+│   └── postinstall.mjs      #   npm postinstall (Electron app download, Cursor MCP config, skills sync)
 │
 ├── config/compatibility/     # Contract baselines (CLI/MCP/plugin/skills)
 ├── bin/                     # CLI entrypoint (muggle.js → dist/cli.js)
@@ -554,12 +556,7 @@ CI/CD and publishing
 | `verify-end-user-upgrade.yml` | Weekly + manual | Existing-user upgrade validation (cleanup + re-download + health checks) |
 | `publish-works-to-npm.yml` | Tag `v*` or manual  | Verify (including release checksums), audit, smoke-install, publish to npm |
 
-
-```bash
-git tag v<version> && git push --tags
-# publish-works-to-npm.yml handles the rest
-```
-
+**Publishing `@muggleai/works`:** use the repo-level skill **`plugin/skills/muggle-works-npm-release/SKILL.md`** (bump + `pnpm run sync:versions`, local verify, `chore(release)` PR, merge, then `workflow_dispatch` with an explicit `version`). Do not rely on tagging alone while `package.json` / marketplace manifests on `master` are still old — CI can publish a version that does not match the checked-in manifests. Tag `v*` push remains a valid workflow trigger when it matches the merged release commit.
 
 Release tag strategy
 

package/dist/{chunk-HDEZDEM6.js → chunk-44I5ROCB.js}

@@ -2211,6 +2211,9 @@ async function executeElectronAppAsync(params) {
   if (params.showUi) {
     spawnArgs.push("--show-ui");
   }
+  if (params.freshSession) {
+    spawnArgs.push("--fresh-session");
+  }
   logger4.info("Spawning electron-app for local execution", {
     runId: params.runId,
     mode,
@@ -2359,7 +2362,8 @@ async function executeTestGeneration(params) {
         scriptFilePath: inputFilePath,
         authFilePath,
         timeoutMs,
-        showUi: params.showUi
+        showUi: params.showUi,
+        freshSession: params.freshSession
       });
       const completedAt = Date.now();
       const executionTimeMs = completedAt - startedAt;
@@ -2407,9 +2411,11 @@ ${executionResult.stderr}`;
           `Generated script does not contain a valid 'steps' array. File: ${generatedScriptPath}`
         );
       }
+      const generatedSummaryStep = generatedScript.summaryStep;
       storage.updateTestScript(localTestScript.id, {
         status: "generated",
-        actionScript: generatedSteps
+        actionScript: generatedSteps,
+        summaryStep: generatedSummaryStep
       });
       const artifactsDir = await moveResultsToArtifacts({
         runId,
@@ -2503,7 +2509,8 @@ async function executeReplay(params) {
         scriptFilePath: inputFilePath,
         authFilePath,
         timeoutMs,
-        showUi: params.showUi
+        showUi: params.showUi,
+        freshSession: params.freshSession
       });
       const completedAt = Date.now();
       const executionTimeMs = completedAt - startedAt;
@@ -3237,6 +3244,12 @@ var WorkflowStartTestScriptGenerationInputSchema = z.object({
   expectedResult: z.string().min(1).describe("Expected result"),
   workflowParams: WorkflowParamsSchema
 });
+var WorkflowStartTestScriptGenerationBulkInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID (UUID)"),
+  name: z.string().min(1).describe("Workflow name"),
+  testCaseIds: z.array(IdSchema).optional().describe("Optional: targeted test case UUIDs to generate scripts for; when absent generates for all eligible test cases in the project"),
+  workflowParams: WorkflowParamsSchema
+});
 var WorkflowGetLatestScriptGenByTestCaseInputSchema = z.object({
   testCaseId: IdSchema.describe("Test case ID (UUID)")
 });
@@ -4206,6 +4219,25 @@ var workflowTools = [
       };
     }
   },
+  {
+    name: "muggle-remote-workflow-start-test-script-generation-bulk",
+    description: "Start a bulk test script generation workflow to generate scripts for multiple test cases in a single request.",
+    inputSchema: WorkflowStartTestScriptGenerationBulkInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/workflow/test-script/test-script-generation/bulk`,
+        body: {
+          projectId: data.projectId,
+          name: data.name,
+          ...data.testCaseIds && { testCaseIds: data.testCaseIds },
+          ...data.workflowParams && { workflowParams: data.workflowParams }
+        },
+        timeoutMs: getWorkflowTimeoutMs()
+      };
+    }
+  },
   {
     name: "muggle-remote-wf-get-ts-gen-latest-run",
     description: "Get the latest run status for a test script generation workflow runtime.",
@@ -5144,14 +5176,6 @@ __export(local_exports, {
   executeTool: () => executeTool,
   getTool: () => getTool
 });
-var AuthLoginInputSchema2 = z.object({
-  waitForCompletion: z.boolean().optional().describe("Whether to wait for browser login completion before returning. Default: true"),
-  timeoutMs: z.number().int().positive().min(1e3).max(9e5).optional().describe("Maximum time to wait for login completion in milliseconds. Default: 120000")
-});
-var AuthPollInputSchema2 = z.object({
-  deviceCode: z.string().optional().describe("Device code from the login response. Optional if a login was recently started.")
-});
-var EmptyInputSchema2 = z.object({});
 var TestCaseDetailsSchema = z.object({
   /** Cloud test case ID. */
   id: MuggleEntityIdSchema.describe("Cloud test case ID (UUID)"),
@@ -5198,7 +5222,9 @@ var ExecuteTestGenerationInputSchema = z.object({
   /** Optional timeout. */
   timeoutMs: z.number().int().positive().optional().describe("Timeout in milliseconds (default: 300000 = 5 min)"),
   /** Show the electron-app UI during execution. Default: visible window. Pass false to run headless. */
-  showUi: z.boolean().optional().describe("Show the electron-app UI during generation. Defaults to visible; pass false to run headless.")
+  showUi: z.boolean().optional().describe("Show the electron-app UI during generation. Defaults to visible; pass false to run headless."),
+  /** Clear all session storage (cookies, localStorage, etc.) before execution. Use for test cases that require a clean browser state, such as registration, login, or cookie consent flows. */
+  freshSession: z.boolean().optional().describe("Clear all session storage (cookies, localStorage, etc.) before execution. Use for test cases that require a clean browser state \u2014 e.g. registration, login, or cookie consent flows. Default: false.")
 });
 var ExecuteReplayInputSchema = z.object({
   /** Test script metadata from muggle-remote-test-script-get. */
@@ -5210,7 +5236,9 @@ var ExecuteReplayInputSchema = z.object({
   /** Optional timeout. */
   timeoutMs: z.number().int().positive().optional().describe("Timeout in milliseconds (default: 180000 = 3 min)"),
   /** Show the electron-app UI during execution. Default: visible window. Pass false to run headless. */
-  showUi: z.boolean().optional().describe("Show the electron-app UI during replay. Defaults to visible; pass false to run headless.")
+  showUi: z.boolean().optional().describe("Show the electron-app UI during replay. Defaults to visible; pass false to run headless."),
+  /** Clear all session storage (cookies, localStorage, etc.) before execution. Use for test cases that require a clean browser state, such as registration, login, or cookie consent flows. */
+  freshSession: z.boolean().optional().describe("Clear all session storage (cookies, localStorage, etc.) before execution. Use for test cases that require a clean browser state \u2014 e.g. registration, login, or cookie consent flows. Default: false.")
 });
 var CancelExecutionInputSchema = z.object({
   runId: MuggleEntityIdSchema.describe("Run ID (UUID) to cancel")
@@ -5238,6 +5266,7 @@ var ListSessionsInputSchema = z.object({
 var CleanupSessionsInputSchema = z.object({
   max_age_days: z.number().int().min(0).optional().describe("Maximum age of sessions to keep (in days). Sessions older than this will be deleted. Defaults to 30.")
 });
+var EmptyInputSchema2 = z.object({});
 
 // packages/mcps/src/mcp/tools/local/tool-registry.ts
 function createChildLogger2(correlationId) {
@@ -5462,7 +5491,8 @@ var executeTestGenerationTool = {
         testCase: input.testCase,
         localUrl: input.localUrl,
         timeoutMs: input.timeoutMs,
-        showUi
+        showUi,
+        freshSession: input.freshSession
       });
       const content = [
         "## Test Generation " + (result.status === "passed" ? "Successful" : "Failed"),
@@ -5501,7 +5531,8 @@ var executeReplayTool = {
         actionScript: input.actionScript,
         localUrl: input.localUrl,
         timeoutMs: input.timeoutMs,
-        showUi
+        showUi,
+        freshSession: input.freshSession
       });
       const content = [
         "## Test Replay " + (result.status === "passed" ? "Successful" : "Failed"),
@@ -5629,6 +5660,7 @@ var publishTestScriptTool = {
               uploadedAt
             },
             actionScript: testScript.actionScript,
+            summaryStep: testScript.summaryStep,
             status: runResult.status === "passed" ? "passed" : "failed",
             executionTimeMs: runResult.executionTimeMs,
             errorMessage: runResult.errorMessage
@@ -5796,6 +5828,7 @@ __export(e2e_exports2, {
   WorkflowMemoryParamsSchema: () => WorkflowMemoryParamsSchema,
   WorkflowParamsSchema: () => WorkflowParamsSchema,
   WorkflowStartTestCaseDetectionInputSchema: () => WorkflowStartTestCaseDetectionInputSchema,
+  WorkflowStartTestScriptGenerationBulkInputSchema: () => WorkflowStartTestScriptGenerationBulkInputSchema,
   WorkflowStartTestScriptGenerationInputSchema: () => WorkflowStartTestScriptGenerationInputSchema,
   WorkflowStartTestScriptReplayBulkInputSchema: () => WorkflowStartTestScriptReplayBulkInputSchema,
   WorkflowStartTestScriptReplayInputSchema: () => WorkflowStartTestScriptReplayInputSchema,
@@ -5821,8 +5854,6 @@ function getQaTools() {
 // packages/mcps/src/mcp/local/index.ts
 var local_exports2 = {};
 __export(local_exports2, {
-  AuthLoginInputSchema: () => AuthLoginInputSchema2,
-  AuthPollInputSchema: () => AuthPollInputSchema2,
   AuthService: () => AuthService,
   CancelExecutionInputSchema: () => CancelExecutionInputSchema,
   CleanupSessionsInputSchema: () => CleanupSessionsInputSchema,

package/dist/{chunk-SMRMPHDD.js → chunk-OMLNCNSZ.js}

@@ -1,4 +1,4 @@
-import { __export, getLogger, getConfig, createChildLogger, buildElectronAppReleaseAssetUrl, getAuthService, hasApiKey, getElectronAppVersion, getElectronAppDir, getPlatformKey, isElectronAppInstalled, getElectronAppChecksums, getChecksumForPlatform, verifyFileChecksum, calculateFileChecksum, getQaTools, getLocalQaTools, performLogout, performLogin, toolRequiresAuth, getCallerCredentials, getDataDir, getBundledElectronAppVersion, getElectronAppVersionSource, getCredentialsFilePath, buildElectronAppChecksumsUrl, __require } from './chunk-HDEZDEM6.js';
+import { __export, getLogger, getConfig, createChildLogger, buildElectronAppReleaseAssetUrl, getAuthService, hasApiKey, getElectronAppVersion, getElectronAppDir, getPlatformKey, isElectronAppInstalled, getElectronAppChecksums, getChecksumForPlatform, verifyFileChecksum, calculateFileChecksum, getQaTools, getLocalQaTools, performLogout, performLogin, toolRequiresAuth, getCallerCredentials, getDataDir, getBundledElectronAppVersion, getElectronAppVersionSource, getCredentialsFilePath, buildElectronAppChecksumsUrl, __require } from './chunk-44I5ROCB.js';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { v4 } from 'uuid';
@@ -6,12 +6,12 @@ import { z, ZodError } from 'zod';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import * as fs from 'fs';
 import { readFileSync, existsSync, rmSync, mkdirSync, readdirSync, createWriteStream, writeFileSync, statSync } from 'fs';
-import * as path from 'path';
+import * as path4 from 'path';
 import { dirname, resolve, join } from 'path';
 import { fileURLToPath } from 'url';
 import { Command } from 'commander';
 import axios from 'axios';
-import { platform, arch, homedir } from 'os';
+import { platform, homedir, arch } from 'os';
 import { execFile } from 'child_process';
 import { pipeline } from 'stream/promises';
 
@@ -486,7 +486,7 @@ function renderResultSummary(test, projectId) {
     lines.push(`**Error:** \`${safeInlineCode(test.error)}\``);
   }
   lines.push(`**Steps:** ${test.steps.length}`);
-  lines.push(`[View on Muggle AI dashboard \u2192](${dashboardUrl})`);
+  lines.push(`[View steps on Muggle AI \u2192](${dashboardUrl})`);
   return lines;
 }
 function renderBody(report, opts) {
@@ -686,7 +686,7 @@ async function resolveGsScreenshotUrls(report, opts) {
     if (gsUrls.length === 0) {
       return report;
     }
-    const mcps = await import('./src-TX2KXI26.js');
+    const mcps = await import('./src-ZRUONWKV.js');
     const credentials = await mcps.getCallerCredentialsAsync();
     if (!credentials.bearerToken && !credentials.apiKey) {
       stderrWrite(
@@ -807,13 +807,13 @@ var CURSOR_SKILLS_SUBDIR = "skills";
 var MUGGLE_SKILL_PREFIX = "muggle";
 var INSTALL_MANIFEST_FILE = "install-manifest.json";
 function getElectronAppBaseDir() {
-  return path.join(getDataDir(), ELECTRON_APP_DIR);
+  return path4.join(getDataDir(), ELECTRON_APP_DIR);
 }
 function getCursorSkillsDir() {
-  return path.join(homedir(), CURSOR_SKILLS_DIR, CURSOR_SKILLS_SUBDIR);
+  return path4.join(homedir(), CURSOR_SKILLS_DIR, CURSOR_SKILLS_SUBDIR);
 }
 function getInstallManifestPath() {
-  return path.join(getDataDir(), INSTALL_MANIFEST_FILE);
+  return path4.join(getDataDir(), INSTALL_MANIFEST_FILE);
 }
 function readInstallManifest() {
   const manifestPath = getInstallManifestPath();
@@ -851,7 +851,7 @@ function listObsoleteSkills() {
       if (manifestSkills.has(entry.name)) {
         continue;
       }
-      const skillPath = path.join(skillsDir, entry.name);
+      const skillPath = path4.join(skillsDir, entry.name);
       const sizeBytes = getDirectorySize(skillPath);
       obsoleteSkills.push({
         name: entry.name,
@@ -897,7 +897,7 @@ function getDirectorySize(dirPath) {
   try {
     const entries = readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path.join(dirPath, entry.name);
+      const fullPath = path4.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += getDirectorySize(fullPath);
       } else if (entry.isFile()) {
@@ -950,7 +950,7 @@ function listInstalledVersions() {
       if (!/^\d+\.\d+\.\d+$/.test(entry.name)) {
         continue;
       }
-      const versionPath = path.join(baseDir, entry.name);
+      const versionPath = path4.join(baseDir, entry.name);
       const sizeBytes = getDirectorySize(versionPath);
       versions.push({
         version: entry.name,
@@ -1106,11 +1106,11 @@ function getExpectedExecutablePath(versionDir) {
   const os = platform();
   switch (os) {
     case "darwin":
-      return path.join(versionDir, "MuggleAI.app", "Contents", "MacOS", "MuggleAI");
+      return path4.join(versionDir, "MuggleAI.app", "Contents", "MacOS", "MuggleAI");
     case "win32":
-      return path.join(versionDir, "MuggleAI.exe");
+      return path4.join(versionDir, "MuggleAI.exe");
     case "linux":
-      return path.join(versionDir, "MuggleAI");
+      return path4.join(versionDir, "MuggleAI");
     default:
       throw new Error(`Unsupported platform: ${os}`);
   }
@@ -1119,7 +1119,7 @@ function verifyElectronAppInstallation() {
   const version = getElectronAppVersion();
   const versionDir = getElectronAppDir(version);
   const executablePath = getExpectedExecutablePath(versionDir);
-  const metadataPath = path.join(versionDir, ".install-metadata.json");
+  const metadataPath = path4.join(versionDir, ".install-metadata.json");
   const result = {
     valid: false,
     versionDir,
@@ -1326,7 +1326,7 @@ function runDiagnostics() {
     name: "Cursor MCP Config",
     passed: cursorMcpConfigValidationResult.passed,
     description: cursorMcpConfigValidationResult.description,
-    suggestion: "Re-run npm install -g @muggleai/works to refresh ~/.cursor/mcp.json"
+    suggestion: "Run 'muggle setup' to configure ~/.cursor/mcp.json"
   });
   return results;
 }
@@ -1640,11 +1640,11 @@ function getExpectedExecutablePath2(versionDir) {
   const os = platform();
   switch (os) {
     case "darwin":
-      return path.join(versionDir, "MuggleAI.app", "Contents", "MacOS", "MuggleAI");
+      return path4.join(versionDir, "MuggleAI.app", "Contents", "MacOS", "MuggleAI");
     case "win32":
-      return path.join(versionDir, "MuggleAI.exe");
+      return path4.join(versionDir, "MuggleAI.exe");
     case "linux":
-      return path.join(versionDir, "MuggleAI");
+      return path4.join(versionDir, "MuggleAI");
     default:
       throw new Error(`Unsupported platform: ${os}`);
   }
@@ -1740,10 +1740,43 @@ function cleanupFailedInstall(versionDir) {
     }
   }
 }
+function upsertCursorMcpConfig() {
+  const cursorMcpConfigPath = path4.join(homedir(), ".cursor", "mcp.json");
+  const cursorDir = path4.join(homedir(), ".cursor");
+  let config = {};
+  if (existsSync(cursorMcpConfigPath)) {
+    try {
+      const raw = readFileSync(cursorMcpConfigPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        console.log("Warning: ~/.cursor/mcp.json has unexpected shape, skipping MCP config upsert.");
+        return;
+      }
+      config = parsed;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log("Warning: ~/.cursor/mcp.json is invalid JSON, skipping MCP config upsert.");
+      console.log(`  Parse error: ${message}`);
+      return;
+    }
+  }
+  if (!config.mcpServers || typeof config.mcpServers !== "object") {
+    config.mcpServers = {};
+  }
+  config.mcpServers.muggle = {
+    command: "muggle",
+    args: ["serve"]
+  };
+  mkdirSync(cursorDir, { recursive: true });
+  writeFileSync(cursorMcpConfigPath, `${JSON.stringify(config, null, 2)}
+`, "utf-8");
+  console.log(`Cursor MCP config updated at ${cursorMcpConfigPath}`);
+}
 async function setupCommand(options) {
   const version = getElectronAppVersion();
   const versionDir = getElectronAppDir(version);
   const platformKey = getPlatformKey();
+  upsertCursorMcpConfig();
   if (!options.force && isElectronAppInstalled()) {
     console.log(`Electron app v${version} is already installed at ${versionDir}`);
     console.log("Use --force to re-download.");
@@ -1761,7 +1794,7 @@ async function setupCommand(options) {
       rmSync(versionDir, { recursive: true, force: true });
     }
     mkdirSync(versionDir, { recursive: true });
-    const tempFile = path.join(versionDir, binaryName);
+    const tempFile = path4.join(versionDir, binaryName);
     await downloadWithRetry(downloadUrl, tempFile);
     console.log("Download complete, verifying checksum...");
     const checksums = getElectronAppChecksums();
@@ -1797,7 +1830,7 @@ The archive may be corrupted or in an unexpected format.`
       );
     }
     const executableChecksum = await calculateFileChecksum(executablePath);
-    const metadataPath = path.join(versionDir, INSTALL_METADATA_FILE_NAME);
+    const metadataPath = path4.join(versionDir, INSTALL_METADATA_FILE_NAME);
     writeInstallMetadata({
       metadataPath,
       version,
@@ -1839,7 +1872,7 @@ function extractVersionFromTag(tag) {
   return match ? match[1] : null;
 }
 function getVersionOverridePath() {
-  return path.join(getDataDir(), VERSION_OVERRIDE_FILE);
+  return path4.join(getDataDir(), VERSION_OVERRIDE_FILE);
 }
 function getEffectiveElectronAppVersion() {
   const overridePath = getVersionOverridePath();
@@ -1927,11 +1960,11 @@ function getExpectedExecutablePath3(versionDir) {
   const os = platform();
   switch (os) {
     case "darwin":
-      return path.join(versionDir, "MuggleAI.app", "Contents", "MacOS", "MuggleAI");
+      return path4.join(versionDir, "MuggleAI.app", "Contents", "MacOS", "MuggleAI");
     case "win32":
-      return path.join(versionDir, "MuggleAI.exe");
+      return path4.join(versionDir, "MuggleAI.exe");
     case "linux":
-      return path.join(versionDir, "MuggleAI");
+      return path4.join(versionDir, "MuggleAI");
     default:
       throw new Error(`Unsupported platform: ${os}`);
   }
@@ -2043,7 +2076,7 @@ async function downloadAndInstall(version, downloadUrl, checksum) {
   if (!response.ok) {
     throw new Error(`Download failed: ${response.status} ${response.statusText}`);
   }
-  const tempFile = path.join(versionDir, binaryName);
+  const tempFile = path4.join(versionDir, binaryName);
   const fileStream = createWriteStream(tempFile);
   if (!response.body) {
     throw new Error("No response body");
@@ -2085,7 +2118,7 @@ The archive may be corrupted or in an unexpected format.`
     );
   }
   const executableChecksum = await calculateFileChecksum(executablePath);
-  const metadataPath = path.join(versionDir, INSTALL_METADATA_FILE_NAME2);
+  const metadataPath = path4.join(versionDir, INSTALL_METADATA_FILE_NAME2);
   writeInstallMetadata2({
     metadataPath,
     version,

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { runCli } from './chunk-SMRMPHDD.js';
-import './chunk-HDEZDEM6.js';
+import { runCli } from './chunk-OMLNCNSZ.js';
+import './chunk-44I5ROCB.js';
 
 // src/cli/main.ts
 runCli().catch((error) => {

package/dist/index.js

@@ -1,2 +1,2 @@
-export { src_exports as commands, createUnifiedMcpServer, server_exports as server } from './chunk-SMRMPHDD.js';
-export { createChildLogger, e2e_exports as e2e, getConfig, getLocalQaTools, getLogger, getQaTools, local_exports as localQa, mcp_exports as mcp, e2e_exports as qa, src_exports as shared } from './chunk-HDEZDEM6.js';
+export { src_exports as commands, createUnifiedMcpServer, server_exports as server } from './chunk-OMLNCNSZ.js';
+export { createChildLogger, e2e_exports as e2e, getConfig, getLocalQaTools, getLogger, getQaTools, local_exports as localQa, mcp_exports as mcp, e2e_exports as qa, src_exports as shared } from './chunk-44I5ROCB.js';

package/dist/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "muggle",
   "description": "Run real-browser end-to-end (E2E) acceptance tests on your web app from any AI coding agent. Generate test scripts from plain English, replay them on localhost, capture screenshots, and validate user flows like signup, checkout, and dashboards. Works across Claude Code, Cursor, Codex, and Windsurf.",
-  "version": "4.7.0",
+  "version": "4.8.1",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/dist/plugin/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "muggle",
   "displayName": "Muggle AI",
   "description": "Ship quality products with AI-powered end-to-end (E2E) acceptance testing that validates your web app like a real user — from Claude Code and Cursor to PR.",
-  "version": "4.7.0",
+  "version": "4.8.1",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/dist/plugin/README.md

@@ -15,7 +15,7 @@ For npm installs:
 npm install -g @muggleai/works
 ```
 
-This updates the CLI and syncs `muggle-*` skills into `~/.cursor/skills/` for Cursor. Claude slash commands remain plugin-managed, so use `/plugin update muggleai@muggle-works` to refresh them.
+This updates the CLI, configures Cursor MCP (`~/.cursor/mcp.json`), and syncs `muggle-*` skills into `~/.cursor/skills/`. Claude slash commands remain plugin-managed, so use `/plugin update muggleai@muggle-works` to refresh them.
 
 ## Skills
 

package/dist/plugin/skills/muggle-test/SKILL.md

@@ -200,6 +200,17 @@ If nothing detected, ask as free text: "Your local app should be running. What's
 
 Before execution, fetch full test case details for all selected test cases by issuing **all** `muggle-remote-test-case-get` calls in parallel (single message, multiple tool calls).
 
+### Determine `freshSession` per test case
+
+Before executing each test case, inspect its content (title, goal, instructions, preconditions) for signals that it requires a **clean browser state** — no prior cookies, localStorage, or logged-in session. Set `freshSession: true` when the test case involves any of:
+
+- **Registration / sign-up** — creating a new account
+- **Login / authentication** — verifying the login flow itself (not a test that merely *uses* login as a prerequisite)
+- **Cookie consent / GDPR banners** — verifying first-visit consent prompts
+- **Onboarding flows** — first-time user experiences that only appear on a fresh session
+
+If none of the above apply, omit `freshSession` (defaults to `false`, preserving any existing session state). Evaluate this per test case — in a batch, some may need it and others may not.
+
 ### Run sequentially (Electron constraint)
 
 Execution itself **must** be sequential because there is only one local Electron browser. For each test case, in order:
@@ -208,6 +219,7 @@ Execution itself **must** be sequential because there is only one local Electron
    - `testCase`: Full test case object from the parallel fetch above
    - `localUrl`: User's local URL from the pre-flight question
    - `showUi`: omit (default visible) unless the user explicitly asked for headless, then pass `false`
+   - `freshSession`: `true` if the test case requires a clean browser state (see above), omit otherwise
 2. Store the returned `runId`
 
 If a generation fails, log it and continue to the next. Do not abort the batch.
@@ -231,7 +243,7 @@ Store every `viewUrl` — these are used in the next steps.
 ### Report summary
 
 ```
-Test Case                  Status    Duration   Steps   View on Muggle
+Test Case                  Status    Duration   Steps   View Steps on Muggle AI
 ─────────────────────────────────────────────────────────────────────────
 Login with valid creds     PASSED    12.3s      8       https://www.muggle-ai.com/...
 Login with invalid creds   PASSED    9.1s       6       https://www.muggle-ai.com/...

package/dist/plugin/skills/muggle-test-feature-local/SKILL.md

@@ -86,17 +86,28 @@ Remind them: local URL is only the execution target, not tied to cloud project c
 
 ### 5. Load data for the chosen path
 
+**Determine `freshSession`**
+
+Before calling either execution tool, inspect the test case content (title, goal, instructions, preconditions) for signals that the test requires a **clean browser state** — no prior cookies, localStorage, or logged-in session. Pass `freshSession: true` when the test case involves any of:
+
+- **Registration / sign-up** — creating a new account
+- **Login / authentication** — verifying the login flow itself (not a test that merely *uses* login as a prerequisite)
+- **Cookie consent / GDPR banners** — verifying first-visit consent prompts
+- **Onboarding flows** — first-time user experiences that only appear on a fresh session
+
+If none of the above apply, omit `freshSession` (defaults to `false`, preserving any existing session state).
+
 **Generate**
 
 1. `muggle-remote-test-case-get`
-2. `muggle-local-execute-test-generation` with that test case + `localUrl` (optional: `showUi: false` for headless — defaults to visible; **`timeoutMs`** — see below)
+2. `muggle-local-execute-test-generation` with that test case + `localUrl` (optional: `showUi: false` for headless — defaults to visible; **`freshSession`** — see above; **`timeoutMs`** — see below)
 
 **Replay**
 
 1. `muggle-remote-test-script-get` — note `actionScriptId`
 2. `muggle-remote-action-script-get` with that id — full `actionScript`
    **Use the API response as-is.** Do not edit, shorten, or rebuild `actionScript`; replay needs full `label` paths for element lookup.
-3. `muggle-local-execute-replay` with `testScript`, `actionScript`, `localUrl` (optional: `showUi: false` for headless — defaults to visible; **`timeoutMs`** — see below)
+3. `muggle-local-execute-replay` with `testScript`, `actionScript`, `localUrl` (optional: `showUi: false` for headless — defaults to visible; **`freshSession`** — see above; **`timeoutMs`** — see below)
 
 ### Local execution timeout (`timeoutMs`)
 

package/dist/plugin/skills/muggle-test-regenerate-missing/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: muggle-test-regenerate-missing
-description: "Bulk-regenerate test scripts for every test case in a Muggle AI project that doesn't currently have an active script. Scans the project, finds test cases stuck in DRAFT or GENERATION_PENDING (no usable script attached), shows the user the list, and on approval kicks off remote test script generation for each one in parallel via the Muggle cloud. Use this skill whenever the user asks to 'regenerate missing scripts', 'fill in missing test scripts', 'generate scripts for test cases without one', 'regen all the test cases that don't have scripts', 'rebuild scripts for stale test cases', 'fix test cases with no script', 'bulk regenerate', or any phrasing that means 'kick off script generation across a project for the cases that need it'. Triggers on: 'regenerate missing test scripts', 'generate scripts for all empty test cases', 'fill the gaps in my test scripts', 'bulk test script regen', 'all my test cases without active scripts'. This is the go-to skill for project-wide script catch-up — it handles discovery, filtering, confirmation, and remote workflow dispatch end-to-end."
+description: "Bulk-regenerate test scripts for every test case in a Muggle AI project that doesn't currently have an active script. Scans the project, finds test cases stuck in DRAFT or GENERATION_PENDING (no usable script attached), shows the user the list, and on approval kicks off bulk remote test script generation via the Muggle cloud. Use this skill whenever the user asks to 'regenerate missing scripts', 'fill in missing test scripts', 'generate scripts for test cases without one', 'regen all the test cases that don't have scripts', 'rebuild scripts for stale test cases', 'fix test cases with no script', 'bulk regenerate', or any phrasing that means 'kick off script generation across a project for the cases that need it'. Triggers on: 'regenerate missing test scripts', 'generate scripts for all empty test cases', 'fill the gaps in my test scripts', 'bulk test script regen', 'all my test cases without active scripts'. This is the go-to skill for project-wide script catch-up — it handles discovery, filtering, confirmation, and remote workflow dispatch end-to-end."
 ---
 
 # Muggle Test — Regenerate Missing Test Scripts
@@ -116,27 +116,22 @@ After selection, call `AskQuestion` once more for a final confirmation:
 
 Only proceed after the user picks "Yes".
 
-### Step 6 — Dispatch Remote Generations
+### Step 6 — Dispatch Remote Generations (Bulk)
 
-For each selected test case, in order:
+Send a single bulk request instead of dispatching one workflow per test case:
 
-1. Call `muggle-remote-test-case-get` with `testCaseId` to fetch the full record (the list endpoint returns a slim shape; generation needs `goal`, `precondition`, `instructions`, `expectedResult`, `url`).
-2. Call `muggle-remote-workflow-start-test-script-generation` with:
+1. Call `muggle-remote-workflow-start-test-script-generation-bulk` with:
    - `projectId` — from Step 2
-   - `useCaseId` — from the test case
-   - `testCaseId` — the test case being regenerated
-   - `name` — `"muggle-test-regenerate-missing: {test case title}"` (so it's easy to find this batch later in the dashboard)
-   - `url` — prefer the test case's own `url` if set, else the project URL from Step 2
-   - `goal`, `precondition`, `instructions`, `expectedResult` — straight from the test case. If `precondition` is empty, pass `"None"` (the schema requires a non-empty string).
-3. Capture the returned workflow runtime ID and store it alongside the test case.
+   - `name` — `"muggle-test-regenerate-missing: bulk ({count} test cases)"` where `{count}` is the number of selected test cases
+   - `testCaseIds` — array of all selected test case IDs from Step 5
+2. The backend handles looking up full test case details (goal, precondition, instructions, expectedResult, url), so there is no need to call `muggle-remote-test-case-get` per test case.
+3. Parse the response to get the `items` array with per-test-case status. Each item contains the test case ID, dispatch status, and (when successful) the workflow runtime ID.
 
-**Failure handling:** if a single dispatch fails (validation error, server error, missing field), log it inline, mark the test case as `dispatch_failed`, and continue to the next one. Do not abort the whole batch — partial progress is more useful than nothing.
-
-**Pacing:** Muggle's cloud handles parallelism on its side, so you don't need to throttle. Just dispatch sequentially as fast as the API will accept them.
+**Failure handling:** the bulk API returns per-item status in the response `items` array. Individual test cases may fail (validation error, missing field, etc.) while others succeed. Surface failures in the Step 7 report — partial progress beats no progress.
 
 ### Step 7 — Report
 
-After all dispatches are done, print a summary table:
+After the bulk dispatch returns, build a summary table from the response `items` array. Each item contains a test case ID, dispatch status, and (when successful) a workflow runtime ID. Cross-reference with the test case list from Step 3 to fill in titles and use case names:
 
 ```
 Test Case                          Use Case             Prev Status       Dispatch       Runtime
@@ -149,7 +144,7 @@ Apply expired coupon               Checkout Flow        GENERATION_PEND.  ❌ fa
 Total: 17 dispatched | 16 started | 1 failed
 ```
 
-For failures: include a one-line error excerpt and (where possible) a hint at the cause (e.g., "missing instructions field — edit the test case in the dashboard, then re-run this skill").
+For failures: include a one-line error excerpt from the item's error field and (where possible) a hint at the cause (e.g., "missing instructions field — edit the test case in the dashboard, then re-run this skill").
 
 ### Step 8 — Open the Dashboard
 
@@ -183,8 +178,7 @@ Add item to cart         rt-ghi789   COMPLETED   12
 | Auth | `muggle-remote-auth-status`, `muggle-remote-auth-login`, `muggle-remote-auth-poll` |
 | Project | `muggle-remote-project-list`, `muggle-remote-project-create` |
 | Scan | `muggle-remote-test-case-list` (paginated) |
-| Detail | `muggle-remote-test-case-get` |
-| Dispatch | `muggle-remote-workflow-start-test-script-generation` |
+| Dispatch | `muggle-remote-workflow-start-test-script-generation-bulk` |
 | Status (optional) | `muggle-remote-wf-get-ts-gen-latest-run`, `muggle-remote-wf-get-latest-ts-gen-by-tc` |
 | Browser | `open` (shell command) |
 
@@ -193,9 +187,8 @@ Add item to cart         rt-ghi789   COMPLETED   12
 - **The user MUST select the project** — present projects via `AskQuestion`, never infer from cwd, repo name, or URL guesses.
 - **The user MUST approve which test cases to regenerate** — show the candidates via `AskQuestion`, let them deselect, then confirm again before any dispatch. Bulk-regenerating without approval can waste meaningful workflow budget.
 - **Default filter is `DRAFT` + `GENERATION_PENDING`** — never include `GENERATING`, `ACTIVE`, `DEPRECATED`, `ARCHIVED`, `REPLAYING`, or `REPLAY_PENDING` unless the user explicitly says so. `GENERATING` already has a workflow in flight and dispatching another races against it. `ACTIVE` test cases already have working scripts. The rest reflect deliberate user decisions or in-flight replays the skill should not interfere with.
-- **Use `muggle-remote-test-case-get` before each dispatch** — the list endpoint returns a slim shape and generation needs the full payload.
-- **Failures don't abort the batch** — log and continue, then surface them at the end. Partial progress beats no progress.
-- **Never throttle artificially** — dispatch sequentially as fast as the API accepts. Muggle's cloud handles parallelism.
+- **Use the bulk endpoint for dispatch** — call `muggle-remote-workflow-start-test-script-generation-bulk` once with all selected test case IDs rather than dispatching one-by-one. The backend resolves full test case details internally.
+- **Failures don't abort the batch** — the bulk API returns per-item status. Surface failures in the report. Partial progress beats no progress.
 - **Open the dashboard, don't poll by default** — the runs page is the canonical view of progress. Only poll if the user explicitly asks.
 - **Use `AskQuestion` for every selection** — never ask the user to type a number.
 - **Can be invoked at any state** — if the user already has a project chosen in conversation context, skip Step 2 and go straight to scanning.