@muggleai/works 4.4.0 → 4.5.0

package/README.md

@@ -42,6 +42,7 @@ This installs:
 - `/muggle:muggle-do` — autonomous dev pipeline (requirements to PR)
 - `/muggle:muggle-test` — change-driven E2E acceptance testing (local or remote, with PR posting)
 - `/muggle:muggle-test-feature-local` — local quick E2E acceptance testing
+- `/muggle:muggle-test-regenerate-missing` — bulk-regenerate test scripts for every test case that has no active script
 - `/muggle:muggle-status` — health check for muggle-works plugins (Electron app, MCP server, and auth)
 - `/muggle:muggle-repair` — diagnose and fix broken installation
 - `/muggle:muggle-upgrade` — update to the latest version
@@ -246,24 +247,40 @@ Project Management (muggle-remote-project-*)
 Use Cases (muggle-remote-use-case-*)
 
 
-| Tool                                         | Purpose                      |
-| -------------------------------------------- | ---------------------------- |
-| `muggle-remote-use-case-list`                | List use cases               |
-| `muggle-remote-use-case-create-from-prompts` | Create from natural language |
-| `muggle-remote-use-case-prompt-preview`      | Preview before creating      |
-| `muggle-remote-use-case-update-from-prompt`  | Regenerate from new prompt   |
+| Tool                                           | Purpose                                                  |
+| ---------------------------------------------- | -------------------------------------------------------- |
+| `muggle-remote-use-case-list`                  | List use cases                                           |
+| `muggle-remote-use-case-create`                | Persist a fully-specified use case (no LLM)              |
+| `muggle-remote-use-case-create-from-prompts`   | Create from natural language                             |
+| `muggle-remote-use-case-prompt-preview`        | Preview before creating                                  |
+| `muggle-remote-use-case-update-from-prompt`    | Regenerate from new prompt                               |
+| `muggle-remote-use-case-bulk-preview-submit`   | Async batch-preview via OpenAI Batch API (~50% cheaper)  |
 
 
 Test Cases (muggle-remote-test-case-*)
 
 
-| Tool                                           | Purpose               |
-| ---------------------------------------------- | --------------------- |
-| `muggle-remote-test-case-list`                 | List all test cases   |
-| `muggle-remote-test-case-list-by-use-case`     | List by use case      |
-| `muggle-remote-test-case-get`                  | Get test case details |
-| `muggle-remote-test-case-create`               | Create test case      |
-| `muggle-remote-test-case-generate-from-prompt` | Generate from prompt  |
+| Tool                                           | Purpose                                                  |
+| ---------------------------------------------- | -------------------------------------------------------- |
+| `muggle-remote-test-case-list`                 | List all test cases                                      |
+| `muggle-remote-test-case-list-by-use-case`     | List by use case                                         |
+| `muggle-remote-test-case-get`                  | Get test case details                                    |
+| `muggle-remote-test-case-create`               | Create test case                                         |
+| `muggle-remote-test-case-generate-from-prompt` | Generate from prompt                                     |
+| `muggle-remote-test-case-bulk-preview-submit`  | Async batch-preview via OpenAI Batch API (~50% cheaper)  |
+
+
+Bulk Preview Jobs (muggle-remote-bulk-preview-job-*)
+
+Manage async jobs started by the `*-bulk-preview-submit` tools above. Submit returns a
+`jobId` immediately; poll `-get` until a terminal status, then persist the results via
+`muggle-remote-use-case-create` / `muggle-remote-test-case-create`.
+
+| Tool                                    | Purpose                                 |
+| --------------------------------------- | --------------------------------------- |
+| `muggle-remote-bulk-preview-job-get`    | Poll a bulk-preview job for status/results |
+| `muggle-remote-bulk-preview-job-list`   | List bulk-preview jobs for a project    |
+| `muggle-remote-bulk-preview-job-cancel` | Cooperatively cancel an in-flight job   |
 
 
 Test Scripts and Workflows (muggle-remote-workflow-*)
@@ -479,6 +496,7 @@ muggle-ai-works/
 │   │   ├── muggle/                        # /muggle:muggle — command router and menu
 │   │   ├── muggle-do/                     # /muggle:muggle-do — autonomous dev pipeline
 │   │   ├── muggle-test-feature-local/     # /muggle:muggle-test-feature-local
