@muggleai/works 4.5.0 → 4.6.1

package/dist/chunk-2FVSZ5LQ.js

@@ -0,0 +1,2176 @@
+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 { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { v4 } from 'uuid';
+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 { dirname, resolve, join } from 'path';
+import { fileURLToPath } from 'url';
+import { Command } from 'commander';
+import axios from 'axios';
+import { platform, arch, homedir } from 'os';
+import { execFile } from 'child_process';
+import { pipeline } from 'stream/promises';
+
+var registeredTools = [];
+function registerTools(tools) {
+  registeredTools = [...registeredTools, ...tools];
+}
+function getAllTools() {
+  return registeredTools;
+}
+function clearTools() {
+  registeredTools = [];
+}
+function zodToJsonSchema(schema) {
+  try {
+    if (schema && typeof schema === "object" && "safeParse" in schema) {
+      return z.toJSONSchema(schema);
+    }
+  } catch {
+  }
+  try {
+    const zodSchema = schema;
+    if (zodSchema._def) {
+      return convertZodDef(zodSchema);
+    }
+  } catch {
+  }
+  return {
+    type: "object",
+    properties: {},
+    additionalProperties: true
+  };
+}
+function convertZodDef(schema) {
+  const zodSchema = schema;
+  if (!zodSchema._def) {
+    return { type: "object" };
+  }
+  const def = zodSchema._def;
+  const typeName = def.typeName ?? def.type;
+  switch (typeName) {
+    case "ZodObject":
+    case "object": {
+      const shapeFromDef = typeof def.shape === "function" ? def.shape() : def.shape;
+      const shape = shapeFromDef || zodSchema.shape || {};
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = convertZodDef(value);
+        const valueDef = value._def;
+        if (valueDef?.typeName !== "ZodOptional") {
+          required.push(key);
+        }
+      }
+      const result = {
+        type: "object",
+        properties
+      };
+      if (required.length > 0) {
+        result.required = required;
+      }
+      return result;
+    }
+    case "ZodString":
+    case "string": {
+      const result = { type: "string" };
+      if (def.description) result.description = def.description;
+      if (def.checks) {
+        for (const check of def.checks) {
+          if (check.kind === "min") result.minLength = check.value;
+          if (check.kind === "max") result.maxLength = check.value;
+          if (check.kind === "url") result.format = "uri";
+          if (check.kind === "email") result.format = "email";
+        }
+      }
+      return result;
+    }
+    case "ZodNumber":
+    case "number": {
+      const result = { type: "number" };
+      if (def.description) result.description = def.description;
+      if (def.checks) {
+        for (const check of def.checks) {
+          if (check.kind === "int") result.type = "integer";
+          if (check.kind === "min") result.minimum = check.value;
+          if (check.kind === "max") result.maximum = check.value;
+        }
+      }
+      return result;
+    }
+    case "ZodBoolean":
+    case "boolean": {
+      const result = { type: "boolean" };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    case "ZodArray":
+    case "array": {
+      const result = {
+        type: "array",
+        items: def.innerType ? convertZodDef(def.innerType) : def.element ? convertZodDef(def.element) : {}
+      };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    case "ZodEnum":
+    case "enum": {
+      const enumValues = Array.isArray(def.values) ? def.values : def.values ? Object.values(def.values) : [];
+      const result = {
+        type: "string",
+        enum: enumValues
+      };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    case "ZodOptional":
+    case "optional": {
+      const inner = def.innerType ? convertZodDef(def.innerType) : {};
+      if (def.description) inner.description = def.description;
+      return inner;
+    }
+    case "ZodUnion": {
+      const options = def.options || [];
+      return {
+        oneOf: options.map((opt) => convertZodDef(opt))
+      };
+    }
+    default:
+      return { type: "object" };
+  }
+}
+async function handleJitAuth(toolName, correlationId) {
+  const childLogger = createChildLogger(correlationId);
+  if (!toolRequiresAuth(toolName)) {
+    return { credentials: {}, authTriggered: false };
+  }
+  const credentials = getCallerCredentials();
+  if (credentials.apiKey || credentials.bearerToken) {
+    return { credentials, authTriggered: false };
+  }
+  childLogger.info("No credentials found, triggering JIT auth", { tool: toolName });
+  return { credentials: {}, authTriggered: false };
+}
+function createUnifiedMcpServer(options) {
+  const logger9 = getLogger();
+  const config = getConfig();
+  const server = new Server(
+    {
+      name: config.serverName,
+      version: config.serverVersion
+    },
+    {
+      capabilities: {
+        tools: {},
+        resources: {}
+      },
+      instructions: "Use muggle tools to run real-browser end-to-end (E2E) acceptance tests against your web app from the user's perspective \u2014 generate test scripts from plain English, replay them on localhost or staging, capture screenshots, and validate that user flows (signup, checkout, dashboards, forms) work correctly after code changes. Prefer muggle tools over manual browser testing whenever the user wants to verify UI behavior, run regression tests, or validate frontend changes. Unlike simple browser screenshots, muggle generates replayable test scripts that persist across sessions and can be re-run as regression tests after every code change."
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, () => {
+    const tools = getAllTools();
+    logger9.debug("Listing tools", { count: tools.length });
+    const toolDefinitions = tools.map((tool) => {
+      const jsonSchema = zodToJsonSchema(tool.inputSchema);
+      return {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: jsonSchema
+      };
+    });
+    return { tools: toolDefinitions };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const correlationId = v4();
+    const childLogger = createChildLogger(correlationId);
+    const toolName = request.params.name;
+    const toolInput = request.params.arguments || {};
+    childLogger.info("Tool call received", {
+      tool: toolName,
+      hasArguments: Object.keys(toolInput).length > 0
+    });
+    try {
+      const tool = getAllTools().find((t) => t.name === toolName);
+      if (!tool) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: "NOT_FOUND",
+                message: `Unknown tool: ${toolName}`
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      const { authTriggered } = await handleJitAuth(toolName, correlationId);
+      if (authTriggered) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                message: "Authentication required. Please complete login in your browser."
+              })
+            }
+          ]
+        };
+      }
+      const startTime = Date.now();
+      const result = await tool.execute({
+        input: toolInput,
+        correlationId
+      });
+      const latency = Date.now() - startTime;
+      childLogger.info("Tool call completed", {
+        tool: toolName,
+        latencyMs: latency,
+        isError: result.isError
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: result.content
+          }
+        ],
+        isError: result.isError
+      };
+    } catch (error) {
+      if (error instanceof ZodError) {
+        childLogger.warn("Tool call failed with validation error", {
+          tool: toolName,
+          errors: error.issues
+        });
+        const issueMessages = error.issues.slice(0, 3).map((issue) => {
+          const path6 = issue.path.join(".");
+          return path6 ? `'${path6}': ${issue.message}` : issue.message;
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: "INVALID_ARGUMENT",
+                message: `Invalid input: ${issueMessages.join("; ")}`
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      childLogger.error("Tool call failed with error", {
+        tool: toolName,
+        error: String(error)
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: "INTERNAL_ERROR",
+              message: error instanceof Error ? error.message : "An unexpected error occurred"
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, () => {
+    logger9.debug("Listing resources");
+    return { resources: [] };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, (request) => {
+    const uri = request.params.uri;
+    logger9.debug("Reading resource", { uri });
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "text/plain",
+          text: `Resource not found: ${uri}`
+        }
+      ]
+    };
+  });
+  logger9.info("Unified MCP server configured", {
+    tools: getAllTools().length,
+    enableQaTools: options.enableQaTools,
+    enableLocalTools: options.enableLocalTools
+  });
+  return server;
+}
+
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  clearTools: () => clearTools,
+  createUnifiedMcpServer: () => createUnifiedMcpServer,
+  getAllTools: () => getAllTools,
+  registerTools: () => registerTools,
+  startStdioServer: () => startStdioServer
+});
+var logger = getLogger();
+async function startStdioServer(server) {
+  logger.info("Starting stdio server transport");
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info("Stdio server connected");
+  const shutdown = (signal) => {
+    logger.info(`Received ${signal}, shutting down...`);
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+}
+
+// src/cli/pr-section/render.ts
+var DASHBOARD_URL_BASE = "https://www.muggle-ai.com/muggleTestV0/dashboard/projects";
+var DETAIL_IMAGE_WIDTH = 720;
+function countTests(report) {
+  const total = report.tests.length;
+  const passed = report.tests.filter((t) => t.status === "passed").length;
+  const failed = report.tests.filter((t) => t.status === "failed").length;
+  return { total, passed, failed };
+}
+function statusEmoji(test) {
+  return test.status === "passed" ? "\u2705" : "\u274C";
+}
+function endingScreenshot(test) {
+  if (test.steps.length === 0) {
+    return null;
+  }
+  if (test.status === "failed") {
+    const failStep = test.steps.find((s) => s.stepIndex === test.failureStepIndex);
+    if (failStep) {
+      return failStep;
+    }
+    return test.steps[test.steps.length - 1];
+  }
+  return test.steps[test.steps.length - 1];
+}
+function fullSizeImage(url, alt) {
+  return `<a href="${url}"><img src="${url}" width="${DETAIL_IMAGE_WIDTH}" alt="${alt}"></a>`;
+}
+function safeInlineCode(s) {
+  return s.replace(/`/g, "\u2018");
+}
+function renderOverview(report) {
+  const { total, passed, failed } = countTests(report);
+  const lines = [
+    "## E2E Acceptance Results",
+    "",
+    `**${total} tests ran \u2014 ${passed} passed / ${failed} failed**`
+  ];
+  if (total === 0) {
+    lines.push("", "_No tests were executed._");
+    return lines.join("\n");
+  }
+  lines.push("", "**Tests run:**");
+  const anyGrouped = report.tests.some((t) => Boolean(t.useCaseName));
+  if (!anyGrouped) {
+    for (const t of report.tests) {
+      lines.push(`- ${statusEmoji(t)} ${t.name}`);
+    }
+    return lines.join("\n");
+  }
+  const groupOrder = [];
+  const groups = /* @__PURE__ */ new Map();
+  const flat = [];
+  const seenGroups = /* @__PURE__ */ new Set();
+  for (const t of report.tests) {
+    if (t.useCaseName) {
+      if (!groups.has(t.useCaseName)) {
+        groups.set(t.useCaseName, []);
+        groupOrder.push(t.useCaseName);
+      }
+      groups.get(t.useCaseName).push(t);
+      if (!seenGroups.has(t.useCaseName)) {
+        seenGroups.add(t.useCaseName);
+        flat.push({ type: "group", key: t.useCaseName });
+      }
+    } else {
+      flat.push({ type: "test", test: t });
+    }
+  }
+  for (const entry of flat) {
+    if (entry.type === "test") {
+      lines.push(`- ${statusEmoji(entry.test)} ${entry.test.name}`);
+    } else {
+      lines.push(`- **${entry.key}**`);
+      for (const t of groups.get(entry.key)) {
+        lines.push(`  - ${statusEmoji(t)} ${t.name}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function renderTestDetails(test, projectId) {
+  const summary = renderSummaryLine(test);
+  const image = renderEndingImage(test);
+  const resultLines = renderResultSummary(test, projectId);
+  const body = ["", "<br>", ""];
+  if (image) {
+    body.push(image, "");
+  }
+  body.push(...resultLines);
+  return `<details>
+<summary>${summary}</summary>
+${body.join("\n")}
+
+</details>`;
+}
+function renderSummaryLine(test) {
+  const base = `${statusEmoji(test)} <b>${test.name}</b>`;
+  const tail = " <i>\u25B6 click to expand</i>";
+  if (test.description) {
+    return `${base} \u2014 ${test.description}${tail}`;
+  }
+  return `${base}${tail}`;
+}
+function renderEndingImage(test) {
+  const step = endingScreenshot(test);
+  if (!step) {
+    return null;
+  }
+  return fullSizeImage(step.screenshotUrl, test.name);
+}
+function renderResultSummary(test, projectId) {
+  const dashboardUrl = `${DASHBOARD_URL_BASE}/${projectId}/scripts?modal=script-details&testCaseId=${encodeURIComponent(test.testCaseId)}`;
+  const lines = [];
+  if (test.status === "passed") {
+    lines.push(`**Result:** \u2705 PASSED`);
+  } else {
+    lines.push(`**Result:** \u274C FAILED at step ${test.failureStepIndex}`);
+    lines.push(`**Error:** \`${safeInlineCode(test.error)}\``);
+  }
+  lines.push(`**Steps:** ${test.steps.length}`);
+  lines.push(`[View on Muggle AI dashboard \u2192](${dashboardUrl})`);
+  return lines;
+}
+function renderBody(report, opts) {
+  const overview = renderOverview(report);
+  if (report.tests.length === 0) {
+    return overview;
+  }
+  if (!opts.inlineDetails) {
+    return [
+      overview,
+      "",
+      "---",
+      "",
+      "_Full per-test details in the comment below \u2014 the PR description was too large to inline them._"
+    ].join("\n");
+  }
+  const detailBlocks = report.tests.map((t) => renderTestDetails(t, report.projectId));
+  return [
+    overview,
+    "",
+    "---",
+    "",
+    detailBlocks.join("\n\n")
+  ].join("\n");
+}
+function renderComment(report) {
+  if (report.tests.length === 0) {
+    return "";
+  }
+  const detailBlocks = report.tests.map((t) => renderTestDetails(t, report.projectId));
+  return [
+    "## E2E acceptance evidence (overflow)",
+    "",
+    "_This comment was posted because the full per-test details did not fit in the PR description._",
+    "",
+    detailBlocks.join("\n\n")
+  ].join("\n");
+}
+
+// src/cli/pr-section/overflow.ts
+function splitWithOverflow(report, opts) {
+  const inlineBody = renderBody(report, { inlineDetails: true });
+  const inlineBytes = Buffer.byteLength(inlineBody, "utf-8");
+  if (inlineBytes <= opts.maxBodyBytes) {
+    return { body: inlineBody, comment: null };
+  }
+  if (report.tests.length === 0) {
+    return { body: inlineBody, comment: null };
+  }
+  const spilledBody = renderBody(report, { inlineDetails: false });
+  const comment = renderComment(report);
+  return {
+    body: spilledBody,
+    comment: comment.length > 0 ? comment : null
+  };
+}
+var StepSchema = z.object({
+  stepIndex: z.number().int().nonnegative(),
+  action: z.string().min(1),
+  screenshotUrl: z.string().url()
+});
+var PassedTestSchema = z.object({
+  name: z.string().min(1),
+  testCaseId: z.string().min(1),
+  testScriptId: z.string().min(1).optional(),
+  runId: z.string().min(1),
+  viewUrl: z.string().url(),
+  status: z.literal("passed"),
+  steps: z.array(StepSchema),
+  useCaseName: z.string().min(1).optional(),
+  description: z.string().min(1).optional()
+});
+var FailedTestSchema = z.object({
+  name: z.string().min(1),
+  testCaseId: z.string().min(1),
+  testScriptId: z.string().min(1).optional(),
+  runId: z.string().min(1),
+  viewUrl: z.string().url(),
+  status: z.literal("failed"),
+  steps: z.array(StepSchema),
+  failureStepIndex: z.number().int().nonnegative(),
+  error: z.string().min(1),
+  artifactsDir: z.string().min(1).optional(),
+  useCaseName: z.string().min(1).optional(),
+  description: z.string().min(1).optional()
+});
+var TestResultSchema = z.discriminatedUnion("status", [
+  PassedTestSchema,
+  FailedTestSchema
+]);
+var E2eReportSchema = z.object({
+  projectId: z.string().min(1),
+  tests: z.array(TestResultSchema)
+});
+
+// src/cli/pr-section/index.ts
+function buildPrSection(report, opts) {
+  return splitWithOverflow(report, opts);
+}
+
+// src/cli/pr-section/resolve-urls-types.ts
+var GS_SCHEME = "gs://";
+var PUBLIC_URL_PATH = "/v1/protected/storage/publicUrl";
+var RESOLVE_TIMEOUT_MS = 1e4;
+var LOG_PREFIX = "build-pr-section";
+
+// src/cli/pr-section/resolve-urls.ts
+function errMsg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function isGsUrl(url) {
+  return url.startsWith(GS_SCHEME);
+}
+function buildAuthHeaders(credentials) {
+  const headers = {};
+  if (credentials.bearerToken) {
+    headers["Authorization"] = credentials.bearerToken.startsWith("Bearer ") ? credentials.bearerToken : `Bearer ${credentials.bearerToken}`;
+  }
+  if (credentials.apiKey) {
+    headers["x-api-key"] = credentials.apiKey;
+  }
+  return headers;
+}
+function collectGsUrls(report) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const test of report.tests) {
+    for (const step of test.steps) {
+      if (isGsUrl(step.screenshotUrl)) {
+        seen.add(step.screenshotUrl);
+      }
+    }
+  }
+  return Array.from(seen);
+}
+async function resolveOne(gsUrl, baseUrl, headers, stderrWrite) {
+  try {
+    const response = await axios.post(
+      `${baseUrl}${PUBLIC_URL_PATH}`,
+      { resourceUrl: gsUrl },
+      {
+        headers: { ...headers, "Content-Type": "application/json" },
+        timeout: RESOLVE_TIMEOUT_MS,
+        validateStatus: () => true
+      }
+    );
+    if (response.status === 200 && response.data && typeof response.data.resourceUrl === "string" && response.data.resourceUrl.length > 0) {
+      return response.data.resourceUrl;
+    }
+    const reason = response.status !== 200 ? `HTTP ${response.status}` : "missing resourceUrl in response";
+    stderrWrite(`${LOG_PREFIX}: failed to resolve ${gsUrl}: ${reason}
+`);
+    return null;
+  } catch (err) {
+    stderrWrite(`${LOG_PREFIX}: failed to resolve ${gsUrl}: ${errMsg(err)}
+`);
+    return null;
+  }
+}
+function remapStep(step, urlMap) {
+  const resolved = urlMap.get(step.screenshotUrl);
+  if (!resolved) {
+    return step;
+  }
+  return { ...step, screenshotUrl: resolved };
+}
+function remapTest(test, urlMap) {
+  return { ...test, steps: test.steps.map((s) => remapStep(s, urlMap)) };
+}
+async function resolveGsScreenshotUrls(report, opts) {
+  const { stderrWrite } = opts;
+  try {
+    const gsUrls = collectGsUrls(report);
+    if (gsUrls.length === 0) {
+      return report;
+    }
+    const mcps = await import('./src-TX2KXI26.js');
+    const credentials = await mcps.getCallerCredentialsAsync();
+    if (!credentials.bearerToken && !credentials.apiKey) {
+      stderrWrite(
+        `${LOG_PREFIX}: no credentials available; run 'muggle login' to enable automatic gs:// URL resolution. Screenshots will render as broken images in GitHub.
+`
+      );
+      return report;
+    }
+    const baseUrl = mcps.getConfig().e2e.promptServiceBaseUrl;
+    const headers = buildAuthHeaders(credentials);
+    const resolved = await Promise.all(
+      gsUrls.map((gsUrl) => resolveOne(gsUrl, baseUrl, headers, stderrWrite))
+    );
+    const urlMap = /* @__PURE__ */ new Map();
+    let failureCount = 0;
+    for (let i = 0; i < gsUrls.length; i++) {
+      const https = resolved[i];
+      if (https) {
+        urlMap.set(gsUrls[i], https);
+      } else {
+        failureCount++;
+      }
+    }
+    if (failureCount > 0) {
+      stderrWrite(
+        `${LOG_PREFIX}: ${failureCount}/${gsUrls.length} gs:// URLs could not be resolved; those screenshots will render as broken images in GitHub
+`
+      );
+    }
+    if (urlMap.size === 0) {
+      return report;
+    }
+    return {
+      ...report,
+      tests: report.tests.map((t) => remapTest(t, urlMap))
+    };
+  } catch (err) {
+    stderrWrite(
+      `${LOG_PREFIX}: unexpected error while resolving gs:// URLs: ${errMsg(err)}; continuing with original report
+`
+    );
+    return report;
+  }
+}
+
+// src/cli/build-pr-section.ts
+var DEFAULT_MAX_BODY_BYTES = 6e4;
+async function readAll(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function errMsg2(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+async function runBuildPrSection(opts) {
+  let raw;
+  try {
+    raw = await readAll(opts.stdin);
+  } catch (err) {
+    opts.stderrWrite(`build-pr-section: failed to read stdin: ${errMsg2(err)}
+`);
+    return 1;
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (err) {
+    opts.stderrWrite(`build-pr-section: failed to parse stdin as JSON: ${errMsg2(err)}
+`);
+    return 1;
+  }
+  let report;
+  try {
+    report = E2eReportSchema.parse(json);
+  } catch (err) {
+    if (err instanceof ZodError) {
+      opts.stderrWrite(
+        `build-pr-section: report validation failed:
+${err.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}
+`
+      );
+    } else {
+      opts.stderrWrite(`build-pr-section: report validation failed: ${errMsg2(err)}
+`);
+    }
+    return 1;
+  }
+  const resolvedReport = await resolveGsScreenshotUrls(report, { stderrWrite: opts.stderrWrite });
+  const result = buildPrSection(resolvedReport, { maxBodyBytes: opts.maxBodyBytes });
+  opts.stdoutWrite(JSON.stringify({ body: result.body, comment: result.comment }));
+  return 0;
+}
+async function buildPrSectionCommand(options) {
+  const maxBodyBytes = options.maxBodyBytes ? Number(options.maxBodyBytes) : DEFAULT_MAX_BODY_BYTES;
+  if (!Number.isFinite(maxBodyBytes) || maxBodyBytes <= 0) {
+    process.stderr.write(`build-pr-section: --max-body-bytes must be a positive number
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const code = await runBuildPrSection({
+    stdin: process.stdin,
+    stdoutWrite: (s) => process.stdout.write(s),
+    stderrWrite: (s) => process.stderr.write(s),
+    maxBodyBytes
+  });
+  if (code !== 0) {
+    process.exitCode = code;
+  }
+}
+var logger2 = getLogger();
+var ELECTRON_APP_DIR = "electron-app";
+var CURSOR_SKILLS_DIR = ".cursor";
+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);
+}
+function getCursorSkillsDir() {
+  return path.join(homedir(), CURSOR_SKILLS_DIR, CURSOR_SKILLS_SUBDIR);
+}
+function getInstallManifestPath() {
+  return path.join(getDataDir(), INSTALL_MANIFEST_FILE);
+}
+function readInstallManifest() {
+  const manifestPath = getInstallManifestPath();
+  if (!existsSync(manifestPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(manifestPath, "utf-8");
+    const manifest = JSON.parse(content);
+    if (typeof manifest !== "object" || manifest === null || Array.isArray(manifest)) {
+      return null;
+    }
+    return manifest;
+  } catch {
+    return null;
+  }
+}
+function listObsoleteSkills() {
+  const skillsDir = getCursorSkillsDir();
+  const manifest = readInstallManifest();
+  const obsoleteSkills = [];
+  if (!existsSync(skillsDir)) {
+    return obsoleteSkills;
+  }
+  const manifestSkills = new Set(manifest?.skills ?? []);
+  try {
+    const entries = readdirSync(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      if (!entry.name.startsWith(MUGGLE_SKILL_PREFIX)) {
+        continue;
+      }
+      if (manifestSkills.has(entry.name)) {
+        continue;
+      }
+      const skillPath = path.join(skillsDir, entry.name);
+      const sizeBytes = getDirectorySize(skillPath);
+      obsoleteSkills.push({
+        name: entry.name,
+        path: skillPath,
+        sizeBytes
+      });
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger2.warn("Failed to list obsolete skills", { error: errorMessage });
+  }
+  return obsoleteSkills;
+}
+function cleanupObsoleteSkills(options = {}) {
+  const { dryRun = false } = options;
+  const obsoleteSkills = listObsoleteSkills();
+  const removed = [];
+  let freedBytes = 0;
+  for (const skill of obsoleteSkills) {
+    if (!dryRun) {
+      try {
+        rmSync(skill.path, { recursive: true, force: true });
+        logger2.info("Removed obsolete skill", {
+          skill: skill.name,
+          freedBytes: skill.sizeBytes
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger2.error("Failed to remove skill", {
+          skill: skill.name,
+          error: errorMessage
+        });
+        continue;
+      }
+    }
+    removed.push(skill);
+    freedBytes += skill.sizeBytes;
+  }
+  return { removed, freedBytes };
+}
+function getDirectorySize(dirPath) {
+  let totalSize = 0;
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        totalSize += getDirectorySize(fullPath);
+      } else if (entry.isFile()) {
+        try {
+          const stats = statSync(fullPath);
+          totalSize += stats.size;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return totalSize;
+}
+function formatBytes(bytes) {
+  if (bytes === 0) {
+    return "0 B";
+  }
+  const units = ["B", "KB", "MB", "GB"];
+  const k = 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const size = bytes / Math.pow(k, i);
+  return `${size.toFixed(1)} ${units[i]}`;
+}
+function compareVersions(a, b) {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const partA = partsA[i] || 0;
+    const partB = partsB[i] || 0;
+    if (partA !== partB) {
+      return partA - partB;
+    }
+  }
+  return 0;
+}
+function listInstalledVersions() {
+  const baseDir = getElectronAppBaseDir();
+  const currentVersion = getElectronAppVersion();
+  const versions = [];
+  if (!existsSync(baseDir)) {
+    return versions;
+  }
+  try {
+    const entries = readdirSync(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      if (!/^\d+\.\d+\.\d+$/.test(entry.name)) {
+        continue;
+      }
+      const versionPath = path.join(baseDir, entry.name);
+      const sizeBytes = getDirectorySize(versionPath);
+      versions.push({
+        version: entry.name,
+        path: versionPath,
+        sizeBytes,
+        isCurrent: entry.name === currentVersion
+      });
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger2.warn("Failed to list installed versions", { error: errorMessage });
+  }
+  versions.sort((a, b) => compareVersions(b.version, a.version));
+  return versions;
+}
+function cleanupOldVersions(options = {}) {
+  const { all = false, dryRun = false } = options;
+  const versions = listInstalledVersions();
+  const removed = [];
+  let freedBytes = 0;
+  const versionsToKeep = all ? 1 : 2;
+  let keptCount = 0;
+  for (const version of versions) {
+    if (version.isCurrent) {
+      keptCount++;
+      continue;
+    }
+    if (keptCount < versionsToKeep) {
+      keptCount++;
+      continue;
+    }
+    if (!dryRun) {
+      try {
+        rmSync(version.path, { recursive: true, force: true });
+        logger2.info("Removed old version", {
+          version: version.version,
+          freedBytes: version.sizeBytes
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger2.error("Failed to remove version", {
+          version: version.version,
+          error: errorMessage
+        });
+        continue;
+      }
+    }
+    removed.push(version);
+    freedBytes += version.sizeBytes;
+  }
+  return { removed, freedBytes };
+}
+async function versionsCommand() {
+  console.log("\nInstalled Electron App Versions");
+  console.log("================================\n");
+  const versions = listInstalledVersions();
+  if (versions.length === 0) {
+    console.log("No versions installed.");
+    console.log("Run 'muggle setup' to download the Electron app.\n");
+    return;
+  }
+  let totalSize = 0;
+  for (const version of versions) {
+    const marker = version.isCurrent ? " (current)" : "";
+    const size = formatBytes(version.sizeBytes);
+    console.log(`  v${version.version}${marker} - ${size}`);
+    totalSize += version.sizeBytes;
+  }
+  console.log("");
+  console.log(`Total: ${versions.length} version(s), ${formatBytes(totalSize)}`);
+  console.log("");
+}
+async function cleanupCommand(options) {
+  let totalFreedBytes = 0;
+  let totalRemovedCount = 0;
+  console.log("\nElectron App Cleanup");
+  console.log("====================\n");
+  const versions = listInstalledVersions();
+  if (versions.length === 0) {
+    console.log("No versions installed. Nothing to clean up.\n");
+  } else if (versions.length === 1) {
+    console.log("Only the current version is installed. Nothing to clean up.\n");
+  } else {
+    const currentVersion = versions.find((v) => v.isCurrent);
+    const oldVersions = versions.filter((v) => !v.isCurrent);
+    console.log(`Current version: v${currentVersion?.version ?? "unknown"}`);
+    console.log(`Old versions: ${oldVersions.length}`);
+    console.log("");
+    if (options.dryRun) {
+      console.log("Dry run - showing what would be deleted:\n");
+    }
+    const result = cleanupOldVersions(options);
+    if (result.removed.length === 0) {
+      if (options.all) {
+        console.log("No old versions to remove.\n");
+      } else {
+        console.log("Keeping one previous version for rollback.");
+        console.log("Use --all to remove all old versions.\n");
+      }
+    } else {
+      console.log(options.dryRun ? "Would remove:" : "Removed:");
+      for (const version of result.removed) {
+        console.log(`  v${version.version} (${formatBytes(version.sizeBytes)})`);
+      }
+      totalFreedBytes += result.freedBytes;
+      totalRemovedCount += result.removed.length;
+      console.log("");
+    }
+  }
+  if (options.skills) {
+    console.log("Skills Cleanup");
+    console.log("==============\n");
+    const obsoleteSkills = listObsoleteSkills();
+    if (obsoleteSkills.length === 0) {
+      console.log("No obsolete skills found. Nothing to clean up.\n");
+    } else {
+      console.log(`Found ${obsoleteSkills.length} obsolete skill(s):
+`);
+      if (options.dryRun) {
+        console.log("Dry run - showing what would be deleted:\n");
+      }
+      const skillResult = cleanupObsoleteSkills({ dryRun: options.dryRun });
+      console.log(options.dryRun ? "Would remove:" : "Removed:");
+      for (const skill of skillResult.removed) {
+        console.log(`  ${skill.name} (${formatBytes(skill.sizeBytes)})`);
+      }
+      totalFreedBytes += skillResult.freedBytes;
+      totalRemovedCount += skillResult.removed.length;
+      console.log("");
+    }
+  }
+  if (totalRemovedCount > 0) {
+    console.log(
+      `${options.dryRun ? "Would free" : "Freed"}: ${formatBytes(totalFreedBytes)} total`
+    );
+    console.log("");
+    if (options.dryRun) {
+      console.log("Run without --dry-run to actually delete.\n");
+    }
+  }
+  logger2.info("Cleanup completed", {
+    removed: totalRemovedCount,
+    freedBytes: totalFreedBytes,
+    dryRun: options.dryRun,
+    includeSkills: options.skills
+  });
+}
+var logger3 = getLogger();
+function getCursorMcpConfigPath() {
+  return join(homedir(), ".cursor", "mcp.json");
+}
+function getExpectedExecutablePath(versionDir) {
+  const os = platform();
+  switch (os) {
+    case "darwin":
+      return path.join(versionDir, "MuggleAI.app", "Contents", "MacOS", "MuggleAI");
+    case "win32":
+      return path.join(versionDir, "MuggleAI.exe");
+    case "linux":
+      return path.join(versionDir, "MuggleAI");
+    default:
+      throw new Error(`Unsupported platform: ${os}`);
+  }
+}
+function verifyElectronAppInstallation() {
+  const version = getElectronAppVersion();
+  const versionDir = getElectronAppDir(version);
+  const executablePath = getExpectedExecutablePath(versionDir);
+  const metadataPath = path.join(versionDir, ".install-metadata.json");
+  const result = {
+    valid: false,
+    versionDir,
+    executablePath,
+    executableExists: false,
+    executableIsFile: false,
+    metadataExists: false,
+    hasPartialArchive: false
+  };
+  if (!fs.existsSync(versionDir)) {
+    result.errorDetail = "Version directory does not exist";
+    return result;
+  }
+  const archivePatterns = ["MuggleAI-darwin", "MuggleAI-win32", "MuggleAI-linux"];
+  try {
+    const files = fs.readdirSync(versionDir);
+    for (const file of files) {
+      if (archivePatterns.some((pattern) => file.startsWith(pattern)) && (file.endsWith(".zip") || file.endsWith(".tar.gz"))) {
+        result.hasPartialArchive = true;
+        break;
+      }
+    }
+  } catch {
+  }
+  result.executableExists = fs.existsSync(executablePath);
+  if (!result.executableExists) {
+    if (result.hasPartialArchive) {
+      result.errorDetail = "Download incomplete: archive found but not extracted";
+    } else {
+      result.errorDetail = "Executable not found at expected path";
+    }
+    return result;
+  }
+  try {
+    const stats = fs.statSync(executablePath);
+    result.executableIsFile = stats.isFile();
+    if (!result.executableIsFile) {
+      result.errorDetail = "Executable path exists but is not a file";
+      return result;
+    }
+  } catch {
+    result.errorDetail = "Cannot stat executable (broken symlink?)";
+    return result;
+  }
+  result.metadataExists = fs.existsSync(metadataPath);
+  result.valid = true;
+  return result;
+}
+function validateCursorMcpConfig() {
+  const cursorMcpConfigPath = getCursorMcpConfigPath();
+  if (!existsSync(cursorMcpConfigPath)) {
+    return {
+      passed: false,
+      description: `Missing at ${cursorMcpConfigPath}`
+    };
+  }
+  try {
+    const rawCursorConfig = JSON.parse(
+      readFileSync(cursorMcpConfigPath, "utf-8")
+    );
+    if (!rawCursorConfig.mcpServers) {
+      return {
+        passed: false,
+        description: "Missing mcpServers key"
+      };
+    }
+    const muggleServerConfig = rawCursorConfig.mcpServers.muggle;
+    if (!muggleServerConfig) {
+      return {
+        passed: false,
+        description: "Missing mcpServers.muggle entry"
+      };
+    }
+    if (!Array.isArray(muggleServerConfig.args)) {
+      return {
+        passed: false,
+        description: "mcpServers.muggle.args is not an array"
+      };
+    }
+    const hasServeArgument = muggleServerConfig.args.includes("serve");
+    if (!hasServeArgument) {
+      return {
+        passed: false,
+        description: "mcpServers.muggle args does not include 'serve'"
+      };
+    }
+    if (muggleServerConfig.command === "node") {
+      const firstArgument = muggleServerConfig.args.at(0);
+      if (!firstArgument) {
+        return {
+          passed: false,
+          description: "mcpServers.muggle command is node but args[0] is missing"
+        };
+      }
+      if (!existsSync(firstArgument)) {
+        return {
+          passed: false,
+          description: `mcpServers.muggle args[0] does not exist: ${firstArgument}`
+        };
+      }
+    }
+    return {
+      passed: true,
+      description: `Configured at ${cursorMcpConfigPath}`
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      passed: false,
+      description: `Invalid JSON or schema: ${errorMessage}`
+    };
+  }
+}
+function runDiagnostics() {
+  const results = [];
+  const config = getConfig();
+  const dataDir = getDataDir();
+  results.push({
+    name: "Data Directory",
+    passed: existsSync(dataDir),
+    description: existsSync(dataDir) ? `Found at ${dataDir}` : `Not found at ${dataDir}`,
+    suggestion: "Run 'muggle login' to create the data directory"
+  });
+  const electronVersion = getElectronAppVersion();
+  const bundledVersion = getBundledElectronAppVersion();
+  const versionSource = getElectronAppVersionSource();
+  const installVerification = verifyElectronAppInstallation();
+  let electronDescription;
+  let electronSuggestion;
+  if (installVerification.valid) {
+    electronDescription = `Installed (v${electronVersion})`;
+    switch (versionSource) {
+      case "env":
+        electronDescription += ` [from ELECTRON_APP_VERSION env]`;
+        break;
+      case "override":
+        electronDescription += ` [overridden from bundled v${bundledVersion}]`;
+        break;
+    }
+    if (!installVerification.metadataExists) {
+      electronDescription += " [missing metadata]";
+    }
+  } else {
+    electronDescription = `Not installed (expected v${electronVersion})`;
+    if (installVerification.errorDetail) {
+      electronDescription += `
+  \u2514\u2500 ${installVerification.errorDetail}`;
+      electronDescription += `
+  \u2514\u2500 Checked: ${installVerification.versionDir}`;
+    }
+    if (installVerification.hasPartialArchive) {
+      electronSuggestion = "Run 'muggle setup --force' to re-download and extract";
+    } else {
+      electronSuggestion = "Run 'muggle setup' to download the Electron app";
+    }
+  }
+  results.push({
+    name: "Electron App",
+    passed: installVerification.valid,
+    description: electronDescription,
+    suggestion: electronSuggestion
+  });
+  if (installVerification.valid) {
+    results.push({
+      name: "Electron App Updates",
+      passed: true,
+      description: "Run 'muggle upgrade --check' to check for updates"
+    });
+  }
+  const authService = getAuthService();
+  const authStatus = authService.getAuthStatus();
+  results.push({
+    name: "Authentication",
+    passed: authStatus.authenticated,
+    description: authStatus.authenticated ? `Authenticated as ${authStatus.email ?? "unknown"}` : "Not authenticated",
+    suggestion: "Run 'muggle login' to authenticate"
+  });
+  const hasStoredApiKey = hasApiKey();
+  results.push({
+    name: "API Key",
+    passed: hasStoredApiKey,
+    description: hasStoredApiKey ? "API key stored" : "No API key stored (optional)",
+    suggestion: "Run 'muggle login --key-name <name>' to generate an API key"
+  });
+  const credentialsPath = getCredentialsFilePath();
+  results.push({
+    name: "Credentials File",
+    passed: existsSync(credentialsPath),
+    description: existsSync(credentialsPath) ? `Found at ${credentialsPath}` : `Not found at ${credentialsPath}`,
+    suggestion: "Run 'muggle login' to create credentials"
+  });
+  results.push({
+    name: "Prompt Service URL",
+    passed: !!config.e2e.promptServiceBaseUrl,
+    description: config.e2e.promptServiceBaseUrl
+  });
+  results.push({
+    name: "Web Service URL",
+    passed: !!config.localQa.webServiceUrl,
+    description: config.localQa.webServiceUrl
+  });
+  const cursorMcpConfigValidationResult = validateCursorMcpConfig();
+  results.push({
+    name: "Cursor MCP Config",
+    passed: cursorMcpConfigValidationResult.passed,
+    description: cursorMcpConfigValidationResult.description,
+    suggestion: "Re-run npm install -g @muggleai/works to refresh ~/.cursor/mcp.json"
+  });
+  return results;
+}
+function formatCheckResult(result) {
+  const icon = result.passed ? "\u2713" : "\u2717";
+  const color = result.passed ? "\x1B[32m" : "\x1B[31m";
+  const reset = "\x1B[0m";
+  let output = `${color}${icon}${reset} ${result.name}: ${result.description}`;
+  if (!result.passed && result.suggestion) {
+    output += `
+  \u2514\u2500 ${result.suggestion}`;
+  }
+  return output;
+}
+async function doctorCommand() {
+  console.log("\nMuggle Works Doctor");
+  console.log("=================\n");
+  const results = runDiagnostics();
+  for (const result of results) {
+    console.log(formatCheckResult(result));
+  }
+  console.log("");
+  const failedCount = results.filter((r) => !r.passed).length;
+  if (failedCount === 0) {
+    console.log("All checks passed! Your installation is ready.");
+  } else {
+    console.log(`${failedCount} issue(s) found. See suggestions above.`);
+  }
+  logger3.info("Doctor command completed", {
+    totalChecks: results.length,
+    passed: results.length - failedCount,
+    failed: failedCount
+  });
+}
+
+// src/cli/help.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m"};
+function colorize(text, color) {
+  if (process.env.NO_COLOR) {
+    return text;
+  }
+  return `${color}${text}${COLORS.reset}`;
+}
+function header(title) {
+  return colorize(`
+${title}`, COLORS.bold + COLORS.cyan);
+}
+function cmd(cmd2) {
+  return colorize(cmd2, COLORS.green);
+}
+function path3(path6) {
+  return colorize(path6, COLORS.yellow);
+}
+function getHelpGuidance() {
+  const lines = [
+    "",
+    colorize("=".repeat(70), COLORS.cyan),
+    colorize("  Muggle AI Works - Comprehensive How-To Guide", COLORS.bold + COLORS.green),
+    colorize("=".repeat(70), COLORS.cyan),
+    "",
+    header("What is Muggle AI Works?"),
+    "",
+    "  Muggle AI Works is a Model Context Protocol server that provides AI",
+    "  assistants with tools to perform automated end-to-end (E2E) acceptance testing of web applications.",
+    "",
+    "  It supports both:",
+    `    ${colorize("\u2022", COLORS.green)} Cloud E2E - Test remote production/staging sites with a public URL`,
+    `    ${colorize("\u2022", COLORS.green)} Local E2E - Test localhost development servers`,
+    "",
+    header("Setup Instructions"),
+    "",
+    `  ${colorize("Step 1:", COLORS.bold)} Configure your MCP client`,
+    "",
+    `    For ${colorize("Cursor", COLORS.bold)}, edit ${path3("~/.cursor/mcp.json")}:`,
+    "",
+    `    ${colorize("{", COLORS.dim)}`,
+    `      ${colorize('"mcpServers"', COLORS.yellow)}: {`,
+    `        ${colorize('"muggle"', COLORS.yellow)}: {`,
+    `          ${colorize('"command"', COLORS.yellow)}: ${colorize('"muggle"', COLORS.green)},`,
+    `          ${colorize('"args"', COLORS.yellow)}: [${colorize('"serve"', COLORS.green)}]`,
+    `        }`,
+    `      }`,
+    `    ${colorize("}", COLORS.dim)}`,
+    "",
+    `  ${colorize("Step 2:", COLORS.bold)} Restart your MCP client`,
+    "",
+    `  ${colorize("Step 3:", COLORS.bold)} Start testing! Ask your AI assistant:`,
+    `    ${colorize('"Test the login flow on my app at http://localhost:3000"', COLORS.dim)}`,
+    "",
+    header("CLI Commands"),
+    "",
+    `  ${colorize("Server Commands:", COLORS.bold)}`,
+    `    ${cmd("muggle serve")}            Start MCP server with all tools`,
+    `    ${cmd("muggle serve --e2e")}      Start with cloud E2E tools only`,
+    `    ${cmd("muggle serve --local")}    Start with local E2E tools only`,
+    "",
+    `  ${colorize("Setup & Diagnostics:", COLORS.bold)}`,
+    `    ${cmd("muggle setup")}            Download/update Electron app`,
+    `    ${cmd("muggle setup --force")}    Force re-download`,
+    `    ${cmd("muggle doctor")}           Diagnose installation issues`,
+    `    ${cmd("muggle upgrade")}          Check for updates`,
+    `    ${cmd("muggle upgrade --check")}  Check updates without installing`,
+    "",
+    `  ${colorize("Authentication:", COLORS.bold)}`,
+    `    ${cmd("muggle login")}            Login to Muggle AI`,
+    `    ${cmd("muggle logout")}           Clear stored credentials`,
+    `    ${cmd("muggle status")}           Show authentication status`,
+    "",
+    `  ${colorize("Maintenance:", COLORS.bold)}`,
+    `    ${cmd("muggle versions")}         List installed Electron app versions`,
+    `    ${cmd("muggle cleanup")}          Remove old Electron app versions`,
+    `    ${cmd("muggle cleanup --all")}    Remove all old versions`,
+    `    ${cmd("muggle cleanup --skills")} Also remove obsolete skills`,
+    "",
+    `  ${colorize("Help:", COLORS.bold)}`,
+    `    ${cmd("muggle help")}             Show this guide`,
+    `    ${cmd("muggle --help")}           Show command synopsis`,
+    `    ${cmd("muggle --version")}        Show version`,
+    "",
+    header("Authentication Flow"),
+    "",
+    "  Authentication happens automatically when you first use a tool that",
+    "  requires it:",
+    "",
+    `    1. ${colorize("A browser window opens", COLORS.bold)} with a verification code`,
+    `    2. ${colorize("Log in", COLORS.bold)} with your Muggle AI account`,
+    `    3. ${colorize("The tool call continues", COLORS.bold)} with your credentials`,
+    "",
+    `  API keys are stored in ${path3("~/.muggle-ai/api-key.json")}`,
+    "",
+    header("Available MCP Tools"),
+    "",
+    `  ${colorize("Cloud E2E tools:", COLORS.bold)} (prefix: muggle-remote-)`,
+    "    muggle-remote-project-create, muggle-remote-project-list, muggle-remote-use-case-create-from-prompts,",
+    "    muggle-remote-test-case-generate-from-prompt, muggle-remote-workflow-start-*, etc.",
+    "",
+    `  ${colorize("Local E2E tools:", COLORS.bold)} (prefix: muggle-local-)`,
+    "    muggle-local-execute-test-generation, muggle-local-execute-replay,",
+    "    muggle-local-publish-test-script, muggle-local-run-result-get,",
+    "    muggle-local-check-status, etc.",
+    "",
+    header("Data Directory"),
+    "",
+    `  All data is stored in ${path3("~/.muggle-ai/")}:`,
+    "",
+    `    ${path3("api-key.json")}         Long-lived API key (auto-generated)`,
+    `    ${path3("projects/")}            Local test projects`,
+    `    ${path3("sessions/")}            Test execution sessions`,
+    `    ${path3("electron-app/")}        Downloaded Electron app binaries`,
+    "",
+    header("Troubleshooting"),
+    "",
+    `  ${colorize("Installation issues:", COLORS.bold)}`,
+    `    Run ${cmd("muggle doctor")} to diagnose problems`,
+    "",
+    `  ${colorize("Electron app not found:", COLORS.bold)}`,
+    `    Run ${cmd("muggle setup --force")} to re-download`,
+    "",
+    `  ${colorize("Authentication issues:", COLORS.bold)}`,
+    `    Run ${cmd("muggle logout")} then ${cmd("muggle login")}`,
+    "",
+    `  ${colorize("MCP not working in client:", COLORS.bold)}`,
+    "    1. Verify mcp.json configuration",
+    "    2. Restart your MCP client",
+    `    3. Check ${cmd("muggle doctor")} output`,
+    "",
+    header("Documentation & Support"),
+    "",
+    `  Docs:    ${colorize("https://www.muggle-ai.com/muggleTestV0/docs/mcp/mcp-overview", COLORS.blue)}`,
+    `  GitHub:  ${colorize("https://github.com/multiplex-ai/muggle-ai-works", COLORS.blue)}`,
+    "",
+    colorize("=".repeat(70), COLORS.cyan),
+    ""
+  ];
+  return lines.join("\n");
+}
+function helpCommand() {
+  console.log(getHelpGuidance());
+}
+
+// src/cli/login.ts
+var logger4 = getLogger();
+async function loginCommand(options) {
+  console.log("\nMuggle AI Login");
+  console.log("===============\n");
+  const expiry = options.keyExpiry || "90d";
+  console.log("Starting device code authentication...");
+  console.log("A browser window will open for you to complete login.\n");
+  const result = await performLogin(options.keyName, expiry);
+  if (result.success) {
+    console.log("\u2713 Login successful!");
+    if (result.credentials?.email) {
+      console.log(`  Logged in as: ${result.credentials.email}`);
+    }
+    if (result.credentials?.apiKey) {
+      console.log("  API key created and stored for future use.");
+    }
+    console.log("\nYou can now use Muggle AI Works tools.");
+  } else {
+    console.error("\u2717 Login failed");
+    if (result.error) {
+      console.error(`  Error: ${result.error}`);
+    }
+    if (result.deviceCodeResponse) {
+      console.log("\nIf browser didn't open, visit:");
+      console.log(`  ${result.deviceCodeResponse.verificationUriComplete}`);
+      console.log(`  Code: ${result.deviceCodeResponse.userCode}`);
+    }
+    process.exit(1);
+  }
+}
+async function logoutCommand() {
+  console.log("\nLogging out...");
+  performLogout();
+  console.log("\u2713 Credentials cleared successfully.");
+  logger4.info("Logout completed");
+}
+async function statusCommand() {
+  console.log("\nAuthentication Status");
+  console.log("=====================\n");
+  const authService = getAuthService();
+  const status = authService.getAuthStatus();
+  const hasStoredApiKey = hasApiKey();
+  if (status.authenticated) {
+    console.log("\u2713 Authenticated");
+    if (status.email) {
+      console.log(`  Email: ${status.email}`);
+    }
+    if (status.userId) {
+      console.log(`  User ID: ${status.userId}`);
+    }
+    if (status.expiresAt) {
+      const expiresDate = new Date(status.expiresAt);
+      console.log(`  Token expires: ${expiresDate.toLocaleString()}`);
+      if (status.isExpired) {
+        console.log("  (Token expired - will refresh automatically on next API call)");
+      }
+    }
+    console.log(`  API Key: ${hasStoredApiKey ? "Yes" : "No"}`);
+  } else {
+    console.log("\u2717 Not authenticated");
+    console.log("\nRun 'muggle login' to authenticate.");
+  }
+}
+
+// src/cli/serve.ts
+var logger5 = getLogger();
+async function serveCommand(options) {
+  const config = getConfig();
+  const enableQa = options.local ? false : true;
+  const enableLocal = options.e2e ? false : true;
+  logger5.info("Starting Muggle MCP Server", {
+    version: config.serverVersion,
+    enableQa,
+    enableLocal,
+    transport: "stdio"
+  });
+  try {
+    if (enableQa) {
+      const qaTools = getQaTools();
+      registerTools(qaTools);
+      logger5.info("Registered cloud E2E acceptance tools", { count: qaTools.length });
+    }
+    if (enableLocal) {
+      const localTools = getLocalQaTools();
+      registerTools(localTools);
+      logger5.info("Registered local E2E acceptance tools", { count: localTools.length });
+    }
+    const mcpServer = createUnifiedMcpServer({
+      enableQaTools: enableQa,
+      enableLocalTools: enableLocal
+    });
+    await startStdioServer(mcpServer);
+    logger5.info("MCP server started successfully");
+  } catch (error) {
+    logger5.error("Failed to start MCP server", {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
+    process.exit(1);
+  }
+}
+var logger6 = getLogger();
+var MAX_RETRY_ATTEMPTS = 3;
+var RETRY_BASE_DELAY_MS = 2e3;
+var INSTALL_METADATA_FILE_NAME = ".install-metadata.json";
+function getBinaryName() {
+  const os = platform();
+  const architecture = arch();
+  switch (os) {
+    case "darwin": {
+      const darwinArch = architecture === "arm64" ? "arm64" : "x64";
+      return `MuggleAI-darwin-${darwinArch}.zip`;
+    }
+    case "win32":
+      return "MuggleAI-win32-x64.zip";
+    case "linux":
+      return "MuggleAI-linux-x64.zip";
+    default:
+      throw new Error(`Unsupported platform: ${os}`);
+  }
+}
+function getExpectedExecutablePath2(versionDir) {
+  const os = platform();
+  switch (os) {
+    case "darwin":
+      return path.join(versionDir, "MuggleAI.app", "Contents", "MacOS", "MuggleAI");
+    case "win32":
+      return path.join(versionDir, "MuggleAI.exe");
+    case "linux":
+      return path.join(versionDir, "MuggleAI");
+    default:
+      throw new Error(`Unsupported platform: ${os}`);
+  }
+}
+async function extractZip(zipPath, destDir) {
+  return new Promise((resolve2, reject) => {
+    if (platform() === "win32") {
+      execFile(
+        "powershell",
+        ["-command", `Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force`],
+        (error) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve2();
+          }
+        }
+      );
+    } else {
+      execFile("unzip", ["-o", zipPath, "-d", destDir], (error) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve2();
+        }
+      });
+    }
+  });
+}
+async function extractTarGz(tarPath, destDir) {
+  return new Promise((resolve2, reject) => {
+    execFile("tar", ["-xzf", tarPath, "-C", destDir], (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve2();
+      }
+    });
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function downloadWithRetry(downloadUrl, destPath) {
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS; attempt++) {
+    try {
+      if (attempt > 1) {
+        const delayMs = RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 2);
+        console.log(`Retry attempt ${attempt}/${MAX_RETRY_ATTEMPTS} after ${delayMs}ms delay...`);
+        await sleep(delayMs);
+      }
+      const response = await fetch(downloadUrl);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      if (!response.body) {
+        throw new Error("No response body received");
+      }
+      const fileStream = createWriteStream(destPath);
+      await pipeline(response.body, fileStream);
+      return true;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      console.error(`Download attempt ${attempt} failed: ${lastError.message}`);
+      if (existsSync(destPath)) {
+        rmSync(destPath, { force: true });
+      }
+    }
+  }
+  if (lastError) {
+    throw new Error(`Download failed after ${MAX_RETRY_ATTEMPTS} attempts: ${lastError.message}`);
+  }
+  return false;
+}
+function writeInstallMetadata(params) {
+  const metadata = {
+    version: params.version,
+    binaryName: params.binaryName,
+    platformKey: params.platformKey,
+    executableChecksum: params.executableChecksum,
+    expectedArchiveChecksum: params.expectedArchiveChecksum,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync(params.metadataPath, `${JSON.stringify(metadata, null, 2)}
+`, "utf-8");
+}
+function cleanupFailedInstall(versionDir) {
+  if (existsSync(versionDir)) {
+    try {
+      rmSync(versionDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+async function setupCommand(options) {
+  const version = getElectronAppVersion();
+  const versionDir = getElectronAppDir(version);
+  const platformKey = getPlatformKey();
+  if (!options.force && isElectronAppInstalled()) {
+    console.log(`Electron app v${version} is already installed at ${versionDir}`);
+    console.log("Use --force to re-download.");
+    return;
+  }
+  const binaryName = getBinaryName();
+  const downloadUrl = buildElectronAppReleaseAssetUrl({
+    version,
+    assetFileName: binaryName
+  });
+  console.log(`Downloading Muggle Test Electron app v${version}...`);
+  console.log(`URL: ${downloadUrl}`);
+  try {
+    if (existsSync(versionDir)) {
+      rmSync(versionDir, { recursive: true, force: true });
+    }
+    mkdirSync(versionDir, { recursive: true });
+    const tempFile = path.join(versionDir, binaryName);
+    await downloadWithRetry(downloadUrl, tempFile);
+    console.log("Download complete, verifying checksum...");
+    const checksums = getElectronAppChecksums();
+    const expectedChecksum = getChecksumForPlatform(checksums);
+    const checksumResult = await verifyFileChecksum(tempFile, expectedChecksum);
+    if (!checksumResult.valid && expectedChecksum) {
+      cleanupFailedInstall(versionDir);
+      throw new Error(
+        `Checksum verification failed!
+Expected: ${checksumResult.expected}
+Actual:   ${checksumResult.actual}
+The downloaded file may be corrupted or tampered with.`
+      );
+    }
+    if (expectedChecksum) {
+      console.log("Checksum verified successfully.");
+    } else {
+      console.log("Warning: No checksum configured, skipping verification.");
+    }
+    console.log("Extracting...");
+    if (binaryName.endsWith(".zip")) {
+      await extractZip(tempFile, versionDir);
+    } else if (binaryName.endsWith(".tar.gz")) {
+      await extractTarGz(tempFile, versionDir);
+    }
+    const executablePath = getExpectedExecutablePath2(versionDir);
+    if (!existsSync(executablePath)) {
+      cleanupFailedInstall(versionDir);
+      throw new Error(
+        `Extraction failed: executable not found at expected path.
+Expected: ${executablePath}
+The archive may be corrupted or in an unexpected format.`
+      );
+    }
+    const executableChecksum = await calculateFileChecksum(executablePath);
+    const metadataPath = path.join(versionDir, INSTALL_METADATA_FILE_NAME);
+    writeInstallMetadata({
+      metadataPath,
+      version,
+      binaryName,
+      platformKey,
+      executableChecksum,
+      expectedArchiveChecksum: expectedChecksum
+    });
+    rmSync(tempFile, { force: true });
+    console.log(`Electron app installed to ${versionDir}`);
+    logger6.info("Setup complete", { version, path: versionDir });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to download Electron app: ${errorMessage}`);
+    logger6.error("Setup failed", { error: errorMessage });
+    process.exit(1);
+  }
+}
+var logger7 = getLogger();
+var GITHUB_RELEASES_API = "https://api.github.com/repos/multiplex-ai/muggle-ai-works/releases";
+var INSTALL_METADATA_FILE_NAME2 = ".install-metadata.json";
+var VERSION_OVERRIDE_FILE = "electron-app-version-override.json";
+function getBinaryName2() {
+  const os = platform();
+  const arch2 = process.arch;
+  switch (os) {
+    case "darwin":
+      return arch2 === "arm64" ? "MuggleAI-darwin-arm64.zip" : "MuggleAI-darwin-x64.zip";
+    case "win32":
+      return "MuggleAI-win32-x64.zip";
+    case "linux":
+      return "MuggleAI-linux-x64.zip";
+    default:
+      throw new Error(`Unsupported platform: ${os}`);
+  }
+}
+function extractVersionFromTag(tag) {
+  const match = tag.match(/^(?:electron-app-)?v(\d+\.\d+\.\d+)$/);
+  return match ? match[1] : null;
+}
+function getVersionOverridePath() {
+  return path.join(getDataDir(), VERSION_OVERRIDE_FILE);
+}
+function getEffectiveElectronAppVersion() {
+  const overridePath = getVersionOverridePath();
+  if (existsSync(overridePath)) {
+    try {
+      const content = JSON.parse(__require("fs").readFileSync(overridePath, "utf-8"));
+      if (content.version) {
+        return content.version;
+      }
+    } catch {
+    }
+  }
+  return getElectronAppVersion();
+}
+function saveVersionOverride(version) {
+  const overridePath = getVersionOverridePath();
+  const dataDir = getDataDir();
+  if (!existsSync(dataDir)) {
+    mkdirSync(dataDir, { recursive: true });
+  }
+  writeFileSync(overridePath, JSON.stringify({
+    version,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }, null, 2), "utf-8");
+}
+async function checkForUpdates() {
+  const currentVersion = getEffectiveElectronAppVersion();
+  try {
+    const response = await fetch(GITHUB_RELEASES_API, {
+      headers: {
+        "Accept": "application/vnd.github.v3+json",
+        "User-Agent": "muggle"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+    }
+    const releases = await response.json();
+    for (const release of releases) {
+      if (release.prerelease || release.draft) {
+        continue;
+      }
+      const version = extractVersionFromTag(release.tag_name);
+      if (version) {
+        const updateAvailable = compareVersions2(version, currentVersion) > 0;
+        const binaryName = getBinaryName2();
+        return {
+          currentVersion,
+          latestVersion: version,
+          updateAvailable,
+          downloadUrl: buildElectronAppReleaseAssetUrl({
+            version,
+            assetFileName: binaryName
+          })
+        };
+      }
+    }
+    return {
+      currentVersion,
+      latestVersion: currentVersion,
+      updateAvailable: false
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger7.warn("Failed to check for updates", { error: errorMessage });
+    throw new Error(`Failed to check for updates: ${errorMessage}`, { cause: error });
+  }
+}
+function compareVersions2(a, b) {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const partA = partsA[i] || 0;
+    const partB = partsB[i] || 0;
+    if (partA > partB) {
+      return 1;
+    }
+    if (partA < partB) {
+      return -1;
+    }
+  }
+  return 0;
+}
+function getExpectedExecutablePath3(versionDir) {
+  const os = platform();
+  switch (os) {
+    case "darwin":
+      return path.join(versionDir, "MuggleAI.app", "Contents", "MacOS", "MuggleAI");
+    case "win32":
+      return path.join(versionDir, "MuggleAI.exe");
+    case "linux":
+      return path.join(versionDir, "MuggleAI");
+    default:
+      throw new Error(`Unsupported platform: ${os}`);
+  }
+}
+function writeInstallMetadata2(params) {
+  const metadata = {
+    version: params.version,
+    binaryName: params.binaryName,
+    platformKey: params.platformKey,
+    executableChecksum: params.executableChecksum,
+    expectedArchiveChecksum: params.expectedArchiveChecksum,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync(params.metadataPath, `${JSON.stringify(metadata, null, 2)}
+`, "utf-8");
+}
+async function extractZip2(zipPath, destDir) {
+  return new Promise((resolve2, reject) => {
+    if (platform() === "win32") {
+      execFile(
+        "powershell",
+        ["-command", `Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force`],
+        (error) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve2();
+          }
+        }
+      );
+    } else {
+      execFile("unzip", ["-o", zipPath, "-d", destDir], (error) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve2();
+        }
+      });
+    }
+  });
+}
+async function extractTarGz2(tarPath, destDir) {
+  return new Promise((resolve2, reject) => {
+    execFile("tar", ["-xzf", tarPath, "-C", destDir], (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve2();
+      }
+    });
+  });
+}
+async function fetchChecksumFromRelease(version) {
+  const checksumUrl = buildElectronAppChecksumsUrl(version);
+  try {
+    const response = await fetch(checksumUrl);
+    if (!response.ok) {
+      logger7.warn("Checksums file not found in release", { version });
+      return "";
+    }
+    const text = await response.text();
+    const binaryName = getBinaryName2();
+    const platformKey = getPlatformKey();
+    const lines = text.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        continue;
+      }
+      const match = trimmed.match(/^([a-fA-F0-9]{64})\s+(.+)$/);
+      if (match) {
+        const checksum = match[1];
+        const filename = match[2];
+        if (filename === binaryName || filename.includes(platformKey)) {
+          logger7.info("Found checksum in release", {
+            version,
+            platform: platformKey,
+            checksum: checksum.substring(0, 16) + "..."
+          });
+          return checksum;
+        }
+      }
+    }
+    logger7.warn("Platform checksum not found in checksums.txt", {
+      version,
+      platform: platformKey
+    });
+    return "";
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger7.warn("Failed to fetch checksums from release", {
+      version,
+      error: errorMessage
+    });
+    return "";
+  }
+}
+async function downloadAndInstall(version, downloadUrl, checksum) {
+  const versionDir = getElectronAppDir(version);
+  const binaryName = getBinaryName2();
+  const platformKey = getPlatformKey();
+  console.log(`Downloading Muggle Test Electron app v${version}...`);
+  console.log(`URL: ${downloadUrl}`);
+  if (existsSync(versionDir)) {
+    rmSync(versionDir, { recursive: true, force: true });
+  }
+  mkdirSync(versionDir, { recursive: true });
+  const response = await fetch(downloadUrl);
+  if (!response.ok) {
+    throw new Error(`Download failed: ${response.status} ${response.statusText}`);
+  }
+  const tempFile = path.join(versionDir, binaryName);
+  const fileStream = createWriteStream(tempFile);
+  if (!response.body) {
+    throw new Error("No response body");
+  }
+  await pipeline(response.body, fileStream);
+  console.log("Download complete, verifying checksum...");
+  let expectedChecksum = checksum;
+  if (!expectedChecksum) {
+    expectedChecksum = await fetchChecksumFromRelease(version);
+  }
+  const checksumResult = await verifyFileChecksum(tempFile, expectedChecksum || "");
+  if (!checksumResult.valid && expectedChecksum) {
+    rmSync(versionDir, { recursive: true, force: true });
+    throw new Error(
+      `Checksum verification failed!
+Expected: ${checksumResult.expected}
+Actual:   ${checksumResult.actual}
+The downloaded file may be corrupted or tampered with.`
+    );
+  }
+  if (expectedChecksum) {
+    console.log("Checksum verified successfully.");
+  } else {
+    console.log("Warning: No checksum available, skipping verification.");
+  }
+  console.log("Extracting...");
+  if (binaryName.endsWith(".zip")) {
+    await extractZip2(tempFile, versionDir);
+  } else if (binaryName.endsWith(".tar.gz")) {
+    await extractTarGz2(tempFile, versionDir);
+  }
+  const executablePath = getExpectedExecutablePath3(versionDir);
+  if (!existsSync(executablePath)) {
+    rmSync(versionDir, { recursive: true, force: true });
+    throw new Error(
+      `Extraction failed: executable not found at expected path.
+Expected: ${executablePath}
+The archive may be corrupted or in an unexpected format.`
+    );
+  }
+  const executableChecksum = await calculateFileChecksum(executablePath);
+  const metadataPath = path.join(versionDir, INSTALL_METADATA_FILE_NAME2);
+  writeInstallMetadata2({
+    metadataPath,
+    version,
+    binaryName,
+    platformKey,
+    executableChecksum,
+    expectedArchiveChecksum: expectedChecksum || ""
+  });
+  rmSync(tempFile, { force: true });
+  saveVersionOverride(version);
+  console.log(`Electron app v${version} installed to ${versionDir}`);
+  logger7.info("Upgrade complete", { version, path: versionDir });
+}
+async function upgradeCommand(options) {
+  try {
+    if (options.version) {
+      const binaryName = getBinaryName2();
+      const downloadUrl = buildElectronAppReleaseAssetUrl({
+        version: options.version,
+        assetFileName: binaryName
+      });
+      await downloadAndInstall(options.version, downloadUrl);
+      const cleanupResult2 = cleanupOldVersions({ all: false });
+      if (cleanupResult2.removed.length > 0) {
+        console.log(
+          `
+Cleaned up ${cleanupResult2.removed.length} old version(s), freed ${formatBytes(cleanupResult2.freedBytes)}`
+        );
+      }
+      return;
+    }
+    console.log("Checking for updates...");
+    const result = await checkForUpdates();
+    console.log(`Current version: ${result.currentVersion}`);
+    console.log(`Latest version:  ${result.latestVersion}`);
+    if (options.check) {
+      if (result.updateAvailable) {
+        console.log("\nUpdate available! Run 'muggle upgrade' to install.");
+      } else {
+        console.log("\nYou are on the latest version.");
+      }
+      return;
+    }
+    if (!result.updateAvailable && !options.force) {
+      console.log("\nYou are already on the latest version.");
+      console.log("Use --force to re-download the current version.");
+      return;
+    }
+    if (!result.downloadUrl) {
+      throw new Error("No download URL available");
+    }
+    await downloadAndInstall(result.latestVersion, result.downloadUrl);
+    const cleanupResult = cleanupOldVersions({ all: false });
+    if (cleanupResult.removed.length > 0) {
+      console.log(
+        `
+Cleaned up ${cleanupResult.removed.length} old version(s), freed ${formatBytes(cleanupResult.freedBytes)}`
+      );
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`Upgrade failed: ${errorMessage}`);
+    logger7.error("Upgrade failed", { error: errorMessage });
+    process.exit(1);
+  }
+}
+
+// packages/commands/src/cli/run-cli.ts
+var __dirname$1 = dirname(fileURLToPath(import.meta.url));
+function getPackageRoot() {
+  if (__dirname$1.endsWith("dist")) {
+    return resolve(__dirname$1, "..");
+  }
+  return resolve(__dirname$1, "..", "..", "..", "..");
+}
+var packageVersion = JSON.parse(
+  readFileSync(resolve(getPackageRoot(), "package.json"), "utf-8")
+).version;
+var logger8 = getLogger();
+function createProgram() {
+  const program = new Command();
+  program.name("muggle").description("Unified MCP server for Muggle AI \u2014 cloud E2E and local E2E testing").version(packageVersion);
+  program.command("serve").description("Start the MCP server").option("--e2e", "Only enable cloud E2E tools (remote URLs; muggle-remote-* prefix)").option("--local", "Only enable local E2E tools (localhost; muggle-local-* prefix)").option("--stdio", "Use stdio transport (default)").action(serveCommand);
+  program.command("setup").description("Download/update the Electron app for local testing").option("--force", "Force re-download even if already installed").action(setupCommand);
+  program.command("upgrade").description("Check for and install the latest electron-app version").option("--force", "Force re-download even if already on latest").option("--check", "Check for updates only, don't download").option("--version <version>", "Download a specific version (e.g., 1.0.2)").action(upgradeCommand);
+  program.command("versions").description("List installed electron-app versions").action(versionsCommand);
+  program.command("cleanup").description("Remove old electron-app versions and obsolete skills").option("--all", "Remove all old versions (default: keep one previous)").option("--dry-run", "Show what would be deleted without deleting").option("--skills", "Also clean up obsolete skills from ~/.cursor/skills").action(cleanupCommand);
+  program.command("doctor").description("Diagnose installation and configuration issues").action(doctorCommand);
+  program.command("login").description("Authenticate with Muggle AI (uses device code flow)").option("--key-name <name>", "Name for the API key").option("--key-expiry <expiry>", "API key expiry: 30d, 90d, 1y, never", "90d").action(loginCommand);
+  program.command("logout").description("Clear stored credentials").action(logoutCommand);
+  program.command("status").description("Show authentication status").action(statusCommand);
+  program.command("build-pr-section").description("Render a muggle-do PR body evidence block from an e2e report on stdin").option("--max-body-bytes <n>", "Max UTF-8 byte budget for the PR body (default 60000)").action(buildPrSectionCommand);
+  program.action(() => {
+    helpCommand();
+  });
+  program.on("command:*", () => {
+    helpCommand();
+    process.exit(1);
+  });
+  return program;
+}
+function handleHelpCommand() {
+  const args = process.argv.slice(2);
+  if (args.length === 1 && args[0] === "help") {
+    helpCommand();
+    return true;
+  }
+  return false;
+}
+async function runCli() {
+  try {
+    if (handleHelpCommand()) {
+      return;
+    }
+    const program = createProgram();
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    logger8.error("CLI error", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    process.exit(1);
+  }
+}
+
+// packages/commands/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  cleanupCommand: () => cleanupCommand,
+  doctorCommand: () => doctorCommand,
+  helpCommand: () => helpCommand,
+  loginCommand: () => loginCommand,
+  logoutCommand: () => logoutCommand,
+  registerCoreCommands: () => registerCoreCommands,
+  runCli: () => runCli,
+  serveCommand: () => serveCommand,
+  setupCommand: () => setupCommand,
+  statusCommand: () => statusCommand,
+  upgradeCommand: () => upgradeCommand,
+  versionsCommand: () => versionsCommand
+});
+
+// packages/commands/src/registry/register-core-commands.ts
+function registerCoreCommands(commandRegistrationContext) {
+}
+
+export { createUnifiedMcpServer, runCli, server_exports, src_exports };