@primeuicom/mcp 0.1.25 → 0.1.26

package/dist/service.js

@@ -3,14 +3,212 @@
 // src/service.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
-// src/runtime.ts
+// src/cli.ts
+import path2 from "path";
+
+// src/package-metadata.ts
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { z } from "zod";
+var packageMetadataSchema = z.object({
+  name: z.string().trim().min(1),
+  version: z.string().trim().min(1),
+  description: z.string().trim().min(1)
+});
+function loadPackageMetadata() {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const currentDir = path.dirname(currentFilePath);
+  const packageJsonPath = path.resolve(currentDir, "../package.json");
+  let rawPackageJson = "";
+  try {
+    rawPackageJson = readFileSync(packageJsonPath, "utf-8");
+  } catch (error) {
+    throw new Error(
+      `[primeui-mcp] failed to read package.json at ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  let parsedPackageJson;
+  try {
+    parsedPackageJson = JSON.parse(rawPackageJson);
+  } catch (error) {
+    throw new Error(
+      `[primeui-mcp] invalid package.json at ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const parsed = packageMetadataSchema.safeParse(parsedPackageJson);
+  if (!parsed.success) {
+    const details = parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
+    throw new Error(
+      `[primeui-mcp] invalid package metadata in ${packageJsonPath}: ${details}`
+    );
+  }
+  return parsed.data;
+}
+var packageMetadata = loadPackageMetadata();
+
+// src/cli.ts
+function buildCliCommand(metadata) {
+  return `npx ${metadata.name}@latest`;
+}
+function formatUsageText(metadata = packageMetadata) {
+  const command = buildCliCommand(metadata);
+  return [
+    "Usage:",
+    `  ${command}`,
+    `  ${command} --help`,
+    `  ${command} --version`,
+    `  ${command} --health`,
+    `  ${command} --health /absolute/project/path`
+  ].join("\n");
+}
+function formatHelpText(metadata = packageMetadata) {
+  return [
+    "PrimeUI MCP",
+    "MCP stdio server for importing PrimeUI pages into your local project.",
+    "",
+    formatUsageText(metadata),
+    "",
+    "Options:",
+    "  -h, --help       Show this help message and exit.",
+    "  -v, --version    Show package version and exit.",
+    "  --health         Run runtime diagnostics without starting the MCP server.",
+    "",
+    "Behavior:",
+    "  Running without arguments starts the PrimeUI MCP stdio server.",
+    "  This mode is intended to be launched by an MCP-compatible client.",
+    "  `--health` prints runtime diagnostics and exits.",
+    "",
+    "Configuration:",
+    "  PRIMEUI_API_KEY       PrimeUI API key. Falls back to .primeui/project.json.",
+    "  PRIMEUI_API_BASE_URL  Override PrimeUI API base URL for local development.",
+    "  PRIMEUI_PROJECT_ROOT  Override project root used to resolve .primeui/project.json.",
+    "",
+    "Project config:",
+    "  .primeui/project.json must include projectId, apiKey, and targetProjectPath."
+  ].join("\n");
+}
+function formatInvalidHealthPathError(projectRoot, metadata = packageMetadata) {
+  return [
+    `Invalid --health project path: ${projectRoot}`,
+    "",
+    "The optional `--health` project path must be an absolute path.",
+    "",
+    formatUsageText(metadata)
+  ].join("\n");
+}
+function formatUnknownArgError(arg, metadata = packageMetadata) {
+  return [`Unknown argument: ${arg}`, "", formatUsageText(metadata)].join("\n");
+}
+function formatInvalidArgsError(args, metadata = packageMetadata) {
+  return [
+    `Invalid arguments: ${args.join(" ")}`,
+    "",
+    formatUsageText(metadata)
+  ].join("\n");
+}
+function parseCliArgs(argv) {
+  if (argv.length === 0) {
+    return {
+      kind: "start-server"
+    };
+  }
+  const [arg, maybeProjectRoot] = argv;
+  if (arg === "--health") {
+    if (argv.length === 1) {
+      return {
+        kind: "run-health-check"
+      };
+    }
+    if (argv.length !== 2) {
+      return {
+        kind: "error",
+        reason: "invalid-arguments",
+        args: argv
+      };
+    }
+    if (maybeProjectRoot === "--help" || maybeProjectRoot === "-h" || maybeProjectRoot === "--version" || maybeProjectRoot === "-v") {
+      return {
+        kind: "error",
+        reason: "invalid-arguments",
+        args: argv
+      };
+    }
+    if (!path2.isAbsolute(maybeProjectRoot ?? "")) {
+      return {
+        kind: "error",
+        reason: "invalid-health-path",
+        args: argv
+      };
+    }
+    return {
+      kind: "run-health-check",
+      projectRoot: maybeProjectRoot
+    };
+  }
+  if (argv.length !== 1) {
+    return {
+      kind: "error",
+      reason: "invalid-arguments",
+      args: argv
+    };
+  }
+  if (arg === "--help" || arg === "-h") {
+    return {
+      kind: "print-help"
+    };
+  }
+  if (arg === "--version" || arg === "-v") {
+    return {
+      kind: "print-version"
+    };
+  }
+  return {
+    kind: "error",
+    reason: "unknown-argument",
+    args: argv
+  };
+}
+function writeLine(stream, text) {
+  stream.write(`${text}
+`);
+}
+async function runCli(argv, dependencies) {
+  const metadata = dependencies.metadata ?? packageMetadata;
+  const parsed = parseCliArgs(argv);
+  switch (parsed.kind) {
+    case "start-server":
+      await dependencies.startServer();
+      return 0;
+    case "run-health-check":
+      return dependencies.runHealthCheck({
+        projectRoot: parsed.projectRoot
+      });
+    case "print-help":
+      writeLine(dependencies.stdout, formatHelpText(metadata));
+      return 0;
+    case "print-version":
+      writeLine(dependencies.stdout, metadata.version);
+      return 0;
+    case "error":
+      writeLine(
+        dependencies.stderr,
+        parsed.reason === "unknown-argument" ? formatUnknownArgError(parsed.args[0] ?? "", metadata) : parsed.reason === "invalid-health-path" ? formatInvalidHealthPathError(parsed.args[1] ?? "", metadata) : formatInvalidArgsError(parsed.args, metadata)
+      );
+      return 1;
+  }
+}
+
+// src/health/run-health-check.ts
+import { stat as stat3 } from "fs/promises";
 import path7 from "path";
 
 // src/lib/project-link-config.ts
 import { readFile, stat } from "fs/promises";
-import path from "path";
-import { z } from "zod";
-var PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH = ".primeui/project.json";
+import path3 from "path";
+import { z as z2 } from "zod";
+var PRIMEUI_PROJECT_DIR_NAME = ".primeui";
+var PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH = `${PRIMEUI_PROJECT_DIR_NAME}/project.json`;
 var PrimeUiProjectConfigError = class extends Error {
   code;
   hint;
@@ -26,10 +224,10 @@ var PrimeUiProjectConfigError = class extends Error {
 function buildProjectRootHint() {
   return "Likely MCP project-path bug: when Codex VSCode runs MCP from global config, server can start in HOME without project context. Fix: set tool input parameter `projectRoot` to the ABSOLUTE path of the current project root (for example: /path/to/current/project).";
 }
-var primeUiProjectConfigSchema = z.object({
-  projectId: z.string().trim().min(1),
-  apiKey: z.string().trim().min(1),
-  targetProjectPath: z.string().trim().regex(/^\.\/.*$/)
+var primeUiProjectConfigSchema = z2.object({
+  projectId: z2.string().trim().min(1),
+  apiKey: z2.string().trim().min(1),
+  targetProjectPath: z2.string().trim().regex(/^\.\/.*$/)
 }).passthrough();
 async function fileExists(filePath) {
   try {
@@ -40,12 +238,12 @@ async function fileExists(filePath) {
   }
 }
 function ancestors(startPath) {
-  const resolvedStartPath = path.resolve(startPath);
+  const resolvedStartPath = path3.resolve(startPath);
   const directories = [];
   let currentPath = resolvedStartPath;
   while (true) {
     directories.push(currentPath);
-    const parentPath = path.dirname(currentPath);
+    const parentPath = path3.dirname(currentPath);
     if (parentPath === currentPath) {
       break;
     }
@@ -55,7 +253,7 @@ function ancestors(startPath) {
 }
 async function findPrimeUiProjectConfigPath(startPath) {
   for (const currentPath of ancestors(startPath)) {
-    const candidatePath = path.join(
+    const candidatePath = path3.join(
       currentPath,
       PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH
     );
@@ -106,6 +304,37 @@ async function readPrimeUiProjectConfig(projectConfigPath) {
   }
   return parsedConfig.data;
 }
+function withConfigSourceDetails(error, context) {
+  if (!(error instanceof PrimeUiProjectConfigError)) {
+    throw error;
+  }
+  throw new PrimeUiProjectConfigError({
+    code: error.code,
+    message: error.message,
+    hint: error.hint,
+    details: {
+      ...error.details,
+      source: context.source,
+      projectRoot: context.projectRoot,
+      expectedConfigPath: context.projectConfigPath
+    }
+  });
+}
+async function loadResolvedPrimeUiProjectConfig(context) {
+  try {
+    const projectConfig = await readPrimeUiProjectConfig(
+      context.projectConfigPath
+    );
+    return {
+      projectRoot: context.projectRoot,
+      projectConfigPath: context.projectConfigPath,
+      projectConfig,
+      source: context.source
+    };
+  } catch (error) {
+    withConfigSourceDetails(error, context);
+  }
+}
 function toUniqueResolvedDirs(directories) {
   const resolved = /* @__PURE__ */ new Set();
   for (const directory of directories) {
@@ -113,7 +342,7 @@ function toUniqueResolvedDirs(directories) {
     if (!trimmed) {
       continue;
     }
-    resolved.add(path.resolve(trimmed));
+    resolved.add(path3.resolve(trimmed));
   }
   return [...resolved];
 }
@@ -123,8 +352,8 @@ function buildPrimeUiProjectSearchRoots(options) {
 async function resolvePrimeUiProjectConfig(options) {
   const toolProjectRoot = options.projectRootFromTool?.trim();
   if (toolProjectRoot) {
-    const resolvedToolRoot = path.resolve(toolProjectRoot);
-    const toolProjectConfigPath = path.join(
+    const resolvedToolRoot = path3.resolve(toolProjectRoot);
+    const toolProjectConfigPath = path3.join(
       resolvedToolRoot,
       PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH
     );
@@ -141,35 +370,31 @@ async function resolvePrimeUiProjectConfig(options) {
         hint: buildProjectRootHint()
       });
     }
-    const projectConfig2 = await readPrimeUiProjectConfig(toolProjectConfigPath);
-    return {
+    return loadResolvedPrimeUiProjectConfig({
+      source: "tool",
       projectRoot: resolvedToolRoot,
-      projectConfigPath: toolProjectConfigPath,
-      projectConfig: projectConfig2
-    };
+      projectConfigPath: toolProjectConfigPath
+    });
   }
   const stickyProjectRoot = options.projectRootFromSticky?.trim();
   if (stickyProjectRoot) {
-    const resolvedStickyRoot = path.resolve(stickyProjectRoot);
-    const stickyProjectConfigPath = path.join(
+    const resolvedStickyRoot = path3.resolve(stickyProjectRoot);
+    const stickyProjectConfigPath = path3.join(
       resolvedStickyRoot,
       PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH
     );
     if (await fileExists(stickyProjectConfigPath)) {
-      const projectConfig2 = await readPrimeUiProjectConfig(
-        stickyProjectConfigPath
-      );
-      return {
+      return loadResolvedPrimeUiProjectConfig({
+        source: "sticky",
         projectRoot: resolvedStickyRoot,
-        projectConfigPath: stickyProjectConfigPath,
-        projectConfig: projectConfig2
-      };
+        projectConfigPath: stickyProjectConfigPath
+      });
     }
   }
   const envProjectRoot = options.projectRootFromEnv?.trim();
   if (envProjectRoot) {
-    const resolvedEnvRoot = path.resolve(envProjectRoot);
-    const envProjectConfigPath = path.join(
+    const resolvedEnvRoot = path3.resolve(envProjectRoot);
+    const envProjectConfigPath = path3.join(
       resolvedEnvRoot,
       PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH
     );
@@ -187,12 +412,11 @@ async function resolvePrimeUiProjectConfig(options) {
         hint: buildProjectRootHint()
       });
     }
-    const projectConfig2 = await readPrimeUiProjectConfig(envProjectConfigPath);
-    return {
+    return loadResolvedPrimeUiProjectConfig({
+      source: "env",
       projectRoot: resolvedEnvRoot,
-      projectConfigPath: envProjectConfigPath,
-      projectConfig: projectConfig2
-    };
+      projectConfigPath: envProjectConfigPath
+    });
   }
   const searchRoots = buildPrimeUiProjectSearchRoots({
     cwd: options.cwd,
@@ -220,37 +444,52 @@ async function resolvePrimeUiProjectConfig(options) {
       hint: buildProjectRootHint()
     });
   }
-  const projectRoot = path.dirname(path.dirname(projectConfigPath));
-  const projectConfig = await readPrimeUiProjectConfig(projectConfigPath);
-  return {
+  const projectRoot = path3.dirname(path3.dirname(projectConfigPath));
+  return loadResolvedPrimeUiProjectConfig({
+    source: "search",
     projectRoot,
-    projectConfigPath,
-    projectConfig
+    projectConfigPath
+  });
+}
+function resolvePrimeUiApiKeyDetails(options) {
+  const envApiKey = options.apiKeyFromEnv?.trim();
+  const configApiKey = options.projectConfig?.apiKey.trim();
+  const envProvided = Boolean(envApiKey);
+  const configProvided = Boolean(configApiKey);
+  return {
+    apiKey: envApiKey ?? configApiKey,
+    source: envProvided ? "env" : configProvided ? "config" : "missing",
+    envProvided,
+    configProvided,
+    valuesMatch: envProvided && configProvided ? envApiKey === configApiKey : void 0
   };
 }
+function resolvePrimeUiTargetProjectRoot(projectRoot, projectConfig) {
+  return path3.resolve(projectRoot, projectConfig.targetProjectPath);
+}
 async function resolvePrimeUiApiKey(options) {
-  const envApiKey = options.apiKeyFromEnv?.trim();
-  if (envApiKey) {
-    return envApiKey;
-  }
-  const projectConfigApiKey = options.projectConfig.apiKey.trim();
-  if (!projectConfigApiKey) {
-    throw new PrimeUiProjectConfigError({
-      code: "PROJECT_API_KEY_MISSING",
-      message: "[primeui-mcp] PRIMEUI_API_KEY is missing in env and .primeui/project.json",
-      hint: "Set PRIMEUI_API_KEY or ensure apiKey is present in .primeui/project.json."
-    });
-  }
-  return projectConfigApiKey;
+  const resolved = resolvePrimeUiApiKeyDetails(options);
+  if (resolved.apiKey) {
+    return resolved.apiKey;
+  }
+  throw new PrimeUiProjectConfigError({
+    code: "PROJECT_API_KEY_MISSING",
+    message: "[primeui-mcp] PRIMEUI_API_KEY is missing in env and .primeui/project.json",
+    hint: "Set PRIMEUI_API_KEY or ensure apiKey is present in .primeui/project.json."
+  });
 }
 
-// src/services/project-sync-service.ts
+// src/sources/api-provider.ts
+import { createWriteStream } from "fs";
+import { unlink } from "fs/promises";
 import path5 from "path";
-import { readFile as readFile4 } from "fs/promises";
+import { Readable, Transform } from "stream";
+import { pipeline } from "stream/promises";
+import { z as z3 } from "zod";
 
 // src/lib/fs.ts
 import { mkdir, rm, writeFile } from "fs/promises";
-import path2 from "path";
+import path4 from "path";
 import extractZipArchive from "extract-zip";
 async function ensureDir(dirPath) {
   await mkdir(dirPath, { recursive: true });
@@ -260,7 +499,7 @@ async function resetDir(dirPath) {
   await mkdir(dirPath, { recursive: true });
 }
 async function writeUtf8(filePath, content) {
-  await ensureDir(path2.dirname(filePath));
+  await ensureDir(path4.dirname(filePath));
   await writeFile(filePath, content, "utf-8");
 }
 async function extractZip(zipPath, targetDir) {
@@ -273,14 +512,1010 @@ async function extractZip(zipPath, targetDir) {
   }
 }
 
+// src/sources/api-provider.ts
+var DEFAULT_API_BASE_URL = "https://app.primeui.com/";
+var ZIP_CONTENT_TYPES = [
+  "application/zip",
+  "application/octet-stream",
+  "application/x-zip-compressed"
+];
+var exportStatusSchema = z3.enum(["in_progress", "completed", "failed"]);
+var projectPageObjectSchema = z3.object({
+  id: z3.string(),
+  title: z3.string(),
+  slug: z3.string(),
+  pageType: z3.string(),
+  isReadyToExport: z3.boolean(),
+  pagePath: z3.string(),
+  componentsPath: z3.string()
+});
+var projectPageSchema = projectPageObjectSchema;
+var exportSummarySchema = z3.object({
+  total: z3.number(),
+  successful: z3.number(),
+  failed: z3.number()
+});
+var exportedComponentSchema = z3.object({
+  componentKey: z3.string(),
+  enabled: z3.boolean(),
+  files: z3.array(z3.string()),
+  message: z3.string()
+});
+var exportPageManifestSchema = z3.object({
+  success: z3.boolean(),
+  message: z3.string(),
+  files: z3.array(z3.string())
+});
+var exportPageSchema = z3.object({
+  id: z3.string(),
+  title: z3.string().optional(),
+  slug: z3.string(),
+  pageType: z3.string(),
+  isReadyToExport: z3.literal(true),
+  pagePath: z3.string(),
+  componentsPath: z3.string(),
+  manifest: exportPageManifestSchema
+});
+var projectInfoSchema = z3.object({
+  projectId: z3.string(),
+  projectName: z3.string(),
+  metadata: z3.record(z3.unknown()),
+  pages: z3.array(projectPageSchema)
+});
+var projectPageComponentSchema = z3.object({
+  blockId: z3.string(),
+  componentId: z3.string(),
+  componentGroup: z3.string(),
+  slot: z3.string().nullable(),
+  props: z3.record(z3.unknown()).nullable()
+});
+var projectPageDetailsSchema = z3.object({
+  page: projectPageObjectSchema.extend({
+    pageInstruction: z3.string().nullable()
+  }),
+  variant: z3.object({
+    id: z3.string(),
+    name: z3.string()
+  }).nullable(),
+  components: z3.array(projectPageComponentSchema).nullable()
+});
+var exportsResponseSchema = z3.object({
+  exports: z3.array(
+    z3.object({
+      id: z3.string(),
+      status: exportStatusSchema,
+      createdAt: z3.string().datetime({ offset: true })
+    })
+  )
+});
+var createExportResponseSchema = z3.object({
+  export: z3.object({
+    id: z3.string(),
+    status: exportStatusSchema,
+    createdAt: z3.string().datetime({ offset: true }),
+    expiresAt: z3.string().datetime({ offset: true }).nullable(),
+    summary: exportSummarySchema,
+    components: z3.array(exportedComponentSchema)
+  }),
+  pages: z3.array(exportPageSchema)
+});
+var PrimeUiApiContractError = class extends Error {
+  constructor(endpoint, details) {
+    super(`PrimeUI API contract mismatch for "${endpoint}": ${details}`);
+    this.name = "PrimeUiApiContractError";
+  }
+};
+var normalizePrimeUiApiRoot = (rawBaseUrl) => {
+  const normalizedBase = rawBaseUrl?.trim() || DEFAULT_API_BASE_URL;
+  const parsed = new URL(normalizedBase);
+  const normalizedPath = parsed.pathname.replace(/\/+$/, "");
+  if (normalizedPath.endsWith("/api/v1")) {
+    parsed.pathname = `${normalizedPath}/`;
+    return parsed.toString();
+  }
+  parsed.pathname = `${normalizedPath}/api/v1/`.replace(
+    "//api/v1/",
+    "/api/v1/"
+  );
+  return parsed.toString();
+};
+var buildPrimeUiApiUrl = (apiRoot, endpoint) => new URL(endpoint, apiRoot).toString();
+var isJsonContentType = (contentType) => contentType.includes("application/json") || contentType.includes("+json");
+var isZipContentType = (contentType) => ZIP_CONTENT_TYPES.some((allowedType) => contentType.includes(allowedType));
+var looksLikeZipArchive = (buffer) => {
+  if (buffer.length < 4) {
+    return false;
+  }
+  if (buffer[0] !== 80 || buffer[1] !== 75) {
+    return false;
+  }
+  const signature = `${buffer[2]}:${buffer[3]}`;
+  return signature === "3:4" || signature === "5:6" || signature === "7:8";
+};
+var createZipSignatureGuard = (endpoint) => {
+  let signature = Buffer.alloc(0);
+  let validated = false;
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      if (!validated) {
+        const requiredBytes = Math.max(0, 4 - signature.length);
+        if (requiredBytes > 0) {
+          signature = Buffer.concat([
+            signature,
+            chunkBuffer.subarray(0, requiredBytes)
+          ]);
+        }
+        if (signature.length >= 4) {
+          if (!looksLikeZipArchive(signature)) {
+            callback(
+              new PrimeUiApiContractError(
+                endpoint,
+                "response body is not a valid zip archive"
+              )
+            );
+            return;
+          }
+          validated = true;
+        }
+      }
+      callback(null, chunkBuffer);
+    },
+    flush(callback) {
+      if (!validated) {
+        callback(
+          new PrimeUiApiContractError(
+            endpoint,
+            "response body is not a valid zip archive"
+          )
+        );
+        return;
+      }
+      callback();
+    }
+  });
+};
+var ApiProjectDataProvider = class {
+  apiKey;
+  apiRoot;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.apiRoot = normalizePrimeUiApiRoot(options.baseUrl);
+  }
+  async getProjectInfo() {
+    return this.requestJson("project", projectInfoSchema);
+  }
+  async getProjectPageBySlug(slug) {
+    const encodedSlug = encodeURIComponent(slug);
+    return this.requestJson(
+      `project/page?slug=${encodedSlug}`,
+      projectPageDetailsSchema
+    );
+  }
+  async listExports() {
+    const response = await this.requestJson(
+      "project/exports",
+      exportsResponseSchema
+    );
+    return response.exports;
+  }
+  async createExport() {
+    return this.requestJson("project/exports", createExportResponseSchema, {
+      method: "POST"
+    });
+  }
+  /**
+   * Consumer-side runtime contract for GET /api/v1/project/exports/:exportId/download.
+   * Producer source of truth: apps/studio/src/app/api/v1/project/exports/[exportId]/download/route.ts
+   * Keep content-type and archive format checks synchronized with the producer response.
+   */
+  async downloadExportArchive(exportId, destinationPath) {
+    const endpoint = `project/exports/${encodeURIComponent(exportId)}/download`;
+    const apiKey = this.requireApiKey();
+    const response = await fetch(this.buildUrl(endpoint), {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      const details = await this.readError(response);
+      throw new Error(
+        `PrimeUI API request failed (${response.status}) while downloading export "${exportId}": ${details}`
+      );
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!isZipContentType(contentType)) {
+      throw new PrimeUiApiContractError(
+        endpoint,
+        `expected zip content-type but got "${contentType || "unknown"}"`
+      );
+    }
+    if (!response.body) {
+      throw new PrimeUiApiContractError(endpoint, "response body is empty");
+    }
+    await ensureDir(path5.dirname(destinationPath));
+    const zipStream = Readable.fromWeb(
+      response.body
+    );
+    const signatureGuard = createZipSignatureGuard(endpoint);
+    const fileStream = createWriteStream(destinationPath);
+    try {
+      await pipeline(zipStream, signatureGuard, fileStream);
+    } catch (error) {
+      await unlink(destinationPath).catch(() => void 0);
+      throw error;
+    }
+  }
+  buildUrl(endpoint) {
+    return buildPrimeUiApiUrl(this.apiRoot, endpoint);
+  }
+  async requestJson(endpoint, schema, requestInit = {}) {
+    const apiKey = this.requireApiKey();
+    const method = requestInit.method ?? "GET";
+    const response = await fetch(this.buildUrl(endpoint), {
+      ...requestInit,
+      method,
+      headers: {
+        ...requestInit.headers ?? {},
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      const details = await this.readError(response);
+      throw new Error(
+        `PrimeUI API request failed (${response.status}) for "${endpoint}": ${details}`
+      );
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!isJsonContentType(contentType)) {
+      throw new PrimeUiApiContractError(
+        endpoint,
+        `expected JSON content-type but got "${contentType || "unknown"}"`
+      );
+    }
+    let payload;
+    try {
+      payload = await response.json();
+    } catch {
+      throw new PrimeUiApiContractError(
+        endpoint,
+        "response body is not valid JSON"
+      );
+    }
+    const parsed = schema.safeParse(payload);
+    if (!parsed.success) {
+      const details = parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
+      throw new PrimeUiApiContractError(endpoint, details);
+    }
+    return parsed.data;
+  }
+  async readError(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    try {
+      if (isJsonContentType(contentType)) {
+        const body = await response.json();
+        if (body?.message && body?.code) {
+          return `${body.code}: ${body.message}`;
+        }
+        if (body?.message) {
+          return body.message;
+        }
+      } else {
+        const bodyText = await response.text();
+        if (bodyText.trim()) {
+          return bodyText.trim();
+        }
+      }
+    } catch {
+    }
+    return response.statusText || "Unknown error";
+  }
+  requireApiKey() {
+    const apiKey = this.apiKey?.trim();
+    if (!apiKey) {
+      throw new Error("PRIMEUI_API_KEY is required to call PrimeUI API tools.");
+    }
+    return apiKey;
+  }
+};
+
+// src/health/hints.ts
+function addHint(target, seen, hint) {
+  if (!seen.has(hint)) {
+    seen.add(hint);
+    target.push(hint);
+  }
+}
+function buildHealthHints(options) {
+  const { report, connectApiKey } = options;
+  const hints = [];
+  const seen = /* @__PURE__ */ new Set();
+  const validNestedRoots = report.nestedSearch.candidates.filter((candidate) => candidate.configStatus === "valid").map((candidate) => candidate.projectRoot);
+  if (!report.runtimeContext.inputProjectRoot && report.projectResolution.configStatus === "unresolved" && report.projectResolution.errorSource === "search") {
+    addHint(
+      hints,
+      seen,
+      "Config was not found from the current working directory. Rerun `--health /absolute/project/path`, pass the same absolute path via MCP tool `projectRoot`, or set `PRIMEUI_PROJECT_ROOT` if your MCP client starts outside the project."
+    );
+  }
+  if (report.runtimeContext.inputProjectRoot && report.projectResolution.primeUiDirStatus === "missing") {
+    if (report.nestedSearch.candidates.length > 0) {
+      addHint(
+        hints,
+        seen,
+        validNestedRoots.length > 0 ? `No direct \`.primeui\` directory was found under the provided path. Rerun health with one of the exact nested project roots that passed config validation, for example: ${validNestedRoots.join(", ")}.` : "No direct `.primeui` directory was found under the provided path. Nested `.primeui` directories were found below it, so rerun health with the exact intended project root before using MCP tools."
+      );
+      if (validNestedRoots.length > 0) {
+        addHint(
+          hints,
+          seen,
+          `When calling MCP tools, pass \`projectRoot\` only for a candidate whose nested health check passes, for example: ${validNestedRoots[0]}.`
+        );
+      }
+    } else {
+      const connectCommand = `npx @primeuicom/cli ${connectApiKey ?? "<api-key>"} connect`;
+      addHint(
+        hints,
+        seen,
+        `No \`.primeui\` directory was found under the provided path. From the intended target folder, run \`${connectCommand}\` to connect the project to PrimeUI.`
+      );
+      if (!connectApiKey) {
+        addHint(
+          hints,
+          seen,
+          "If you do not already have a valid PrimeUI API key, get it from the appropriate PrimeUI project on `primeui.com`."
+        );
+      }
+    }
+  }
+  if (report.projectResolution.primeUiDirStatus === "found" && report.projectResolution.configStatus === "missing") {
+    addHint(
+      hints,
+      seen,
+      "`.primeui/project.json` is missing. It was likely corrupted or deleted; restore it by reconnecting the project or by making a fresh export via the PrimeUI CLI tool."
+    );
+  }
+  if (report.projectResolution.primeUiDirStatus === "found" && (report.projectResolution.configStatus === "invalid-json" || report.projectResolution.configStatus === "invalid-format" || report.projectResolution.configStatus === "read-failed")) {
+    addHint(
+      hints,
+      seen,
+      "`.primeui/project.json` looks corrupted or incomplete. Restore it by reconnecting the project or by making a fresh export via the PrimeUI CLI tool."
+    );
+  }
+  if (report.runtimeContext.envProjectRoot && report.sourceResolution.projectRoot.comparison === "different") {
+    addHint(
+      hints,
+      seen,
+      report.projectResolution.inputProjectRootValidated ? `\`PRIMEUI_PROJECT_ROOT\` points to a different location than the validated explicit input path. Fix or unset \`PRIMEUI_PROJECT_ROOT\`, and use the successful path via MCP tool \`projectRoot\`: ${report.runtimeContext.inputProjectRoot}.` : "`PRIMEUI_PROJECT_ROOT` points to a different location than the explicit input path. Correct the project root first, then rerun health before using MCP tool `projectRoot`."
+    );
+  }
+  if (report.sourceResolution.apiKey.effectiveSource === "missing" && !(report.projectResolution.primeUiDirStatus === "found" && report.projectResolution.configStatus !== "valid")) {
+    addHint(
+      hints,
+      seen,
+      "No usable API key was found. Set `PRIMEUI_API_KEY`, restore `apiKey` in `.primeui/project.json`, or get a valid key from the appropriate PrimeUI project on `primeui.com`."
+    );
+  }
+  if (report.apiCheck.status === "skipped" && report.apiCheck.errorKind === "configuration" && report.runtimeContext.envApiBaseUrl) {
+    addHint(
+      hints,
+      seen,
+      "Set `PRIMEUI_API_BASE_URL` to a valid absolute URL such as `http://localhost:3020`, or remove it to fall back to the standard production API."
+    );
+  }
+  if (report.apiCheck.status === "failed" && report.apiCheck.errorKind === "auth") {
+    if (report.sourceResolution.apiKey.envState === "set" && report.sourceResolution.apiKey.configState === "set") {
+      addHint(
+        hints,
+        seen,
+        "Both env and config API keys are present. Verify that `PRIMEUI_API_KEY` is not unintentionally overriding a valid config key."
+      );
+    }
+    if (report.apiCheck.nonStandardBaseUrl) {
+      addHint(
+        hints,
+        seen,
+        "Authentication failed while using a non-standard `PRIMEUI_API_BASE_URL`. If you did not intend to target a custom API host, remove that env var and retry."
+      );
+    }
+    addHint(
+      hints,
+      seen,
+      "The current API key was rejected by `project info`. Rotate or regenerate the key, then rerun health."
+    );
+  }
+  if (report.apiCheck.status === "failed" && report.apiCheck.errorKind === "network") {
+    addHint(
+      hints,
+      seen,
+      report.apiCheck.nonStandardBaseUrl ? "The `project info` request failed while using a non-standard `PRIMEUI_API_BASE_URL`. Verify that host is reachable, or remove the env var if you did not intend to target a custom API." : "The `project info` request could not reach the API successfully. Verify network reachability and retry."
+    );
+  }
+  return hints;
+}
+
+// src/health/nested-primeui-search.ts
+import { readdir, stat as stat2 } from "fs/promises";
+import path6 from "path";
+var SCAN_EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".next",
+  "dist",
+  "build",
+  "coverage"
+]);
+async function isFile(targetPath) {
+  try {
+    const targetStat = await stat2(targetPath);
+    return targetStat.isFile();
+  } catch {
+    return false;
+  }
+}
+function mapConfigStatus(error) {
+  if (!(error instanceof PrimeUiProjectConfigError)) {
+    return "read-failed";
+  }
+  switch (error.code) {
+    case "PROJECT_CONFIG_INVALID_JSON":
+      return "invalid-json";
+    case "PROJECT_CONFIG_INVALID_FORMAT":
+      return "invalid-format";
+    case "PROJECT_CONFIG_READ_FAILED":
+      return "read-failed";
+    case "PROJECT_CONFIG_NOT_FOUND":
+      return "missing";
+    default:
+      return "read-failed";
+  }
+}
+async function inspectCandidate(projectRoot, primeUiPath) {
+  const configPath = path6.join(primeUiPath, "project.json");
+  if (!await isFile(configPath)) {
+    return {
+      projectRoot,
+      primeUiPath,
+      configPath,
+      hasProjectConfig: false,
+      configStatus: "missing"
+    };
+  }
+  try {
+    const projectConfig = await readPrimeUiProjectConfig(configPath);
+    return {
+      projectRoot,
+      primeUiPath,
+      configPath,
+      hasProjectConfig: true,
+      configStatus: "valid",
+      targetProjectPath: projectConfig.targetProjectPath,
+      targetProjectRoot: resolvePrimeUiTargetProjectRoot(
+        projectRoot,
+        projectConfig
+      )
+    };
+  } catch (error) {
+    return {
+      projectRoot,
+      primeUiPath,
+      configPath,
+      hasProjectConfig: true,
+      configStatus: mapConfigStatus(error)
+    };
+  }
+}
+async function findNestedPrimeUiCandidates(rootPath) {
+  const queue = [path6.resolve(rootPath)];
+  const seen = /* @__PURE__ */ new Set();
+  const candidates = [];
+  while (queue.length > 0) {
+    const currentDir = queue.shift();
+    if (!currentDir || seen.has(currentDir)) {
+      continue;
+    }
+    seen.add(currentDir);
+    let entries;
+    try {
+      entries = await readdir(currentDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const entryPath = path6.join(currentDir, entry.name);
+      if (entry.name === PRIMEUI_PROJECT_DIR_NAME) {
+        candidates.push(await inspectCandidate(currentDir, entryPath));
+        continue;
+      }
+      if (SCAN_EXCLUDED_DIRS.has(entry.name)) {
+        continue;
+      }
+      queue.push(entryPath);
+    }
+  }
+  return candidates.sort(
+    (left, right) => left.primeUiPath.localeCompare(right.primeUiPath)
+  );
+}
+
+// src/health/report.ts
+function renderValue(value, fallback = "missing") {
+  return value?.trim() ? value : fallback;
+}
+function renderProjectRootComparison(comparison) {
+  switch (comparison) {
+    case "same":
+      return "same";
+    case "different":
+      return "different";
+    case "input-only":
+      return "only explicit input path is set";
+    case "env-only":
+      return "only PRIMEUI_PROJECT_ROOT is set";
+    case "neither":
+      return "neither explicit input path nor PRIMEUI_PROJECT_ROOT is set";
+  }
+}
+function renderApiKeyComparison(comparison) {
+  switch (comparison) {
+    case "same":
+      return "same";
+    case "different":
+      return "different";
+    case "not-comparable":
+      return "not comparable";
+  }
+}
+function renderConfigStatus(status) {
+  switch (status) {
+    case "valid":
+      return "valid";
+    case "missing":
+      return "missing";
+    case "invalid-json":
+      return "invalid JSON";
+    case "invalid-format":
+      return "invalid format";
+    case "read-failed":
+      return "read failed";
+    case "unresolved":
+      return "unresolved";
+  }
+}
+function formatSection(title, lines) {
+  return [title, ...lines.map((line) => `- ${line}`)].join("\n");
+}
+function formatHealthReport(report) {
+  const sections = [
+    "PrimeUI MCP Health",
+    "",
+    formatSection("Version", [
+      `current: ${report.version.currentVersion}`,
+      `latest: ${renderValue(report.version.latestVersion, "unavailable")}`,
+      `update status: ${report.version.updateStatus}${report.version.detail ? ` (${report.version.detail})` : ""}`
+    ]),
+    "",
+    formatSection("Runtime Context", [
+      `cwd: ${report.runtimeContext.cwd}`,
+      `health input path: ${renderValue(report.runtimeContext.inputProjectRoot)}`,
+      `PRIMEUI_PROJECT_ROOT: ${renderValue(report.runtimeContext.envProjectRoot)}`,
+      `PRIMEUI_API_BASE_URL: ${renderValue(report.runtimeContext.envApiBaseUrl)}`,
+      `PRIMEUI_API_KEY: ${report.runtimeContext.envApiKeySet ? "set" : "missing"}`
+    ]),
+    "",
+    formatSection("Source Resolution", [
+      `input project root: ${renderValue(report.sourceResolution.projectRoot.inputPath)}`,
+      `env project root: ${renderValue(report.sourceResolution.projectRoot.envPath)}`,
+      `project root comparison: ${renderProjectRootComparison(
+        report.sourceResolution.projectRoot.comparison
+      )}`,
+      `effective project root source: ${report.sourceResolution.projectRoot.effectiveSource}`,
+      `env API key: ${report.sourceResolution.apiKey.envState}`,
+      `config API key: ${report.sourceResolution.apiKey.configState}`,
+      `API key comparison: ${renderApiKeyComparison(
+        report.sourceResolution.apiKey.comparison
+      )}`,
+      `effective API key source: ${report.sourceResolution.apiKey.effectiveSource}`
+    ]),
+    "",
+    formatSection("Project Resolution", [
+      `resolved project root: ${renderValue(
+        report.projectResolution.resolvedProjectRoot,
+        "unresolved"
+      )}`,
+      `effective project root source: ${report.projectResolution.effectiveSource}`,
+      `project root validation via explicit input: ${report.projectResolution.inputProjectRootValidated ? "passed" : "not used or failed"}`,
+      `.primeui directory: ${report.projectResolution.primeUiDirStatus === "found" ? `found at ${report.projectResolution.primeUiDirPath}` : report.projectResolution.primeUiDirStatus}`,
+      `config path: ${report.projectResolution.configPath ? `${report.projectResolution.configPath} (${renderConfigStatus(
+        report.projectResolution.configStatus
+      )})` : renderConfigStatus(report.projectResolution.configStatus)}`,
+      `targetProjectPath: ${report.projectResolution.targetProjectPath ?? "unresolved"}`,
+      `resolved target project root: ${renderValue(
+        report.projectResolution.targetProjectRoot,
+        "unresolved"
+      )}`,
+      `project resolution detail: ${renderValue(
+        report.projectResolution.errorMessage,
+        "none"
+      )}`
+    ]),
+    "",
+    formatSection("API Check", [
+      `API root: ${renderValue(report.apiCheck.apiRoot, "unresolved")}`,
+      `project info URL: ${renderValue(report.apiCheck.projectInfoUrl, "unresolved")}`,
+      `PRIMEUI_API_BASE_URL source: ${report.apiCheck.apiBaseUrlSource}`,
+      `non-standard API base URL: ${report.apiCheck.nonStandardBaseUrl ? "yes" : "no"}`,
+      `project info request: ${report.apiCheck.status}`,
+      `request detail: ${report.apiCheck.message}`
+    ])
+  ];
+  if (report.nestedSearch.performed) {
+    const candidateLines = report.nestedSearch.candidates.length > 0 ? report.nestedSearch.candidates.map((candidate) => {
+      const parts = [
+        candidate.primeUiPath,
+        `project root: ${candidate.projectRoot}`,
+        `config: ${renderConfigStatus(candidate.configStatus)}`
+      ];
+      if (candidate.targetProjectPath) {
+        parts.push(`targetProjectPath: ${candidate.targetProjectPath}`);
+      }
+      return parts.join("; ");
+    }) : ["none found"];
+    sections.splice(
+      sections.length - 2,
+      0,
+      "",
+      formatSection("Nested PrimeUI Candidates", [
+        `search root: ${renderValue(report.nestedSearch.rootPath, "unresolved")}`,
+        ...candidateLines
+      ])
+    );
+  }
+  sections.push("");
+  if (report.hints.length === 0) {
+    sections.push("Hints\n- none");
+  } else {
+    sections.push(
+      [
+        "Hints",
+        ...report.hints.map((hint, index) => `${index + 1}. ${hint}`)
+      ].join("\n")
+    );
+  }
+  return sections.join("\n");
+}
+
+// src/health/update-check.ts
+function parseVersion(input) {
+  const [coreVersion, prerelease] = input.split("-", 2);
+  return {
+    parts: coreVersion.split(".").map((segment) => {
+      const parsed = Number.parseInt(segment, 10);
+      return Number.isFinite(parsed) ? parsed : 0;
+    }),
+    prerelease
+  };
+}
+function compareVersions(left, right) {
+  const leftVersion = parseVersion(left);
+  const rightVersion = parseVersion(right);
+  const length = Math.max(leftVersion.parts.length, rightVersion.parts.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = leftVersion.parts[index] ?? 0;
+    const rightPart = rightVersion.parts[index] ?? 0;
+    if (leftPart !== rightPart) {
+      return leftPart > rightPart ? 1 : -1;
+    }
+  }
+  if (!leftVersion.prerelease && !rightVersion.prerelease) {
+    return 0;
+  }
+  if (!leftVersion.prerelease) {
+    return 1;
+  }
+  if (!rightVersion.prerelease) {
+    return -1;
+  }
+  return leftVersion.prerelease.localeCompare(rightVersion.prerelease);
+}
+async function checkLatestPackageVersion(packageName, currentVersion) {
+  const controller = new AbortController();
+  const timeoutHandle = setTimeout(() => controller.abort(), 3e3);
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`,
+      {
+        signal: controller.signal
+      }
+    );
+    if (!response.ok) {
+      return {
+        status: "unavailable",
+        detail: `npm registry request failed with status ${response.status}`
+      };
+    }
+    const payload = await response.json();
+    const latestVersion = payload.version?.trim();
+    if (!latestVersion) {
+      return {
+        status: "unavailable",
+        detail: "npm registry response did not include a latest version"
+      };
+    }
+    const comparison = compareVersions(currentVersion, latestVersion);
+    return {
+      latestVersion,
+      status: comparison < 0 ? "update-available" : "up-to-date",
+      detail: comparison > 0 ? "installed version is newer than the npm latest tag" : void 0
+    };
+  } catch (error) {
+    return {
+      status: "unavailable",
+      detail: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}
+
+// src/health/run-health-check.ts
+function mapProjectSource(source) {
+  switch (source) {
+    case "tool":
+      return "input";
+    case "env":
+      return "env";
+    case "search":
+      return "search";
+    default:
+      return "unresolved";
+  }
+}
+function mapProjectErrorSource(source) {
+  switch (source) {
+    case "tool":
+      return "input";
+    case "env":
+      return "env";
+    case "search":
+      return "search";
+    default:
+      return void 0;
+  }
+}
+function compareProjectRoots(inputPath, envPath) {
+  if (inputPath && envPath) {
+    return inputPath === envPath ? "same" : "different";
+  }
+  if (inputPath) {
+    return "input-only";
+  }
+  if (envPath) {
+    return "env-only";
+  }
+  return "neither";
+}
+function compareApiKeys(valuesMatch, envProvided, configProvided) {
+  if (envProvided && configProvided) {
+    return valuesMatch ? "same" : "different";
+  }
+  return "not-comparable";
+}
+function mapConfigStatus2(error) {
+  if (!error) {
+    return "valid";
+  }
+  switch (error.code) {
+    case "PROJECT_CONFIG_NOT_FOUND":
+      return typeof error.details.expectedConfigPath === "string" ? "missing" : "unresolved";
+    case "PROJECT_CONFIG_INVALID_JSON":
+      return "invalid-json";
+    case "PROJECT_CONFIG_INVALID_FORMAT":
+      return "invalid-format";
+    case "PROJECT_CONFIG_READ_FAILED":
+      return "read-failed";
+    default:
+      return "unresolved";
+  }
+}
+async function directoryExists(targetPath) {
+  try {
+    const targetStat = await stat3(targetPath);
+    return targetStat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function classifyApiError(message) {
+  return /PrimeUI API request failed \((401|403)\)/.test(message) ? "auth" : "network";
+}
+async function runHealthCheck(options) {
+  const metadata = options.metadata ?? packageMetadata;
+  const env = options.env ?? process.env;
+  const cwd = path7.resolve(options.cwd ?? process.cwd());
+  const inputProjectRoot = options.projectRoot?.trim() ? path7.resolve(options.projectRoot.trim()) : void 0;
+  const envProjectRoot = env.PRIMEUI_PROJECT_ROOT?.trim() ? path7.resolve(env.PRIMEUI_PROJECT_ROOT.trim()) : void 0;
+  const versionResult = await (options.checkLatestVersion ?? checkLatestPackageVersion)(metadata.name, metadata.version);
+  let resolvedProjectConfig;
+  let projectConfigError;
+  try {
+    resolvedProjectConfig = await resolvePrimeUiProjectConfig({
+      cwd,
+      projectRootFromTool: inputProjectRoot,
+      projectRootFromEnv: envProjectRoot
+    });
+  } catch (error) {
+    if (!(error instanceof PrimeUiProjectConfigError)) {
+      throw error;
+    }
+    projectConfigError = error;
+  }
+  const resolvedProjectRoot = resolvedProjectConfig?.projectRoot ?? (typeof projectConfigError?.details.projectRoot === "string" ? path7.resolve(projectConfigError.details.projectRoot) : void 0);
+  const primeUiDirPath = resolvedProjectRoot ? path7.join(resolvedProjectRoot, PRIMEUI_PROJECT_DIR_NAME) : inputProjectRoot ? path7.join(inputProjectRoot, PRIMEUI_PROJECT_DIR_NAME) : envProjectRoot && mapProjectErrorSource(
+    projectConfigError?.details.source
+  ) === "env" ? path7.join(envProjectRoot, PRIMEUI_PROJECT_DIR_NAME) : void 0;
+  const primeUiDirStatus = primeUiDirPath ? await directoryExists(primeUiDirPath) ? "found" : "missing" : "unresolved";
+  const configStatus = resolvedProjectConfig ? "valid" : mapConfigStatus2(projectConfigError);
+  const configPath = resolvedProjectConfig?.projectConfigPath ?? (typeof projectConfigError?.details.expectedConfigPath === "string" ? path7.resolve(projectConfigError.details.expectedConfigPath) : primeUiDirPath ? path7.join(primeUiDirPath, "project.json") : void 0);
+  const nestedSearchPerformed = Boolean(inputProjectRoot) && primeUiDirStatus === "missing";
+  const nestedCandidates = nestedSearchPerformed ? await findNestedPrimeUiCandidates(inputProjectRoot) : [];
+  const apiKeyDetails = resolvePrimeUiApiKeyDetails({
+    projectConfig: resolvedProjectConfig?.projectConfig,
+    apiKeyFromEnv: env.PRIMEUI_API_KEY
+  });
+  const configApiKeyState = resolvedProjectConfig ? "set" : configStatus === "missing" || configStatus === "unresolved" ? "missing" : "unknown";
+  const apiBaseUrlSource = env.PRIMEUI_API_BASE_URL?.trim() ? "env" : "default";
+  const defaultApiRoot = normalizePrimeUiApiRoot(DEFAULT_API_BASE_URL);
+  let apiRoot;
+  let projectInfoUrl;
+  let apiCheck;
+  try {
+    apiRoot = normalizePrimeUiApiRoot(env.PRIMEUI_API_BASE_URL);
+    projectInfoUrl = buildPrimeUiApiUrl(apiRoot, "project");
+  } catch (error) {
+    apiCheck = {
+      status: "skipped",
+      apiBaseUrlSource,
+      nonStandardBaseUrl: Boolean(env.PRIMEUI_API_BASE_URL?.trim()),
+      message: error instanceof Error ? error.message : String(error),
+      errorKind: "configuration"
+    };
+  }
+  if (!apiCheck) {
+    if (!apiKeyDetails.apiKey) {
+      apiCheck = {
+        status: "skipped",
+        apiRoot,
+        projectInfoUrl,
+        apiBaseUrlSource,
+        nonStandardBaseUrl: apiRoot !== defaultApiRoot,
+        message: "No usable API key was available, so project info was not requested."
+      };
+    } else {
+      const provider = options.createProvider?.({
+        apiKey: apiKeyDetails.apiKey,
+        baseUrl: env.PRIMEUI_API_BASE_URL
+      }) ?? new ApiProjectDataProvider({
+        apiKey: apiKeyDetails.apiKey,
+        baseUrl: env.PRIMEUI_API_BASE_URL
+      });
+      try {
+        await provider.getProjectInfo();
+        apiCheck = {
+          status: "passed",
+          apiRoot,
+          projectInfoUrl,
+          apiBaseUrlSource,
+          nonStandardBaseUrl: apiRoot !== defaultApiRoot,
+          message: "Project info request succeeded with the current API key."
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        apiCheck = {
+          status: "failed",
+          apiRoot,
+          projectInfoUrl,
+          apiBaseUrlSource,
+          nonStandardBaseUrl: apiRoot !== defaultApiRoot,
+          message,
+          errorKind: classifyApiError(message)
+        };
+      }
+    }
+  }
+  if (!apiCheck) {
+    throw new Error(
+      "PrimeUI health check did not produce an API check result."
+    );
+  }
+  const report = {
+    version: {
+      currentVersion: metadata.version,
+      latestVersion: versionResult.latestVersion,
+      updateStatus: versionResult.status,
+      detail: versionResult.detail
+    },
+    runtimeContext: {
+      cwd,
+      inputProjectRoot,
+      envProjectRoot,
+      envApiBaseUrl: env.PRIMEUI_API_BASE_URL?.trim() || void 0,
+      envApiKeySet: Boolean(env.PRIMEUI_API_KEY?.trim())
+    },
+    sourceResolution: {
+      projectRoot: {
+        inputPath: inputProjectRoot,
+        envPath: envProjectRoot,
+        comparison: compareProjectRoots(inputProjectRoot, envProjectRoot),
+        effectiveSource: mapProjectSource(
+          resolvedProjectConfig?.source ?? projectConfigError?.details.source
+        )
+      },
+      apiKey: {
+        envState: apiKeyDetails.envProvided ? "set" : "missing",
+        configState: configApiKeyState,
+        comparison: compareApiKeys(
+          apiKeyDetails.valuesMatch,
+          apiKeyDetails.envProvided,
+          apiKeyDetails.configProvided
+        ),
+        effectiveSource: apiKeyDetails.source
+      }
+    },
+    projectResolution: {
+      resolvedProjectRoot,
+      effectiveSource: mapProjectSource(
+        resolvedProjectConfig?.source ?? projectConfigError?.details.source
+      ),
+      errorSource: mapProjectErrorSource(
+        projectConfigError?.details.source
+      ),
+      primeUiDirPath,
+      primeUiDirStatus,
+      configPath,
+      configStatus,
+      targetProjectPath: resolvedProjectConfig?.projectConfig.targetProjectPath,
+      targetProjectRoot: resolvedProjectConfig ? resolvePrimeUiTargetProjectRoot(
+        resolvedProjectConfig.projectRoot,
+        resolvedProjectConfig.projectConfig
+      ) : void 0,
+      errorCode: projectConfigError?.code,
+      errorMessage: projectConfigError?.message,
+      inputProjectRootValidated: Boolean(inputProjectRoot) && resolvedProjectConfig?.source === "tool"
+    },
+    nestedSearch: {
+      performed: nestedSearchPerformed,
+      rootPath: nestedSearchPerformed ? inputProjectRoot : void 0,
+      candidates: nestedCandidates
+    },
+    apiCheck,
+    hints: []
+  };
+  report.hints = buildHealthHints({
+    report,
+    connectApiKey: nestedSearchPerformed && nestedCandidates.length === 0 && apiCheck.status === "passed" ? apiKeyDetails.apiKey : void 0
+  });
+  options.stdout.write(`${formatHealthReport(report)}
+`);
+  return 0;
+}
+
+// src/services/project-sync-service.ts
+import path10 from "path";
+import { readFile as readFile4 } from "fs/promises";
+
 // src/services/page-copy-service.ts
-import { readFile as readFile3, readdir, stat as stat3, writeFile as writeFile2 } from "fs/promises";
-import path4 from "path";
+import { readFile as readFile3, readdir as readdir2, stat as stat5, writeFile as writeFile2 } from "fs/promises";
+import path9 from "path";
 
 // src/lib/import-graph.ts
-import { readFile as readFile2, stat as stat2 } from "fs/promises";
+import { readFile as readFile2, stat as stat4 } from "fs/promises";
 import { builtinModules } from "module";
-import path3 from "path";
+import path8 from "path";
 var INTERNAL_EXTENSIONS = [
   ".ts",
   ".tsx",
@@ -349,14 +1584,14 @@ function getExternalPackageName(specifier) {
 }
 async function pathExists(filePath) {
   try {
-    await stat2(filePath);
+    await stat4(filePath);
     return true;
   } catch {
     return false;
   }
 }
 async function resolveFileCandidate(candidateBase) {
-  const ext = path3.extname(candidateBase);
+  const ext = path8.extname(candidateBase);
   if (ext) {
     if (await pathExists(candidateBase)) {
       return candidateBase;
@@ -370,13 +1605,13 @@ async function resolveFileCandidate(candidateBase) {
     }
   }
   if (await pathExists(candidateBase)) {
-    const stats = await stat2(candidateBase);
+    const stats = await stat4(candidateBase);
     if (stats.isFile()) {
       return candidateBase;
     }
     if (stats.isDirectory()) {
       for (const extension of INTERNAL_EXTENSIONS) {
-        const indexCandidate = path3.join(candidateBase, `index${extension}`);
+        const indexCandidate = path8.join(candidateBase, `index${extension}`);
         if (await pathExists(indexCandidate)) {
           return indexCandidate;
         }
@@ -398,13 +1633,13 @@ async function resolveImportToFile(projectRoot, importerFilePath, specifier) {
   }
   let candidateBase = null;
   if (specifier.startsWith("@/")) {
-    candidateBase = path3.join(projectRoot, "src", specifier.slice(2));
+    candidateBase = path8.join(projectRoot, "src", specifier.slice(2));
   } else if (specifier.startsWith("@root/")) {
-    candidateBase = path3.join(projectRoot, specifier.slice(6));
+    candidateBase = path8.join(projectRoot, specifier.slice(6));
   } else if (specifier.startsWith(".")) {
-    candidateBase = path3.resolve(path3.dirname(importerFilePath), specifier);
+    candidateBase = path8.resolve(path8.dirname(importerFilePath), specifier);
   } else if (specifier.startsWith("/")) {
-    candidateBase = path3.join(projectRoot, specifier.slice(1));
+    candidateBase = path8.join(projectRoot, specifier.slice(1));
   } else {
     return { kind: "unknown" };
   }
@@ -418,12 +1653,12 @@ async function resolveImportToFile(projectRoot, importerFilePath, specifier) {
   };
 }
 function shouldParseFile(filePath) {
-  return PARSEABLE_EXTENSIONS.has(path3.extname(filePath).toLowerCase());
+  return PARSEABLE_EXTENSIONS.has(path8.extname(filePath).toLowerCase());
 }
 async function buildImportGraph(input) {
   const shouldFollowInternalImports = input.followInternalImports ?? true;
-  const projectRoot = path3.resolve(input.projectRoot);
-  const queue = input.entryFiles.map((filePath) => path3.resolve(filePath));
+  const projectRoot = path8.resolve(input.projectRoot);
+  const queue = input.entryFiles.map((filePath) => path8.resolve(filePath));
   const visited = /* @__PURE__ */ new Set();
   const internalFiles = /* @__PURE__ */ new Set();
   const externalPackages = /* @__PURE__ */ new Set();
@@ -676,10 +1911,10 @@ function normalizeSlug2(slug) {
   return withLeadingSlash.replace(/\/+$/, "") || "/";
 }
 function toPosixPath(value) {
-  return value.split(path4.sep).join("/");
+  return value.split(path9.sep).join("/");
 }
 function toProjectRelative(rootPath, absolutePath) {
-  return toPosixPath(path4.relative(rootPath, absolutePath));
+  return toPosixPath(path9.relative(rootPath, absolutePath));
 }
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -736,7 +1971,7 @@ function buildPlannedSourceBuffer(sourceBuffer, sourceFilePath, importRewritePla
   if (!importRewritePlan) {
     return sourceBuffer;
   }
-  const extension = path4.extname(sourceFilePath).toLowerCase();
+  const extension = path9.extname(sourceFilePath).toLowerCase();
   if (!REWRITABLE_IMPORT_EXTENSIONS.has(extension)) {
     return sourceBuffer;
   }
@@ -759,7 +1994,7 @@ async function readJsonFile(filePath) {
 }
 async function fileExists2(filePath) {
   try {
-    await stat3(filePath);
+    await stat5(filePath);
     return true;
   } catch {
     return false;
@@ -838,14 +2073,14 @@ async function resolveManifestCandidateFiles(input) {
       );
     }
     const normalizedRelative = toPosixPath(trimmed).replace(/^\.\/+/, "");
-    const absolutePath = path4.resolve(input.exportPath, normalizedRelative);
-    const relative = path4.relative(input.exportPath, absolutePath);
-    if (relative.startsWith("..") || path4.isAbsolute(relative)) {
+    const absolutePath = path9.resolve(input.exportPath, normalizedRelative);
+    const relative = path9.relative(input.exportPath, absolutePath);
+    if (relative.startsWith("..") || path9.isAbsolute(relative)) {
       throw new Error(
         `Export manifest for page "${input.pageSlug}" contains path outside export root: ${trimmed}`
       );
     }
-    const stats = await stat3(absolutePath).catch(() => null);
+    const stats = await stat5(absolutePath).catch(() => null);
     if (!stats?.isFile()) {
       throw new Error(
         `Export manifest file is missing for page "${input.pageSlug}": ${normalizedRelative}`
@@ -856,7 +2091,7 @@ async function resolveManifestCandidateFiles(input) {
   return [...result].sort((a, b) => a.localeCompare(b));
 }
 async function resolveSingleExportDirectory(exportsRoot) {
-  const entries = await readdir(exportsRoot, { withFileTypes: true });
+  const entries = await readdir2(exportsRoot, { withFileTypes: true });
   const exportDirectories = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
   if (exportDirectories.length === 0) {
     throw new Error(
@@ -871,12 +2106,12 @@ async function resolveSingleExportDirectory(exportsRoot) {
   const exportId = exportDirectories[0] ?? "";
   return {
     exportId,
-    exportPath: path4.join(exportsRoot, exportId)
+    exportPath: path9.join(exportsRoot, exportId)
   };
 }
 function ensureSafeTargetPath(projectRoot, targetPath) {
-  const relative = path4.relative(projectRoot, targetPath);
-  if (relative.startsWith("..") || path4.isAbsolute(relative)) {
+  const relative = path9.relative(projectRoot, targetPath);
+  if (relative.startsWith("..") || path9.isAbsolute(relative)) {
     throw new Error(
       `Refusing to write outside project root. Computed target: ${targetPath}`
     );
@@ -934,19 +2169,19 @@ function resolveTargetFilePath(input) {
   if (sourceFilePath === sourcePagePath) {
     return targetPagePath;
   }
-  const componentsPrefix = `${sourceComponentsPath}${path4.sep}`;
+  const componentsPrefix = `${sourceComponentsPath}${path9.sep}`;
   if (sourceFilePath === sourceComponentsPath || sourceFilePath.startsWith(componentsPrefix)) {
-    const relativeToComponents = path4.relative(
+    const relativeToComponents = path9.relative(
       sourceComponentsPath,
       sourceFilePath
     );
-    return path4.join(targetComponentsPath, relativeToComponents);
+    return path9.join(targetComponentsPath, relativeToComponents);
   }
-  const relativeToExport = path4.relative(exportRoot, sourceFilePath);
-  if (relativeToExport.startsWith("..") || path4.isAbsolute(relativeToExport)) {
+  const relativeToExport = path9.relative(exportRoot, sourceFilePath);
+  if (relativeToExport.startsWith("..") || path9.isAbsolute(relativeToExport)) {
     throw new Error(`Source file is outside export root: ${sourceFilePath}`);
   }
-  return path4.join(projectRoot, relativeToExport);
+  return path9.join(projectRoot, relativeToExport);
 }
 async function copyPageFromExport(input) {
   const normalizedOriginSlug = normalizeSlug2(input.originPageSlug);
@@ -957,7 +2192,7 @@ async function copyPageFromExport(input) {
   const { exportId, exportPath } = await resolveSingleExportDirectory(
     input.exportsRoot
   );
-  const manifestPath = path4.join(
+  const manifestPath = path9.join(
     input.exportsRoot,
     `${exportId}.manifest.json`
   );
@@ -980,13 +2215,13 @@ async function copyPageFromExport(input) {
       `Page not found in manifest for slug: ${normalizedOriginSlug}`
     );
   }
-  const sourcePagePath = path4.join(exportPath, page.pagePath);
-  const sourceComponentsPath = path4.join(exportPath, page.componentsPath);
-  const sourcePageStats = await stat3(sourcePagePath).catch(() => null);
+  const sourcePagePath = path9.join(exportPath, page.pagePath);
+  const sourceComponentsPath = path9.join(exportPath, page.componentsPath);
+  const sourcePageStats = await stat5(sourcePagePath).catch(() => null);
   if (!sourcePageStats?.isFile()) {
     throw new Error(`Source page file not found: ${sourcePagePath}`);
   }
-  const sourceComponentsStats = await stat3(sourceComponentsPath).catch(
+  const sourceComponentsStats = await stat5(sourceComponentsPath).catch(
     () => null
   );
   if (!sourceComponentsStats?.isDirectory()) {
@@ -1001,8 +2236,8 @@ async function copyPageFromExport(input) {
     pageType: page.pageType,
     slug: normalizedActualSlug
   });
-  const targetPagePath = path4.join(input.projectRoot, targetPaths.pagePath);
-  const targetComponentsPath = path4.join(
+  const targetPagePath = path9.join(input.projectRoot, targetPaths.pagePath);
+  const targetComponentsPath = path9.join(
     input.projectRoot,
     targetPaths.componentsPath
   );
@@ -1048,7 +2283,7 @@ async function copyPageFromExport(input) {
     const sourceRelative = toProjectRelative(exportPath, sourceFilePath);
     const targetRelative = toProjectRelative(input.projectRoot, targetFilePath);
     if (!targetBuffer) {
-      await ensureDir(path4.dirname(targetFilePath));
+      await ensureDir(path9.dirname(targetFilePath));
       await writeFile2(targetFilePath, plannedSourceBuffer);
       newFiles.push({
         sourcePath: sourceRelative,
@@ -1077,8 +2312,8 @@ async function copyPageFromExport(input) {
       isBinary
     });
   }
-  const exportPackageJsonPath = path4.join(exportPath, "package.json");
-  const userPackageJsonPath = path4.join(input.projectRoot, "package.json");
+  const exportPackageJsonPath = path9.join(exportPath, "package.json");
+  const userPackageJsonPath = path9.join(input.projectRoot, "package.json");
   if (!await fileExists2(exportPackageJsonPath)) {
     throw new Error(`Export package.json not found: ${exportPackageJsonPath}`);
   }
@@ -1284,7 +2519,7 @@ function isExportPage(value) {
   return typeof maybe.id === "string" && (typeof title === "string" || typeof title === "undefined") && typeof maybe.slug === "string" && typeof maybe.pageType === "string" && maybe.isReadyToExport === true && typeof maybe.pagePath === "string" && typeof maybe.componentsPath === "string" && isExportPageManifest(maybe.manifest);
 }
 function buildManifestPath(exportsRoot, exportId) {
-  return path5.join(exportsRoot, `${exportId}.manifest.json`);
+  return path10.join(exportsRoot, `${exportId}.manifest.json`);
 }
 function parseExportManifest(value) {
   if (!value || typeof value !== "object") {
@@ -1328,9 +2563,9 @@ var ProjectSyncService = class {
     this.projectRoot = options.projectRoot;
     this.targetProjectRoot = options.targetProjectRoot;
     this.provider = options.provider;
-    this.primeUiRoot = path5.join(this.projectRoot, ".primeui");
-    this.tempRoot = path5.join(this.primeUiRoot, "temp");
-    this.exportsRoot = path5.join(this.tempRoot, "exports");
+    this.primeUiRoot = path10.join(this.projectRoot, ".primeui");
+    this.tempRoot = path10.join(this.primeUiRoot, "temp");
+    this.exportsRoot = path10.join(this.tempRoot, "exports");
   }
   async getProjectInfo(_context) {
     await this.ensureTempLayout();
@@ -1355,8 +2590,8 @@ var ProjectSyncService = class {
     if (!selected) {
       throw new Error(`Export not found: ${id}`);
     }
-    const targetZipPath = path5.join(this.exportsRoot, `${id}.zip`);
-    const targetProjectPath = path5.join(this.exportsRoot, id);
+    const targetZipPath = path10.join(this.exportsRoot, `${id}.zip`);
+    const targetProjectPath = path10.join(this.exportsRoot, id);
     const manifestPath = buildManifestPath(this.exportsRoot, id);
     let manifest;
     try {
@@ -1416,319 +2651,6 @@ var ProjectSyncService = class {
   }
 };
 
-// src/sources/api-provider.ts
-import { createWriteStream } from "fs";
-import { unlink } from "fs/promises";
-import path6 from "path";
-import { Readable, Transform } from "stream";
-import { pipeline } from "stream/promises";
-import { z as z2 } from "zod";
-var DEFAULT_API_BASE_URL = "https://app.primeui.com/";
-var ZIP_CONTENT_TYPES = [
-  "application/zip",
-  "application/octet-stream",
-  "application/x-zip-compressed"
-];
-var exportStatusSchema = z2.enum(["in_progress", "completed", "failed"]);
-var projectPageObjectSchema = z2.object({
-  id: z2.string(),
-  title: z2.string(),
-  slug: z2.string(),
-  pageType: z2.string(),
-  isReadyToExport: z2.boolean(),
-  pagePath: z2.string(),
-  componentsPath: z2.string()
-});
-var projectPageSchema = projectPageObjectSchema;
-var exportSummarySchema = z2.object({
-  total: z2.number(),
-  successful: z2.number(),
-  failed: z2.number()
-});
-var exportedComponentSchema = z2.object({
-  componentKey: z2.string(),
-  enabled: z2.boolean(),
-  files: z2.array(z2.string()),
-  message: z2.string()
-});
-var exportPageManifestSchema = z2.object({
-  success: z2.boolean(),
-  message: z2.string(),
-  files: z2.array(z2.string())
-});
-var exportPageSchema = z2.object({
-  id: z2.string(),
-  title: z2.string().optional(),
-  slug: z2.string(),
-  pageType: z2.string(),
-  isReadyToExport: z2.literal(true),
-  pagePath: z2.string(),
-  componentsPath: z2.string(),
-  manifest: exportPageManifestSchema
-});
-var projectInfoSchema = z2.object({
-  projectId: z2.string(),
-  projectName: z2.string(),
-  metadata: z2.record(z2.unknown()),
-  pages: z2.array(projectPageSchema)
-});
-var projectPageComponentSchema = z2.object({
-  blockId: z2.string(),
-  componentId: z2.string(),
-  componentGroup: z2.string(),
-  slot: z2.string().nullable(),
-  props: z2.record(z2.unknown()).nullable()
-});
-var projectPageDetailsSchema = z2.object({
-  page: projectPageObjectSchema.extend({
-    pageInstruction: z2.string().nullable()
-  }),
-  variant: z2.object({
-    id: z2.string(),
-    name: z2.string()
-  }).nullable(),
-  components: z2.array(projectPageComponentSchema).nullable()
-});
-var exportsResponseSchema = z2.object({
-  exports: z2.array(
-    z2.object({
-      id: z2.string(),
-      status: exportStatusSchema,
-      createdAt: z2.string().datetime({ offset: true })
-    })
-  )
-});
-var createExportResponseSchema = z2.object({
-  export: z2.object({
-    id: z2.string(),
-    status: exportStatusSchema,
-    createdAt: z2.string().datetime({ offset: true }),
-    expiresAt: z2.string().datetime({ offset: true }).nullable(),
-    summary: exportSummarySchema,
-    components: z2.array(exportedComponentSchema)
-  }),
-  pages: z2.array(exportPageSchema)
-});
-var PrimeUiApiContractError = class extends Error {
-  constructor(endpoint, details) {
-    super(`PrimeUI API contract mismatch for "${endpoint}": ${details}`);
-    this.name = "PrimeUiApiContractError";
-  }
-};
-var normalizeApiRoot = (rawBaseUrl) => {
-  const normalizedBase = rawBaseUrl.trim() || DEFAULT_API_BASE_URL;
-  const parsed = new URL(normalizedBase);
-  const normalizedPath = parsed.pathname.replace(/\/+$/, "");
-  if (normalizedPath.endsWith("/api/v1")) {
-    parsed.pathname = `${normalizedPath}/`;
-    return parsed.toString();
-  }
-  parsed.pathname = `${normalizedPath}/api/v1/`.replace(
-    "//api/v1/",
-    "/api/v1/"
-  );
-  return parsed.toString();
-};
-var isJsonContentType = (contentType) => contentType.includes("application/json") || contentType.includes("+json");
-var isZipContentType = (contentType) => ZIP_CONTENT_TYPES.some((allowedType) => contentType.includes(allowedType));
-var looksLikeZipArchive = (buffer) => {
-  if (buffer.length < 4) {
-    return false;
-  }
-  if (buffer[0] !== 80 || buffer[1] !== 75) {
-    return false;
-  }
-  const signature = `${buffer[2]}:${buffer[3]}`;
-  return signature === "3:4" || signature === "5:6" || signature === "7:8";
-};
-var createZipSignatureGuard = (endpoint) => {
-  let signature = Buffer.alloc(0);
-  let validated = false;
-  return new Transform({
-    transform(chunk, _encoding, callback) {
-      const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-      if (!validated) {
-        const requiredBytes = Math.max(0, 4 - signature.length);
-        if (requiredBytes > 0) {
-          signature = Buffer.concat([
-            signature,
-            chunkBuffer.subarray(0, requiredBytes)
-          ]);
-        }
-        if (signature.length >= 4) {
-          if (!looksLikeZipArchive(signature)) {
-            callback(
-              new PrimeUiApiContractError(
-                endpoint,
-                "response body is not a valid zip archive"
-              )
-            );
-            return;
-          }
-          validated = true;
-        }
-      }
-      callback(null, chunkBuffer);
-    },
-    flush(callback) {
-      if (!validated) {
-        callback(
-          new PrimeUiApiContractError(
-            endpoint,
-            "response body is not a valid zip archive"
-          )
-        );
-        return;
-      }
-      callback();
-    }
-  });
-};
-var ApiProjectDataProvider = class {
-  apiKey;
-  apiRoot;
-  constructor(options) {
-    this.apiKey = options.apiKey;
-    this.apiRoot = normalizeApiRoot(options.baseUrl ?? DEFAULT_API_BASE_URL);
-  }
-  async getProjectInfo() {
-    return this.requestJson("project", projectInfoSchema);
-  }
-  async getProjectPageBySlug(slug) {
-    const encodedSlug = encodeURIComponent(slug);
-    return this.requestJson(
-      `project/page?slug=${encodedSlug}`,
-      projectPageDetailsSchema
-    );
-  }
-  async listExports() {
-    const response = await this.requestJson(
-      "project/exports",
-      exportsResponseSchema
-    );
-    return response.exports;
-  }
-  async createExport() {
-    return this.requestJson("project/exports", createExportResponseSchema, {
-      method: "POST"
-    });
-  }
-  /**
-   * Consumer-side runtime contract for GET /api/v1/project/exports/:exportId/download.
-   * Producer source of truth: apps/studio/src/app/api/v1/project/exports/[exportId]/download/route.ts
-   * Keep content-type and archive format checks synchronized with the producer response.
-   */
-  async downloadExportArchive(exportId, destinationPath) {
-    const endpoint = `project/exports/${encodeURIComponent(exportId)}/download`;
-    const apiKey = this.requireApiKey();
-    const response = await fetch(this.buildUrl(endpoint), {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${apiKey}`
-      }
-    });
-    if (!response.ok) {
-      const details = await this.readError(response);
-      throw new Error(
-        `PrimeUI API request failed (${response.status}) while downloading export "${exportId}": ${details}`
-      );
-    }
-    const contentType = response.headers.get("content-type") ?? "";
-    if (!isZipContentType(contentType)) {
-      throw new PrimeUiApiContractError(
-        endpoint,
-        `expected zip content-type but got "${contentType || "unknown"}"`
-      );
-    }
-    if (!response.body) {
-      throw new PrimeUiApiContractError(endpoint, "response body is empty");
-    }
-    await ensureDir(path6.dirname(destinationPath));
-    const zipStream = Readable.fromWeb(
-      response.body
-    );
-    const signatureGuard = createZipSignatureGuard(endpoint);
-    const fileStream = createWriteStream(destinationPath);
-    try {
-      await pipeline(zipStream, signatureGuard, fileStream);
-    } catch (error) {
-      await unlink(destinationPath).catch(() => void 0);
-      throw error;
-    }
-  }
-  buildUrl(endpoint) {
-    return new URL(endpoint, this.apiRoot).toString();
-  }
-  async requestJson(endpoint, schema, requestInit = {}) {
-    const apiKey = this.requireApiKey();
-    const method = requestInit.method ?? "GET";
-    const response = await fetch(this.buildUrl(endpoint), {
-      ...requestInit,
-      method,
-      headers: {
-        ...requestInit.headers ?? {},
-        Authorization: `Bearer ${apiKey}`
-      }
-    });
-    if (!response.ok) {
-      const details = await this.readError(response);
-      throw new Error(
-        `PrimeUI API request failed (${response.status}) for "${endpoint}": ${details}`
-      );
-    }
-    const contentType = response.headers.get("content-type") ?? "";
-    if (!isJsonContentType(contentType)) {
-      throw new PrimeUiApiContractError(
-        endpoint,
-        `expected JSON content-type but got "${contentType || "unknown"}"`
-      );
-    }
-    let payload;
-    try {
-      payload = await response.json();
-    } catch {
-      throw new PrimeUiApiContractError(
-        endpoint,
-        "response body is not valid JSON"
-      );
-    }
-    const parsed = schema.safeParse(payload);
-    if (!parsed.success) {
-      const details = parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
-      throw new PrimeUiApiContractError(endpoint, details);
-    }
-    return parsed.data;
-  }
-  async readError(response) {
-    const contentType = response.headers.get("content-type") ?? "";
-    try {
-      if (isJsonContentType(contentType)) {
-        const body = await response.json();
-        if (body?.message && body?.code) {
-          return `${body.code}: ${body.message}`;
-        }
-        if (body?.message) {
-          return body.message;
-        }
-      } else {
-        const bodyText = await response.text();
-        if (bodyText.trim()) {
-          return bodyText.trim();
-        }
-      }
-    } catch {
-    }
-    return response.statusText || "Unknown error";
-  }
-  requireApiKey() {
-    const apiKey = this.apiKey?.trim();
-    if (!apiKey) {
-      throw new Error("PRIMEUI_API_KEY is required to call PrimeUI API tools.");
-    }
-    return apiKey;
-  }
-};
-
 // src/runtime.ts
 function defaultCreateProvider(options) {
   return new ApiProjectDataProvider(options);
@@ -1759,9 +2681,9 @@ var LazyProjectSyncSource = class {
       projectRootFromEnv: this.env.PRIMEUI_PROJECT_ROOT
     });
     const projectRoot = resolvedProjectConfig.projectRoot;
-    const targetProjectRoot = path7.resolve(
+    const targetProjectRoot = resolvePrimeUiTargetProjectRoot(
       projectRoot,
-      resolvedProjectConfig.projectConfig.targetProjectPath
+      resolvedProjectConfig.projectConfig
     );
     const apiKey = await resolvePrimeUiApiKey({
       projectConfig: resolvedProjectConfig.projectConfig,
@@ -1823,132 +2745,132 @@ var LazyProjectSyncSource = class {
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/instructions.ts
-import { z as z3 } from "zod/v3";
-var pageSchema = z3.object({
-  id: z3.string().describe(
+import { z as z4 } from "zod/v3";
+var pageSchema = z4.object({
+  id: z4.string().describe(
     "Stable PrimeUI page identifier. Use this to match the same page across tool responses."
   ),
-  title: z3.string().describe(
+  title: z4.string().describe(
     "Human-readable page title. Show this to the user when confirming which pages to import."
   ),
-  slug: z3.string().describe(
+  slug: z4.string().describe(
     "PrimeUI route slug, for example '/', '/pricing', '/docs/getting-started'. Use to match user intent."
   ),
-  pageType: z3.string().describe(
+  pageType: z4.string().describe(
     "PrimeUI page type classification (for example landing, docs, pricing, blogIndex, legal)."
   ),
-  isReadyToExport: z3.boolean().describe(
+  isReadyToExport: z4.boolean().describe(
     "True when this page has an active export-ready variant. Only ready pages are expected in export output."
   ),
-  pagePath: z3.string().describe(
+  pagePath: z4.string().describe(
     "Relative file path to the page source inside downloaded export root. Copy page code from this exact path."
   ),
-  componentsPath: z3.string().describe(
+  componentsPath: z4.string().describe(
     "Relative directory path inside downloaded export root where page-level components live. Use as dependency copy start."
   )
 }).describe(
   "PrimeUI page descriptor used by project and export tools. Paths are always relative to export project root."
 );
-var exportStatusSchema2 = z3.enum(["in_progress", "completed", "failed"]).describe(
+var exportStatusSchema2 = z4.enum(["in_progress", "completed", "failed"]).describe(
   "Export lifecycle state. Use 'completed' before calling download_export."
 );
-var exportItemSchema = z3.object({
-  id: z3.string().describe(
+var exportItemSchema = z4.object({
+  id: z4.string().describe(
     "Export identifier. Pass this value to download_export input.id."
   ),
   status: exportStatusSchema2,
-  createdAt: z3.string().describe("Export creation timestamp in ISO-8601 UTC format.")
+  createdAt: z4.string().describe("Export creation timestamp in ISO-8601 UTC format.")
 }).describe("Single export record from PrimeUI export history.");
-var exportSummarySchema2 = z3.object({
-  total: z3.number().describe("Total pages processed in this export run."),
-  successful: z3.number().describe("Number of pages exported successfully."),
-  failed: z3.number().describe("Number of pages that failed export.")
+var exportSummarySchema2 = z4.object({
+  total: z4.number().describe("Total pages processed in this export run."),
+  successful: z4.number().describe("Number of pages exported successfully."),
+  failed: z4.number().describe("Number of pages that failed export.")
 });
-var exportComponentSchema = z3.object({
-  componentKey: z3.string().describe("Global component key from export manifest."),
-  enabled: z3.boolean().describe("True when this global component was exported."),
-  files: z3.array(z3.string()).describe("Files associated with this global component."),
-  message: z3.string().describe("Export status message for this global component.")
+var exportComponentSchema = z4.object({
+  componentKey: z4.string().describe("Global component key from export manifest."),
+  enabled: z4.boolean().describe("True when this global component was exported."),
+  files: z4.array(z4.string()).describe("Files associated with this global component."),
+  message: z4.string().describe("Export status message for this global component.")
 });
-var exportPageManifestSchema2 = z3.object({
-  success: z3.boolean().describe("True when page export succeeded in this export run."),
-  message: z3.string().describe("Export status message for this page."),
-  files: z3.array(z3.string()).describe(
+var exportPageManifestSchema2 = z4.object({
+  success: z4.boolean().describe("True when page export succeeded in this export run."),
+  message: z4.string().describe("Export status message for this page."),
+  files: z4.array(z4.string()).describe(
     "Authoritative list of page-related files from PrimeUI export manifest, including shared project files required by this page."
   )
 });
-var exportPageSchema2 = z3.object({
-  id: z3.string().describe("Stable PrimeUI page identifier for this export entry."),
-  title: z3.string().optional().describe(
+var exportPageSchema2 = z4.object({
+  id: z4.string().describe("Stable PrimeUI page identifier for this export entry."),
+  title: z4.string().optional().describe(
     "Optional page title from export manifest. Can be undefined for some legacy records."
   ),
-  slug: z3.string().describe("PrimeUI page slug included in this export."),
-  pageType: z3.string().describe("PrimeUI page type for routing/path resolution."),
-  isReadyToExport: z3.literal(true).describe("Always true for pages included in export payload."),
-  pagePath: z3.string().describe("Page source file path relative to export root."),
-  componentsPath: z3.string().describe("Page components directory path relative to export root."),
+  slug: z4.string().describe("PrimeUI page slug included in this export."),
+  pageType: z4.string().describe("PrimeUI page type for routing/path resolution."),
+  isReadyToExport: z4.literal(true).describe("Always true for pages included in export payload."),
+  pagePath: z4.string().describe("Page source file path relative to export root."),
+  componentsPath: z4.string().describe("Page components directory path relative to export root."),
   manifest: exportPageManifestSchema2
 });
-var fileTransferSchema = z3.object({
-  sourcePath: z3.string().describe("Relative source file path inside downloaded export root."),
-  targetPath: z3.string().describe("Relative target file path inside user project root.")
+var fileTransferSchema = z4.object({
+  sourcePath: z4.string().describe("Relative source file path inside downloaded export root."),
+  targetPath: z4.string().describe("Relative target file path inside user project root.")
 });
 var conflictFileSchema = fileTransferSchema.extend({
-  diff: z3.string().describe(
+  diff: z4.string().describe(
     "Unified diff between user file and export file. For binary files the diff contains a plain message."
   ),
-  isBinary: z3.boolean().describe("True if conflict comparison was treated as binary data.")
+  isBinary: z4.boolean().describe("True if conflict comparison was treated as binary data.")
 });
-var dependencySectionSchema = z3.enum([
+var dependencySectionSchema = z4.enum([
   "dependencies",
   "devDependencies",
   "peerDependencies"
 ]);
-var dependencyToAddSchema = z3.object({
-  packageName: z3.string().describe("Dependency package name that was missing in user package.json."),
-  version: z3.string().describe("Version from exported project's package.json."),
+var dependencyToAddSchema = z4.object({
+  packageName: z4.string().describe("Dependency package name that was missing in user package.json."),
+  version: z4.string().describe("Version from exported project's package.json."),
   section: dependencySectionSchema.describe(
     "package.json section where dependency should be added."
   )
 });
-var dependencyVersionConflictSchema = z3.object({
-  packageName: z3.string().describe("Dependency package name with version mismatch."),
+var dependencyVersionConflictSchema = z4.object({
+  packageName: z4.string().describe("Dependency package name with version mismatch."),
   section: dependencySectionSchema.describe(
     "Section where export expects this dependency."
   ),
-  exportVersion: z3.string().describe("Version found in exported project's package.json."),
-  userVersion: z3.string().describe("Version currently present in user's package.json.")
+  exportVersion: z4.string().describe("Version found in exported project's package.json."),
+  userVersion: z4.string().describe("Version currently present in user's package.json.")
 });
 var pageDetailsSchema = pageSchema.extend({
-  pageInstruction: z3.string().nullable().describe(
+  pageInstruction: z4.string().nullable().describe(
     "Current instruction text for the active page variant. Null when no active variant is set."
   )
 });
-var pageVariantSchema = z3.object({
-  id: z3.string().describe("Active variant identifier."),
-  name: z3.string().describe("Active variant display name.")
+var pageVariantSchema = z4.object({
+  id: z4.string().describe("Active variant identifier."),
+  name: z4.string().describe("Active variant display name.")
 }).nullable().describe(
   "Active page variant. Null when page has no active variant and components are unavailable."
 );
-var pageComponentSchema = z3.object({
-  blockId: z3.string().describe("Stable block identifier. Use as primary component instance ID."),
-  componentId: z3.string().describe("Component key from variant blocks payload (block.key)."),
-  componentGroup: z3.string().describe("Component family/group normalized from component key."),
-  slot: z3.string().nullable().describe("Optional slot value from block payload."),
-  props: z3.record(z3.unknown()).nullable().describe("Raw block props payload from PrimeUI.")
+var pageComponentSchema = z4.object({
+  blockId: z4.string().describe("Stable block identifier. Use as primary component instance ID."),
+  componentId: z4.string().describe("Component key from variant blocks payload (block.key)."),
+  componentGroup: z4.string().describe("Component family/group normalized from component key."),
+  slot: z4.string().nullable().describe("Optional slot value from block payload."),
+  props: z4.record(z4.unknown()).nullable().describe("Raw block props payload from PrimeUI.")
 });
-var inspectPageReportRowSchema = z3.object({
-  number: z3.number().describe("1-based row number matching report order."),
-  componentGroup: z3.string().describe("Component family/group label."),
-  componentId: z3.string().describe("Component key (block key)."),
-  blockId: z3.string().describe("Primary component instance identifier for future operations."),
-  title: z3.string().nullable().describe("Title extracted by MCP from component props."),
-  description: z3.string().nullable().describe("Description extracted by MCP from component props.")
+var inspectPageReportRowSchema = z4.object({
+  number: z4.number().describe("1-based row number matching report order."),
+  componentGroup: z4.string().describe("Component family/group label."),
+  componentId: z4.string().describe("Component key (block key)."),
+  blockId: z4.string().describe("Primary component instance identifier for future operations."),
+  title: z4.string().nullable().describe("Title extracted by MCP from component props."),
+  description: z4.string().nullable().describe("Description extracted by MCP from component props.")
 });
-var projectRootInputSchema = z3.string().optional().describe(
+var projectRootInputSchema = z4.string().optional().describe(
   "Optional absolute project root path. Use when .primeui/project.json cannot be auto-resolved from current working directory."
 );
-var optionalProjectRootInputObjectSchema = z3.object({
+var optionalProjectRootInputObjectSchema = z4.object({
   projectRoot: projectRootInputSchema
 }).optional();
 var TRIGGER_PHRASES = [
@@ -2032,17 +2954,17 @@ AFTER CALLING:
 
 ${WORKFLOW_SUMMARY}`,
   inputSchema: optionalProjectRootInputObjectSchema,
-  outputSchema: z3.object({
-    projectId: z3.string().describe(
+  outputSchema: z4.object({
+    projectId: z4.string().describe(
       "PrimeUI project identifier associated with the API key and current import session context."
     ),
-    projectName: z3.string().describe(
+    projectName: z4.string().describe(
       "Human-readable PrimeUI project name for confirmations in chat."
     ),
-    metadata: z3.record(z3.unknown()).describe(
+    metadata: z4.record(z4.unknown()).describe(
       "Additional project metadata from PrimeUI. May include project-description and other context fields."
     ),
-    pages: z3.array(pageSchema).describe(
+    pages: z4.array(pageSchema).describe(
       "All pages visible for this project context. Filter by user request and isReadyToExport before creating export."
     )
   }),
@@ -2073,22 +2995,22 @@ If page has no active variant, components is null (not empty array), and report
 ${WORKFLOW_SUMMARY}`,
   inputSchema: {
     projectRoot: projectRootInputSchema,
-    pageSlug: z3.string().describe(
+    pageSlug: z4.string().describe(
       "PrimeUI page slug to inspect, for example '/', '/pricing', '/docs/getting-started'."
     )
   },
-  outputSchema: z3.object({
+  outputSchema: z4.object({
     page: pageDetailsSchema.describe(
       "Single PrimeUI page details resolved by slug with pageInstruction."
     ),
     variant: pageVariantSchema,
-    components: z3.array(pageComponentSchema).nullable().describe(
+    components: z4.array(pageComponentSchema).nullable().describe(
       "Raw component instances from active variant. Null when page has no active variant."
     ),
-    report: z3.string().describe(
+    report: z4.string().describe(
       "Formatted report table generated by MCP from component payload (includes extracted title/description summary)."
     ),
-    reportRows: z3.array(inspectPageReportRowSchema).describe(
+    reportRows: z4.array(inspectPageReportRowSchema).describe(
       "Structured report rows with 1-based numbering and extracted title/description fields."
     )
   }),
@@ -2114,8 +3036,8 @@ Do NOT use this tool as a substitute for create_export. Always create a fresh ex
 
 ${WORKFLOW_SUMMARY}`,
   inputSchema: optionalProjectRootInputObjectSchema,
-  outputSchema: z3.object({
-    exports: z3.array(exportItemSchema).describe(
+  outputSchema: z4.object({
+    exports: z4.array(exportItemSchema).describe(
       "Available exports sorted by API policy. Use item.id to download a specific prior export if user asks."
     )
   }),
@@ -2142,24 +3064,24 @@ AFTER CALLING:
 
 ${WORKFLOW_SUMMARY}`,
   inputSchema: optionalProjectRootInputObjectSchema,
-  outputSchema: z3.object({
-    export: z3.object({
-      id: z3.string().describe(
+  outputSchema: z4.object({
+    export: z4.object({
+      id: z4.string().describe(
         "Freshly created export identifier. Use this as download_export input.id."
       ),
       status: exportStatusSchema2,
-      createdAt: z3.string().describe("Export creation timestamp in ISO-8601 UTC format."),
-      expiresAt: z3.string().nullable().describe(
+      createdAt: z4.string().describe("Export creation timestamp in ISO-8601 UTC format."),
+      expiresAt: z4.string().nullable().describe(
         "Export expiration timestamp in ISO-8601 UTC format, or null when export has no explicit expiration."
       ),
       summary: exportSummarySchema2.describe(
         "Export run summary with total/successful/failed counters."
       ),
-      components: z3.array(exportComponentSchema).describe(
+      components: z4.array(exportComponentSchema).describe(
         "Global component export manifest. These components are independent from page-level manifests."
       )
     }).describe("Created export summary."),
-    pages: z3.array(exportPageSchema2).describe(
+    pages: z4.array(exportPageSchema2).describe(
       "Strict page payload associated with this export, including per-page manifest files list."
     )
   }),
@@ -2193,21 +3115,21 @@ AFTER DOWNLOAD:
   ${WORKFLOW_SUMMARY}`,
   inputSchema: {
     projectRoot: projectRootInputSchema,
-    id: z3.string().describe(
+    id: z4.string().describe(
       "Export identifier to download. Prefer export.id from create_export; use list_exports only on explicit user request."
     )
   },
-  outputSchema: z3.object({
-    exportId: z3.string().describe(
+  outputSchema: z4.object({
+    exportId: z4.string().describe(
       "Downloaded export identifier. Should match the requested input.id for traceability."
     ),
-    projectPath: z3.string().describe(
+    projectPath: z4.string().describe(
       "Absolute local path to extracted export root in .primeui/temp/exports/[exportId]. Read files from here only."
     ),
-    manifestPath: z3.string().describe(
+    manifestPath: z4.string().describe(
       "Absolute path to sidecar export manifest file (.primeui/temp/exports/[exportId].manifest.json) saved by create_export and required by copy_page."
     ),
-    pages: z3.array(exportPageSchema2).describe(
+    pages: z4.array(exportPageSchema2).describe(
       "Page descriptors loaded from local sidecar export manifest for import decisions."
     )
   }),
@@ -2243,46 +3165,46 @@ BEHAVIOR:
 ${WORKFLOW_SUMMARY}`,
   inputSchema: {
     projectRoot: projectRootInputSchema,
-    originPageSlug: z3.string().describe(
+    originPageSlug: z4.string().describe(
       "Source page slug from PrimeUI project pages list, for example '/', '/pricing', '/docs'."
     ),
-    actualPageSlug: z3.string().optional().describe(
+    actualPageSlug: z4.string().optional().describe(
       "Optional destination slug in user's project. If omitted, originPageSlug is used."
     )
   },
-  outputSchema: z3.object({
-    exportId: z3.string().describe("Resolved local export identifier used for copy operation."),
-    exportPath: z3.string().describe("Absolute path to local extracted export project root."),
-    originPageSlug: z3.string().describe("Normalized source page slug requested for copy."),
-    actualPageSlug: z3.string().describe("Normalized destination slug used for target route paths."),
-    sourcePagePath: z3.string().describe("Source page path relative to export root."),
-    targetPagePath: z3.string().describe("Destination page path relative to user project root."),
-    sourceComponentsPath: z3.string().describe("Source components directory relative to export root."),
-    targetComponentsPath: z3.string().describe(
+  outputSchema: z4.object({
+    exportId: z4.string().describe("Resolved local export identifier used for copy operation."),
+    exportPath: z4.string().describe("Absolute path to local extracted export project root."),
+    originPageSlug: z4.string().describe("Normalized source page slug requested for copy."),
+    actualPageSlug: z4.string().describe("Normalized destination slug used for target route paths."),
+    sourcePagePath: z4.string().describe("Source page path relative to export root."),
+    targetPagePath: z4.string().describe("Destination page path relative to user project root."),
+    sourceComponentsPath: z4.string().describe("Source components directory relative to export root."),
+    targetComponentsPath: z4.string().describe(
       "Destination components directory relative to user project root."
     ),
-    newFiles: z3.array(fileTransferSchema).describe("New files copied into user project without conflicts."),
-    identicalFiles: z3.array(fileTransferSchema).describe(
+    newFiles: z4.array(fileTransferSchema).describe("New files copied into user project without conflicts."),
+    identicalFiles: z4.array(fileTransferSchema).describe(
       "Existing files in user project that are byte-identical to export files."
     ),
-    conflictFiles: z3.array(conflictFileSchema).describe(
+    conflictFiles: z4.array(conflictFileSchema).describe(
       "Files that already exist and differ from export version. Never overwritten."
     ),
-    addedDependencies: z3.array(dependencyToAddSchema).describe(
+    addedDependencies: z4.array(dependencyToAddSchema).describe(
       "Dependencies that were missing and have been added to user's package.json."
     ),
-    dependenciesVersionConflicts: z3.array(dependencyVersionConflictSchema).describe(
+    dependenciesVersionConflicts: z4.array(dependencyVersionConflictSchema).describe(
       "Dependencies with version mismatch between export and user project. Report only."
     ),
-    summary: z3.object({
-      totalCandidateFiles: z3.number().describe(
+    summary: z4.object({
+      totalCandidateFiles: z4.number().describe(
         "Total number of candidate files considered for page copy from pages[].manifest.files."
       ),
-      copiedFiles: z3.number().describe("Number of files copied as new."),
-      identicalFiles: z3.number().describe("Number of files detected as identical."),
-      conflictFiles: z3.number().describe("Number of conflicting files not copied."),
-      addedDependencies: z3.number().describe("Count of dependencies added to package.json."),
-      dependenciesVersionConflicts: z3.number().describe("Count of dependency version mismatches reported.")
+      copiedFiles: z4.number().describe("Number of files copied as new."),
+      identicalFiles: z4.number().describe("Number of files detected as identical."),
+      conflictFiles: z4.number().describe("Number of conflicting files not copied."),
+      addedDependencies: z4.number().describe("Count of dependencies added to package.json."),
+      dependenciesVersionConflicts: z4.number().describe("Count of dependency version mismatches reported.")
     })
   }),
   annotations: {
@@ -2304,8 +3226,8 @@ Safe to call multiple times. Only affects .primeui/temp/ directory - never touch
 
 ${WORKFLOW_SUMMARY}`,
   inputSchema: optionalProjectRootInputObjectSchema,
-  outputSchema: z3.object({
-    success: z3.boolean().describe(
+  outputSchema: z4.object({
+    success: z4.boolean().describe(
       "True when temp cleanup completed and baseline temp structure was recreated."
     )
   }),
@@ -2364,7 +3286,7 @@ function createPrimeUiMcpServer(source) {
   const server = new McpServer(
     {
       name: "primeui-mcp-server",
-      version: "0.1.0"
+      version: packageMetadata.version
     },
     {
       instructions: initialInstructions
@@ -2482,12 +3404,28 @@ function createPrimeUiMcpServer(source) {
 }
 
 // src/service.ts
-async function main() {
+async function startPrimeUiMcpServer() {
   const source = new LazyProjectSyncSource();
   const server = createPrimeUiMcpServer(source);
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
+async function main() {
+  const exitCode = await runCli(process.argv.slice(2), {
+    stdout: process.stdout,
+    stderr: process.stderr,
+    startServer: startPrimeUiMcpServer,
+    runHealthCheck: ({ projectRoot }) => runHealthCheck({
+      projectRoot,
+      stdout: process.stdout,
+      env: process.env,
+      cwd: process.cwd()
+    })
+  });
+  if (exitCode !== 0) {
+    process.exitCode = exitCode;
+  }
+}
 main().catch((error) => {
   console.error("[primeui-mcp] failed to start", error);
   process.exit(1);