+│   │   ├── muggle-test-regenerate-missing/# /muggle:muggle-test-regenerate-missing
 │   │   ├── muggle-status/                 # /muggle:muggle-status
 │   │   ├── muggle-repair/                 # /muggle:muggle-repair
 │   │   └── muggle-upgrade/                # /muggle:muggle-upgrade

package/dist/{chunk-PMI2DI3V.js → chunk-MNCBJEPQ.js}

@@ -1,9 +1,9 @@
 import * as fs3 from 'fs';
-import { readFileSync, existsSync, rmSync, mkdirSync, readdirSync, createWriteStream, writeFileSync, statSync } from 'fs';
+import { readFileSync, existsSync, mkdirSync, writeFileSync, rmSync, readdirSync, createWriteStream, statSync } from 'fs';
 import * as os3 from 'os';
 import { platform, arch, homedir } from 'os';
 import * as path2 from 'path';
-import { dirname, resolve, join } from 'path';
+import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import winston from 'winston';
 import axios, { AxiosError } from 'axios';
@@ -34,6 +34,49 @@ var DATA_DIR_NAME = ".muggle-ai";
 function getDataDir() {
   return path2.join(os3.homedir(), DATA_DIR_NAME);
 }
+var DEV_MANIFEST = {
+  release: "dev",
+  buildId: "dev",
+  commitSha: "dev",
+  buildTime: "1970-01-01T00:00:00Z",
+  serviceName: "muggle-ai-works-mcp"
+};
+var MANIFEST_PATH = (() => {
+  try {
+    return join(dirname(fileURLToPath(import.meta.url)), "release-manifest.json");
+  } catch {
+    return "release-manifest.json";
+  }
+})();
+var cachedManifest;
+function isValidManifest(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const m = value;
+  return typeof m.release === "string" && typeof m.buildId === "string" && typeof m.commitSha === "string" && typeof m.buildTime === "string" && typeof m.serviceName === "string";
+}
+function readReleaseManifest() {
+  if (cachedManifest !== void 0) return cachedManifest;
+  try {
+    const raw = readFileSync(MANIFEST_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isValidManifest(parsed)) {
+      cachedManifest = DEV_MANIFEST;
+      return cachedManifest;
+    }
+    cachedManifest = parsed;
+    return cachedManifest;
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      console.warn(
+        "release_manifest: unexpected error reading manifest, using DEV fallback",
+        { error: err.message }
+      );
+    }
+    cachedManifest = DEV_MANIFEST;
+    return cachedManifest;
+  }
+}
 
 // packages/mcps/src/shared/config.ts
 var DEFAULT_PROMPT_SERVICE_PRODUCTION_URL = "https://promptservice.muggle-ai.com";
@@ -303,9 +346,10 @@ function getConfig() {
   if (configInstance) {
     return configInstance;
   }
+  const manifest = readReleaseManifest();
   configInstance = {
     serverName: "muggle",
-    serverVersion: "1.0.0",
+    serverVersion: manifest.release,
     logLevel: process.env.LOG_LEVEL ?? "info",
     auth0: buildAuth0Config(),
     e2e: buildE2eConfig(),
@@ -425,6 +469,14 @@ __export(e2e_exports2, {
   ApiKeyRevokeInputSchema: () => ApiKeyRevokeInputSchema,
   AuthLoginInputSchema: () => AuthLoginInputSchema,
   AuthPollInputSchema: () => AuthPollInputSchema,
+  BulkPreviewJobCancelInputSchema: () => BulkPreviewJobCancelInputSchema,
+  BulkPreviewJobGetInputSchema: () => BulkPreviewJobGetInputSchema,
+  BulkPreviewJobKindSchema: () => BulkPreviewJobKindSchema,
+  BulkPreviewJobListInputSchema: () => BulkPreviewJobListInputSchema,
+  BulkPreviewJobStatusSchema: () => BulkPreviewJobStatusSchema,
+  BulkPreviewPromptSchema: () => BulkPreviewPromptSchema,
+  BulkPreviewSubmitTestCaseInputSchema: () => BulkPreviewSubmitTestCaseInputSchema,
+  BulkPreviewSubmitUseCaseInputSchema: () => BulkPreviewSubmitUseCaseInputSchema,
   EmptyInputSchema: () => EmptyInputSchema,
   GatewayError: () => GatewayError,
   IdSchema: () => IdSchema,
@@ -467,11 +519,11 @@ __export(e2e_exports2, {
   TestCaseListInputSchema: () => TestCaseListInputSchema,
   TestScriptGetInputSchema: () => TestScriptGetInputSchema,
   TestScriptListInputSchema: () => TestScriptListInputSchema,
-  TestScriptListPaginatedInputSchema: () => TestScriptListPaginatedInputSchema,
   TokenPackageIdSchema: () => TokenPackageIdSchema,
   TokenUsageFilterTypeSchema: () => TokenUsageFilterTypeSchema,
   UseCaseCandidatesApproveInputSchema: () => UseCaseCandidatesApproveInputSchema,
   UseCaseCreateFromPromptsInputSchema: () => UseCaseCreateFromPromptsInputSchema,
+  UseCaseCreateInputSchema: () => UseCaseCreateInputSchema,
   UseCaseDiscoveryMemoryGetInputSchema: () => UseCaseDiscoveryMemoryGetInputSchema,
   UseCaseGetInputSchema: () => UseCaseGetInputSchema,
   UseCaseListInputSchema: () => UseCaseListInputSchema,
@@ -2854,8 +2906,10 @@ var LocalRunUploadInputSchema = z.object({
 
 // packages/mcps/src/mcp/e2e/contracts/index.ts
 var PaginationInputSchema = z.object({
-  page: z.number().int().positive().optional().describe("Page number (1-based)"),
-  pageSize: z.number().int().positive().max(100).optional().describe("Number of items per page")
+  page: z.number().int().positive().default(1).describe("Page number, 1-based. Defaults to 1 (the first page)."),
+  pageSize: z.number().int().positive().max(100).default(10).describe("Number of items per page. Defaults to 10, max 100."),
+  sortBy: z.enum(["createdAt", "updatedAt"]).default("createdAt").describe("Field to sort by. Defaults to createdAt (stable under concurrent writes)."),
+  sortOrder: z.enum(["asc", "desc"]).default("desc").describe("Sort direction. Defaults to desc (newest first).")
 });
 var IdSchema = MuggleEntityIdSchema;
 var RunBatchIdSchema = MuggleEntityIdSchema.describe("Bulk replay run batch ID (UUID)");
@@ -2961,15 +3015,67 @@ var UseCasePromptPreviewInputSchema = z.object({
 });
 var UseCaseCreateFromPromptsInputSchema = z.object({
   projectId: IdSchema.describe("Project ID (UUID) to create use cases for"),
-  prompts: z.array(z.object({
-    instruction: z.string().min(1).describe("Natural language instruction describing the use case")
-  })).min(1).describe("Array of prompts to generate use cases from")
+  instructions: z.array(z.string().min(1)).min(1).describe('Natural-language instructions \u2014 one use case is generated per string (e.g., ["As a user, I can log in"])')
 });
 var UseCaseUpdateFromPromptInputSchema = z.object({
   projectId: IdSchema.describe("Project ID (UUID)"),
   useCaseId: IdSchema.describe("Use case ID (UUID) to update"),
   instruction: z.string().min(1).describe("Natural language instruction to regenerate the use case from")
 });
+var UseCaseCreateInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID (UUID) the use case belongs to"),
+  title: z.string().min(1).describe("Use case title"),
+  description: z.string().min(1).describe("Description of the use case, including actor and preconditions"),
+  userStory: z.string().min(1).describe("One-line user story from the end-user point of view"),
+  url: z.string().url().optional().describe("URL where the use case takes place (defaults to project URL)"),
+  useCaseBreakdown: z.array(z.object({
+    requirement: z.string().min(1).describe("One requirement of the use case"),
+    acceptanceCriteria: z.string().min(1).describe("Concrete, measurable acceptance criteria for the requirement")
+  })).describe("Main/alternative/error flows broken down as requirement + acceptance criteria pairs"),
+  status: z.enum(["DRAFT", "IN_REVIEW", "APPROVED", "IMPLEMENTED", "ARCHIVED"]).describe("Use case status"),
+  priority: z.enum(["LOW", "MEDIUM", "HIGH", "CRITICAL"]).describe("Use case priority"),
+  source: z.enum(["PRD_FILE", "SITEMAP", "CRAWLER", "PROMPT", "MANUAL"]).describe("How this use case was produced"),
+  category: z.string().optional().describe("Optional category")
+});
+var BulkPreviewPromptSchema = z.object({
+  clientRef: z.string().max(128).optional().describe("Optional caller-supplied reference echoed back on results"),
+  instruction: z.string().min(1).max(4e3).describe("Natural language instruction (max 4000 chars)")
+});
+var BulkPreviewSubmitUseCaseInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID (UUID) the use cases belong to"),
+  prompts: z.array(BulkPreviewPromptSchema).min(1).max(100).describe("Prompts to generate use cases from (max 100 per request)")
+});
+var BulkPreviewSubmitTestCaseInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID (UUID)"),
+  useCaseId: IdSchema.describe("Parent use case ID (UUID) the test cases will belong to"),
+  prompts: z.array(BulkPreviewPromptSchema).min(1).max(100).describe("Prompts to generate test cases from (max 100 per request)")
+});
+var BulkPreviewJobStatusSchema = z.enum([
+  "queued",
+  "submitted",
+  "running",
+  "succeeded",
+  "partial",
+  "failed",
+  "cancelled",
+  "expired"
+]);
+var BulkPreviewJobKindSchema = z.enum(["useCase", "testCase"]);
+var BulkPreviewJobGetInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID (UUID)"),
+  jobId: IdSchema.describe("Bulk-preview job ID (UUID)")
+});
+var BulkPreviewJobCancelInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID (UUID)"),
+  jobId: IdSchema.describe("Bulk-preview job ID (UUID) to cancel")
+});
+var BulkPreviewJobListInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID (UUID) to list bulk-preview jobs for"),
+  status: z.array(BulkPreviewJobStatusSchema).optional().describe("Optional filter \u2014 only return jobs matching any of these statuses"),
+  kind: BulkPreviewJobKindSchema.optional().describe("Optional filter \u2014 only return jobs of this kind"),
+  limit: z.number().int().min(1).max(100).optional().describe("Max jobs to return (default 20, max 100)"),
+  cursor: z.string().optional().describe("Pagination cursor returned by a previous call")
+});
 var TestCaseListInputSchema = z.object({
   projectId: IdSchema.describe("Project ID (UUID) to list test cases for")
 }).merge(PaginationInputSchema);
@@ -3006,9 +3112,6 @@ var TestScriptListInputSchema = z.object({
 var TestScriptGetInputSchema = z.object({
   testScriptId: IdSchema.describe("Test script ID (UUID) to retrieve")
 });
-var TestScriptListPaginatedInputSchema = z.object({
-  projectId: IdSchema.describe("Project ID (UUID) to list test scripts for")
-}).merge(PaginationInputSchema);
 var ActionScriptGetInputSchema = z.object({
   actionScriptId: IdSchema.describe("Action script ID (UUID) to retrieve")
 });
@@ -3180,6 +3283,61 @@ var GatewayError = class extends Error {
     this.details = params.details;
   }
 };
+
+// packages/mcps/src/shared/host_detection.ts
+function detectMcpHost(env = process.env) {
+  if (env.CLAUDE_CODE || env.CLAUDECODE || env.CLAUDE_CODE_SSE_PORT) {
+    return "claude-code";
+  }
+  if (env.CURSOR_TRACE_ID || env.CURSOR_MCP) {
+    return "cursor";
+  }
+  if (env.CODEX || env.OPENAI_CODEX) {
+    return "codex";
+  }
+  if (env.WINDSURF_MCP || env.WINDSURF || env.CODEIUM_API_KEY) {
+    return "windsurf";
+  }
+  return "unknown";
+}
+var INSTALL_ID_FILENAME = "install-id.json";
+var cachedInstallId;
+function installIdFilePath() {
+  return join(getDataDir(), INSTALL_ID_FILENAME);
+}
+function generateAndPersist(filePath) {
+  const installId = randomUUID();
+  const contents = { installId };
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(contents, null, 2) + "\n", "utf8");
+  return installId;
+}
+function isValid(value) {
+  return typeof value === "object" && value !== null && typeof value.installId === "string" && value.installId.length > 0;
+}
+function getInstallId() {
+  if (cachedInstallId !== void 0) return cachedInstallId;
+  const filePath = installIdFilePath();
+  if (!existsSync(filePath)) {
+    cachedInstallId = generateAndPersist(filePath);
+    return cachedInstallId;
+  }
+  try {
+    const raw = readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (isValid(parsed)) {
+      cachedInstallId = parsed.installId;
+      return cachedInstallId;
+    }
+    cachedInstallId = generateAndPersist(filePath);
+    return cachedInstallId;
+  } catch {
+    cachedInstallId = generateAndPersist(filePath);
+    return cachedInstallId;
+  }
+}
+
+// packages/mcps/src/mcp/e2e/upstream-client.ts
 var ALLOWED_UPSTREAM_PREFIXES = [
   "/v1/protected/muggle-test/",
   "/v1/protected/wallet/",
@@ -3226,8 +3384,17 @@ var PromptServiceClient = class {
    * @returns Headers object.
    */
   buildHeaders(credentials, correlationId) {
+    const manifest = readReleaseManifest();
+    const installId = getInstallId();
+    const host = detectMcpHost();
     const headers = {
-      "X-Correlation-Id": correlationId
+      "X-Correlation-Id": correlationId,
+      "X-Client-Service-Name": manifest.serviceName,
+      "X-Client-Release": manifest.release,
+      "X-Client-Build-Id": manifest.buildId,
+      "X-Client-Commit-Sha": manifest.commitSha,
+      "X-Client-Install-Id": installId,
+      "X-Client-Host": host
     };
     if (credentials.bearerToken) {
       headers["Authorization"] = credentials.bearerToken.startsWith("Bearer ") ? credentials.bearerToken : `Bearer ${credentials.bearerToken}`;
@@ -3476,14 +3643,19 @@ var projectTools = [
   },
   {
     name: "muggle-remote-project-list",
-    description: "List all projects accessible to the authenticated user.",
+    description: "List projects accessible to the authenticated user. Returns up to 10 items per page by default (max 100). Response includes pagination metadata (totalCount, totalPages, hasMore) \u2014 check `hasMore` to decide whether to fetch additional pages.",
     inputSchema: ProjectListInputSchema,
     mapToUpstream: (input) => {
       const data = input;
       return {
         method: "GET",
         path: `${MUGGLE_TEST_PREFIX}/projects`,
-        queryParams: { page: data.page, pageSize: data.pageSize }
+        queryParams: {
+          page: data.page,
+          pageSize: data.pageSize,
+          sortBy: data.sortBy,
+          sortOrder: data.sortOrder
+        }
       };
     }
   },
@@ -3528,14 +3700,20 @@ var useCaseTools = [
   },
   {
     name: "muggle-remote-use-case-list",
-    description: "List all use cases for a project.",
+    description: "List use cases for a project. Returns up to 10 items per page by default (max 100). Response includes pagination metadata (totalCount, totalPages, hasMore) \u2014 check `hasMore` to decide whether to fetch additional pages.",
     inputSchema: UseCaseListInputSchema,
     mapToUpstream: (input) => {
       const data = input;
       return {
         method: "GET",
         path: `${MUGGLE_TEST_PREFIX}/use-cases`,
-        queryParams: { projectId: data.projectId, page: data.page, pageSize: data.pageSize }
+        queryParams: {
+          projectId: data.projectId,
+          page: data.page,
+          pageSize: data.pageSize,
+          sortBy: data.sortBy,
+          sortOrder: data.sortOrder
+        }
       };
     }
   },
@@ -3573,7 +3751,10 @@ var useCaseTools = [
       return {
         method: "POST",
         path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/use-cases/prompts/bulk`,
-        body: { projectId: data.projectId, prompts: data.prompts }
+        body: {
+          projectId: data.projectId,
+          prompts: data.instructions.map((instruction) => ({ instruction }))
+        }
       };
     }
   },
@@ -3589,19 +3770,62 @@ var useCaseTools = [
         body: { instruction: data.instruction }
       };
     }
+  },
+  {
+    name: "muggle-remote-use-case-create",
+    description: "Create a single use case from a fully-specified payload. Use this to persist use cases returned by muggle-remote-use-case-bulk-preview-submit \u2014 no LLM is invoked.",
+    inputSchema: UseCaseCreateInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/use-cases`,
+        body: {
+          projectId: data.projectId,
+          title: data.title,
+          description: data.description,
+          userStory: data.userStory,
+          url: data.url,
+          useCaseBreakdown: data.useCaseBreakdown,
+          status: data.status,
+          priority: data.priority,
+          source: data.source,
+          category: data.category
+        }
+      };
+    }
+  },
+  {
+    name: "muggle-remote-use-case-bulk-preview-submit",
+    description: "Submit an async bulk-preview job that uses the OpenAI Batch API to generate use cases from many prompts at ~50% of normal LLM cost. Returns a job ID immediately; poll with muggle-remote-bulk-preview-job-get until the job reaches a terminal status, then persist each successful result via muggle-remote-use-case-create.",
+    inputSchema: BulkPreviewSubmitUseCaseInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/use-cases/prompts/bulk-preview`,
+        body: { prompts: data.prompts }
+      };
+    }
   }
 ];
 var testCaseTools = [
   {
     name: "muggle-remote-test-case-list",
-    description: "List test cases for a project.",
+    description: "List test cases for a project. Returns up to 10 items per page by default (max 100). Response includes pagination metadata (totalCount, totalPages, hasMore) \u2014 check `hasMore` to decide whether to fetch additional pages.",
     inputSchema: TestCaseListInputSchema,
     mapToUpstream: (input) => {
       const data = input;
       return {
         method: "GET",
         path: `${MUGGLE_TEST_PREFIX}/test-cases`,
-        queryParams: { projectId: data.projectId, page: data.page, pageSize: data.pageSize }
+        queryParams: {
+          projectId: data.projectId,
+          page: data.page,
+          pageSize: data.pageSize,
+          sortBy: data.sortBy,
+          sortOrder: data.sortOrder
+        }
       };
     }
   },
@@ -3668,44 +3892,95 @@ var testCaseTools = [
         }
       };
     }
+  },
+  {
+    name: "muggle-remote-test-case-bulk-preview-submit",
+    description: "Submit an async bulk-preview job that uses the OpenAI Batch API to generate test cases for a single use case from many prompts at ~50% of normal LLM cost. Returns a job ID immediately; poll with muggle-remote-bulk-preview-job-get until the job reaches a terminal status, then persist each successful result via muggle-remote-test-case-create. Note: one input prompt may fan out to 1\u20135 test cases.",
+    inputSchema: BulkPreviewSubmitTestCaseInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/use-cases/${data.useCaseId}/test-cases/prompts/bulk-preview`,
+        body: { prompts: data.prompts }
+      };
+    }
   }
 ];
-var testScriptTools = [
+var bulkPreviewTools = [
   {
-    name: "muggle-remote-test-script-list",
-    description: "List test scripts for a project, optionally filtered by test case.",
-    inputSchema: TestScriptListInputSchema,
+    name: "muggle-remote-bulk-preview-job-get",
+    description: "Get the current status and (when terminal) results of a bulk-preview job. Poll this after submitting a bulk-preview job \u2014 every 10\u201315 seconds is fine. Terminal statuses: succeeded, partial, failed, cancelled, expired.",
+    inputSchema: BulkPreviewJobGetInputSchema,
     mapToUpstream: (input) => {
       const data = input;
       return {
         method: "GET",
-        path: `${MUGGLE_TEST_PREFIX}/test-scripts`,
-        queryParams: { projectId: data.projectId, testCaseId: data.testCaseId, page: data.page, pageSize: data.pageSize }
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/bulk-preview-jobs/${data.jobId}`
       };
     }
   },
   {
-    name: "muggle-remote-test-script-get",
-    description: "Get details of a specific test script.",
-    inputSchema: TestScriptGetInputSchema,
+    name: "muggle-remote-bulk-preview-job-list",
+    description: "List bulk-preview jobs for a project, optionally filtered by status or kind.",
+    inputSchema: BulkPreviewJobListInputSchema,
     mapToUpstream: (input) => {
       const data = input;
       return {
         method: "GET",
-        path: `${MUGGLE_TEST_PREFIX}/test-scripts/${data.testScriptId}`
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/bulk-preview-jobs`,
+        queryParams: {
+          status: data.status?.join(","),
+          kind: data.kind,
+          limit: data.limit,
+          cursor: data.cursor
+        }
       };
     }
   },
   {
-    name: "muggle-remote-test-script-list-paginated",
-    description: "List test scripts with full pagination support.",
-    inputSchema: TestScriptListPaginatedInputSchema,
+    name: "muggle-remote-bulk-preview-job-cancel",
+    description: "Request cancellation of a bulk-preview job. Cancellation is cooperative \u2014 the harvester picks it up on its next tick and moves the job to status=cancelled.",
+    inputSchema: BulkPreviewJobCancelInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "DELETE",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/bulk-preview-jobs/${data.jobId}`
+      };
+    }
+  }
+];
+var testScriptTools = [
+  {
+    name: "muggle-remote-test-script-list",
+    description: "List test scripts for a project, optionally filtered by test case. Returns up to 10 items per page by default (max 100). Response includes pagination metadata (totalCount, totalPages, hasMore) \u2014 check `hasMore` to decide whether to fetch additional pages.",
+    inputSchema: TestScriptListInputSchema,
     mapToUpstream: (input) => {
       const data = input;
       return {
         method: "GET",
-        path: `${MUGGLE_TEST_PREFIX}/test-scripts/paginated`,
-        queryParams: { projectId: data.projectId, page: data.page, pageSize: data.pageSize }
+        path: `${MUGGLE_TEST_PREFIX}/test-scripts`,
+        queryParams: {
+          projectId: data.projectId,
+          testCaseId: data.testCaseId,
+          page: data.page,
+          pageSize: data.pageSize,
+          sortBy: data.sortBy,
+          sortOrder: data.sortOrder
+        }
+      };
+    }
+  },
+  {
+    name: "muggle-remote-test-script-get",
+    description: "Get details of a specific test script.",
+    inputSchema: TestScriptGetInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/test-scripts/${data.testScriptId}`
       };
     }
   }
@@ -4691,6 +4966,7 @@ var allQaToolDefinitions = [
   ...projectTools,
   ...useCaseTools,
   ...testCaseTools,
+  ...bulkPreviewTools,
   ...testScriptTools,
   ...actionScriptTools,
   ...workflowTools,

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { runCli } from './chunk-PMI2DI3V.js';
+import { runCli } from './chunk-MNCBJEPQ.js';
 
 // src/cli/main.ts
 runCli().catch((error) => {

package/dist/index.js

@@ -1 +1 @@
-export { src_exports2 as commands, createChildLogger, createUnifiedMcpServer, e2e_exports as e2e, getConfig, getLocalQaTools, getLogger, getQaTools, local_exports as localQa, mcp_exports as mcp, e2e_exports as qa, server_exports as server, src_exports as shared } from './chunk-PMI2DI3V.js';
+export { src_exports2 as commands, createChildLogger, createUnifiedMcpServer, e2e_exports as e2e, getConfig, getLocalQaTools, getLogger, getQaTools, local_exports as localQa, mcp_exports as mcp, e2e_exports as qa, server_exports as server, src_exports as shared } from './chunk-MNCBJEPQ.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.4.0",
+  "version": "4.5.0",
   "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.4.0",
+  "version": "4.5.0",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/dist/plugin/README.md

@@ -28,6 +28,7 @@ Type `muggle` to discover the full command family.
 | `/muggle:muggle-test` | Change-driven E2E acceptance router: detects code changes, maps to use cases, runs test generation locally or remotely, publishes to dashboard, opens in browser, posts E2E acceptance results to PR. |
 | `/muggle:muggle-test-feature-local` | Test a feature on localhost with AI-driven browser automation. Offers publish to cloud after each run. |
 | `/muggle:muggle-test-import` | Import existing tests into Muggle Test — from Playwright/Cypress specs, PRDs, Gherkin feature files, test plan docs, or any test artifact. |
+| `/muggle:muggle-test-regenerate-missing` | Bulk-regenerate test scripts for every test case in a project that doesn't currently have an active script. Scans DRAFT + GENERATION_PENDING, confirms the list with the user, and dispatches remote generation workflows for each. |
 | `/muggle:muggle-status` | Health check for Electron browser test runner, MCP server, and authentication. |
 | `/muggle:muggle-repair` | Diagnose and fix broken installation automatically. |
 | `/muggle:muggle-upgrade` | Update Electron browser test runner and MCP server to latest version. |