@primeuicom/mcp 0.1.16 → 0.1.18

package/dist/service.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
 // src/service.ts
-import path7 from "path";
+import path8 from "path";
+import { fileURLToPath } from "url";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/lib/project-link-config.ts
@@ -85,6 +86,9 @@ function toUniqueResolvedDirs(directories) {
   }
   return [...resolved];
 }
+function buildPrimeUiProjectSearchRoots(options) {
+  return toUniqueResolvedDirs([options.cwd, ...options.fallbackCwds ?? []]);
+}
 async function resolvePrimeUiProjectConfig(options) {
   const envProjectRoot = options.projectRootFromEnv?.trim();
   let projectConfigPath;
@@ -94,10 +98,10 @@ async function resolvePrimeUiProjectConfig(options) {
       PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH
     );
   } else {
-    const searchRoots = toUniqueResolvedDirs([
-      options.cwd,
-      ...options.fallbackCwds ?? []
-    ]);
+    const searchRoots = buildPrimeUiProjectSearchRoots({
+      cwd: options.cwd,
+      fallbackCwds: options.fallbackCwds
+    });
     for (const searchRoot of searchRoots) {
       const foundProjectConfigPath = await findPrimeUiProjectConfigPath(searchRoot);
       if (foundProjectConfigPath) {
@@ -264,6 +268,33 @@ var inspectPageReportRowSchema = z2.object({
   title: z2.string().nullable().describe("Title extracted by MCP from component props."),
   description: z2.string().nullable().describe("Description extracted by MCP from component props.")
 });
+var healthOptionSchema = z2.object({
+  key: z2.string().describe("Environment variable or diagnostic option name."),
+  description: z2.string().describe("Human-readable explanation of what this option controls."),
+  currentValue: z2.string().nullable().describe(
+    "Current effective value for this option. Null when not set or intentionally hidden."
+  )
+});
+var healthRuntimeSchema = z2.object({
+  cwd: z2.string().describe("process.cwd() observed by the MCP server process."),
+  initCwd: z2.string().nullable().describe("INIT_CWD environment value, if provided by the client runtime."),
+  pwd: z2.string().nullable().describe("PWD environment value, if provided by the client runtime."),
+  searchRoots: z2.array(z2.string()).describe(
+    "Resolved directories used when searching for .primeui/project.json."
+  ),
+  rootsListFallbackCwds: z2.array(z2.string()).describe(
+    "File-system roots derived from MCP roots/list and used as search fallbacks."
+  )
+});
+var healthConfigSchema = z2.object({
+  found: z2.boolean().describe("True when .primeui/project.json was found and parsed successfully."),
+  projectRoot: z2.string().nullable().describe("Resolved PrimeUI project root directory (parent of .primeui)."),
+  projectConfigPath: z2.string().nullable().describe("Absolute path to .primeui/project.json when found."),
+  targetProjectPath: z2.string().nullable().describe("targetProjectPath value loaded from project config."),
+  targetProjectRoot: z2.string().nullable().describe("Absolute target project root derived from targetProjectPath."),
+  source: z2.enum(["env.PRIMEUI_PROJECT_ROOT", "search"]).describe("How project config lookup was resolved."),
+  error: z2.string().nullable().describe("Human-readable resolution error when config is not available.")
+});
 var TRIGGER_PHRASES = [
   "import page from PrimeUI",
   "add page from PrimeUI",
@@ -294,6 +325,7 @@ ${WORKFLOW_SUMMARY}
 
 CRITICAL RULES FOR PAGE IMPORT:
 - Import is PAGE-BY-PAGE only. Never import the entire project at once.
+- Use health_check to inspect runtime path/config resolution when setup issues occur.
 - Always call clear_temp at the very beginning of a new import flow to avoid stale export state.
 - After get_project_info, always compare PrimeUI pages against the user's existing local project pages before proposing imports.
 - Reconciliation report MUST include: page presence match, slug/pagePath/componentsPath path match, and proposed action per page.
@@ -324,6 +356,34 @@ CRITICAL RULES FOR PAGE IMPORT:
 - If integration pattern is obvious, apply it and explicitly mark it in the report with "\u26A0 integration update".
 - If integration pattern is unclear, ask the user before editing integration files.
 `.trim();
+var toolHealthCheck = {
+  title: "PrimeUI Health Check",
+  description: `Diagnostic tool for MCP runtime setup. This tool MUST NOT fail: it always returns structured diagnostics even when project config is missing.
+
+WHEN TO USE:
+- Use this first when PrimeUI MCP tools fail due to project path/config issues.
+- Use this to verify cwd/env/roots behavior in different MCP clients (Codex, Claude Code, Inspector).
+
+RETURNS:
+- Runtime paths (cwd, INIT_CWD, PWD, search roots),
+- roots/list fallback paths from client (if available),
+- Whether .primeui/project.json was found and parsed,
+- Effective resolved project root/config path (when available),
+- Current option values and fallback guidance.`,
+  inputSchema: {},
+  outputSchema: {
+    status: z2.enum(["ok", "degraded"]).describe("Overall setup health. 'degraded' means config is unresolved."),
+    runtime: healthRuntimeSchema,
+    config: healthConfigSchema,
+    options: z2.array(healthOptionSchema).describe("Environment and runtime options relevant for configuration.")
+  },
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  }
+};
 var toolGetProjectInfo = {
   title: "PrimeUI Project Info",
   description: `ENTRY POINT for all PrimeUI import operations. Always start here. Returns project metadata and the full list of available pages.
@@ -651,6 +711,38 @@ function createPrimeUiMcpServer(source) {
       instructions: initialInstructions
     }
   );
+  server.registerTool(
+    "health_check",
+    toolHealthCheck,
+    async () => {
+      try {
+        const health = await source.healthCheck();
+        return okResult("health_check", health);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return okResult("health_check", {
+          status: "degraded",
+          runtime: {
+            cwd: process.cwd(),
+            initCwd: process.env.INIT_CWD?.trim() || null,
+            pwd: process.env.PWD?.trim() || null,
+            searchRoots: [process.cwd()],
+            rootsListFallbackCwds: []
+          },
+          config: {
+            found: false,
+            projectRoot: null,
+            projectConfigPath: null,
+            targetProjectPath: null,
+            targetProjectRoot: null,
+            source: "search",
+            error: `health_check fallback: ${message}`
+          },
+          options: []
+        });
+      }
+    }
+  );
   server.registerTool(
     "get_project_info",
     toolGetProjectInfo,
@@ -741,13 +833,118 @@ function createPrimeUiMcpServer(source) {
   return server;
 }
 
+// src/services/health-check-service.ts
+import path2 from "path";
+function normalizeOptional(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function buildHealthOptions(input) {
+  return [
+    {
+      key: "PRIMEUI_PROJECT_ROOT",
+      description: "Optional absolute root containing .primeui/project.json. Use as explicit override.",
+      currentValue: input.projectRootFromEnv
+    },
+    {
+      key: "PRIMEUI_API_BASE_URL",
+      description: "Optional PrimeUI API base URL override.",
+      currentValue: input.apiBaseUrlFromEnv
+    },
+    {
+      key: "PRIMEUI_API_KEY",
+      description: "Optional API key override. If missing, MCP uses apiKey from .primeui/project.json.",
+      currentValue: input.apiKeyFromEnv ? "set" : null
+    },
+    {
+      key: "Fallback search",
+      description: "When PRIMEUI_PROJECT_ROOT is not set, MCP searches from roots/list file roots, INIT_CWD, PWD, then process.cwd().",
+      currentValue: null
+    }
+  ];
+}
+async function runPrimeUiHealthCheck(input) {
+  const projectRootFromEnv = normalizeOptional(input.projectRootFromEnv);
+  const apiBaseUrlFromEnv = normalizeOptional(input.apiBaseUrlFromEnv);
+  const apiKeyFromEnv = normalizeOptional(input.apiKeyFromEnv);
+  const initCwd = normalizeOptional(input.initCwd);
+  const pwd = normalizeOptional(input.pwd);
+  const rootsListFallbackCwds = (input.rootsListFallbackCwds ?? []).map((value) => value.trim()).filter(Boolean).map((value) => path2.resolve(value));
+  const fallbackCwds = (input.fallbackCwds ?? []).map((value) => value.trim()).filter(Boolean);
+  const searchRoots = buildPrimeUiProjectSearchRoots({
+    cwd: input.cwd,
+    fallbackCwds
+  });
+  try {
+    const resolvedProjectConfig = await resolvePrimeUiProjectConfig({
+      cwd: input.cwd,
+      projectRootFromEnv: projectRootFromEnv ?? void 0,
+      fallbackCwds
+    });
+    const targetProjectPath = resolvedProjectConfig.projectConfig.targetProjectPath;
+    return {
+      status: "ok",
+      runtime: {
+        cwd: path2.resolve(input.cwd),
+        initCwd,
+        pwd,
+        searchRoots,
+        rootsListFallbackCwds
+      },
+      config: {
+        found: true,
+        projectRoot: resolvedProjectConfig.projectRoot,
+        projectConfigPath: resolvedProjectConfig.projectConfigPath,
+        targetProjectPath,
+        targetProjectRoot: path2.resolve(
+          resolvedProjectConfig.projectRoot,
+          targetProjectPath
+        ),
+        source: projectRootFromEnv ? "env.PRIMEUI_PROJECT_ROOT" : "search",
+        error: null
+      },
+      options: buildHealthOptions({
+        projectRootFromEnv,
+        apiBaseUrlFromEnv,
+        apiKeyFromEnv
+      })
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      status: "degraded",
+      runtime: {
+        cwd: path2.resolve(input.cwd),
+        initCwd,
+        pwd,
+        searchRoots,
+        rootsListFallbackCwds
+      },
+      config: {
+        found: false,
+        projectRoot: null,
+        projectConfigPath: null,
+        targetProjectPath: null,
+        targetProjectRoot: null,
+        source: projectRootFromEnv ? "env.PRIMEUI_PROJECT_ROOT" : "search",
+        error: message
+      },
+      options: buildHealthOptions({
+        projectRootFromEnv,
+        apiBaseUrlFromEnv,
+        apiKeyFromEnv
+      })
+    };
+  }
+}
+
 // src/services/project-sync-service.ts
-import path5 from "path";
+import path6 from "path";
 import { readFile as readFile4 } from "fs/promises";
 
 // src/lib/fs.ts
 import { mkdir, rm, writeFile } from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 import extractZipArchive from "extract-zip";
 async function ensureDir(dirPath) {
   await mkdir(dirPath, { recursive: true });
@@ -757,7 +954,7 @@ async function resetDir(dirPath) {
   await mkdir(dirPath, { recursive: true });
 }
 async function writeUtf8(filePath, content) {
-  await ensureDir(path2.dirname(filePath));
+  await ensureDir(path3.dirname(filePath));
   await writeFile(filePath, content, "utf-8");
 }
 async function extractZip(zipPath, targetDir) {
@@ -772,12 +969,12 @@ async function extractZip(zipPath, targetDir) {
 
 // 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 path5 from "path";
 
 // src/lib/import-graph.ts
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
 import { builtinModules } from "module";
-import path3 from "path";
+import path4 from "path";
 var INTERNAL_EXTENSIONS = [
   ".ts",
   ".tsx",
@@ -853,7 +1050,7 @@ async function pathExists(filePath) {
   }
 }
 async function resolveFileCandidate(candidateBase) {
-  const ext = path3.extname(candidateBase);
+  const ext = path4.extname(candidateBase);
   if (ext) {
     if (await pathExists(candidateBase)) {
       return candidateBase;
@@ -873,7 +1070,7 @@ async function resolveFileCandidate(candidateBase) {
     }
     if (stats.isDirectory()) {
       for (const extension of INTERNAL_EXTENSIONS) {
-        const indexCandidate = path3.join(candidateBase, `index${extension}`);
+        const indexCandidate = path4.join(candidateBase, `index${extension}`);
         if (await pathExists(indexCandidate)) {
           return indexCandidate;
         }
@@ -895,13 +1092,13 @@ async function resolveImportToFile(projectRoot, importerFilePath, specifier) {
   }
   let candidateBase = null;
   if (specifier.startsWith("@/")) {
-    candidateBase = path3.join(projectRoot, "src", specifier.slice(2));
+    candidateBase = path4.join(projectRoot, "src", specifier.slice(2));
   } else if (specifier.startsWith("@root/")) {
-    candidateBase = path3.join(projectRoot, specifier.slice(6));
+    candidateBase = path4.join(projectRoot, specifier.slice(6));
   } else if (specifier.startsWith(".")) {
-    candidateBase = path3.resolve(path3.dirname(importerFilePath), specifier);
+    candidateBase = path4.resolve(path4.dirname(importerFilePath), specifier);
   } else if (specifier.startsWith("/")) {
-    candidateBase = path3.join(projectRoot, specifier.slice(1));
+    candidateBase = path4.join(projectRoot, specifier.slice(1));
   } else {
     return { kind: "unknown" };
   }
@@ -915,12 +1112,12 @@ async function resolveImportToFile(projectRoot, importerFilePath, specifier) {
   };
 }
 function shouldParseFile(filePath) {
-  return PARSEABLE_EXTENSIONS.has(path3.extname(filePath).toLowerCase());
+  return PARSEABLE_EXTENSIONS.has(path4.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 = path4.resolve(input.projectRoot);
+  const queue = input.entryFiles.map((filePath) => path4.resolve(filePath));
   const visited = /* @__PURE__ */ new Set();
   const internalFiles = /* @__PURE__ */ new Set();
   const externalPackages = /* @__PURE__ */ new Set();
@@ -1173,10 +1370,10 @@ function normalizeSlug2(slug) {
   return withLeadingSlash.replace(/\/+$/, "") || "/";
 }
 function toPosixPath(value) {
-  return value.split(path4.sep).join("/");
+  return value.split(path5.sep).join("/");
 }
 function toProjectRelative(rootPath, absolutePath) {
-  return toPosixPath(path4.relative(rootPath, absolutePath));
+  return toPosixPath(path5.relative(rootPath, absolutePath));
 }
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -1233,7 +1430,7 @@ function buildPlannedSourceBuffer(sourceBuffer, sourceFilePath, importRewritePla
   if (!importRewritePlan) {
     return sourceBuffer;
   }
-  const extension = path4.extname(sourceFilePath).toLowerCase();
+  const extension = path5.extname(sourceFilePath).toLowerCase();
   if (!REWRITABLE_IMPORT_EXTENSIONS.has(extension)) {
     return sourceBuffer;
   }
@@ -1335,9 +1532,9 @@ 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 = path5.resolve(input.exportPath, normalizedRelative);
+    const relative = path5.relative(input.exportPath, absolutePath);
+    if (relative.startsWith("..") || path5.isAbsolute(relative)) {
       throw new Error(
         `Export manifest for page "${input.pageSlug}" contains path outside export root: ${trimmed}`
       );
@@ -1368,12 +1565,12 @@ async function resolveSingleExportDirectory(exportsRoot) {
   const exportId = exportDirectories[0] ?? "";
   return {
     exportId,
-    exportPath: path4.join(exportsRoot, exportId)
+    exportPath: path5.join(exportsRoot, exportId)
   };
 }
 function ensureSafeTargetPath(projectRoot, targetPath) {
-  const relative = path4.relative(projectRoot, targetPath);
-  if (relative.startsWith("..") || path4.isAbsolute(relative)) {
+  const relative = path5.relative(projectRoot, targetPath);
+  if (relative.startsWith("..") || path5.isAbsolute(relative)) {
     throw new Error(
       `Refusing to write outside project root. Computed target: ${targetPath}`
     );
@@ -1431,19 +1628,19 @@ function resolveTargetFilePath(input) {
   if (sourceFilePath === sourcePagePath) {
     return targetPagePath;
   }
-  const componentsPrefix = `${sourceComponentsPath}${path4.sep}`;
+  const componentsPrefix = `${sourceComponentsPath}${path5.sep}`;
   if (sourceFilePath === sourceComponentsPath || sourceFilePath.startsWith(componentsPrefix)) {
-    const relativeToComponents = path4.relative(
+    const relativeToComponents = path5.relative(
       sourceComponentsPath,
       sourceFilePath
     );
-    return path4.join(targetComponentsPath, relativeToComponents);
+    return path5.join(targetComponentsPath, relativeToComponents);
   }
-  const relativeToExport = path4.relative(exportRoot, sourceFilePath);
-  if (relativeToExport.startsWith("..") || path4.isAbsolute(relativeToExport)) {
+  const relativeToExport = path5.relative(exportRoot, sourceFilePath);
+  if (relativeToExport.startsWith("..") || path5.isAbsolute(relativeToExport)) {
     throw new Error(`Source file is outside export root: ${sourceFilePath}`);
   }
-  return path4.join(projectRoot, relativeToExport);
+  return path5.join(projectRoot, relativeToExport);
 }
 async function copyPageFromExport(input) {
   const normalizedOriginSlug = normalizeSlug2(input.originPageSlug);
@@ -1454,7 +1651,7 @@ async function copyPageFromExport(input) {
   const { exportId, exportPath } = await resolveSingleExportDirectory(
     input.exportsRoot
   );
-  const manifestPath = path4.join(
+  const manifestPath = path5.join(
     input.exportsRoot,
     `${exportId}.manifest.json`
   );
@@ -1477,8 +1674,8 @@ 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 sourcePagePath = path5.join(exportPath, page.pagePath);
+  const sourceComponentsPath = path5.join(exportPath, page.componentsPath);
   const sourcePageStats = await stat3(sourcePagePath).catch(() => null);
   if (!sourcePageStats?.isFile()) {
     throw new Error(`Source page file not found: ${sourcePagePath}`);
@@ -1498,8 +1695,8 @@ async function copyPageFromExport(input) {
     pageType: page.pageType,
     slug: normalizedActualSlug
   });
-  const targetPagePath = path4.join(input.projectRoot, targetPaths.pagePath);
-  const targetComponentsPath = path4.join(
+  const targetPagePath = path5.join(input.projectRoot, targetPaths.pagePath);
+  const targetComponentsPath = path5.join(
     input.projectRoot,
     targetPaths.componentsPath
   );
@@ -1545,7 +1742,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(path5.dirname(targetFilePath));
       await writeFile2(targetFilePath, plannedSourceBuffer);
       newFiles.push({
         sourcePath: sourceRelative,
@@ -1574,8 +1771,8 @@ async function copyPageFromExport(input) {
       isBinary
     });
   }
-  const exportPackageJsonPath = path4.join(exportPath, "package.json");
-  const userPackageJsonPath = path4.join(input.projectRoot, "package.json");
+  const exportPackageJsonPath = path5.join(exportPath, "package.json");
+  const userPackageJsonPath = path5.join(input.projectRoot, "package.json");
   if (!await fileExists2(exportPackageJsonPath)) {
     throw new Error(`Export package.json not found: ${exportPackageJsonPath}`);
   }
@@ -1781,7 +1978,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 path6.join(exportsRoot, `${exportId}.manifest.json`);
 }
 function parseExportManifest(value) {
   if (!value || typeof value !== "object") {
@@ -1825,9 +2022,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 = path6.join(this.projectRoot, ".primeui");
+    this.tempRoot = path6.join(this.primeUiRoot, "temp");
+    this.exportsRoot = path6.join(this.tempRoot, "exports");
   }
   async getProjectInfo() {
     await this.ensureTempLayout();
@@ -1852,8 +2049,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 = path6.join(this.exportsRoot, `${id}.zip`);
+    const targetProjectPath = path6.join(this.exportsRoot, id);
     const manifestPath = buildManifestPath(this.exportsRoot, id);
     let manifest;
     try {
@@ -1906,6 +2103,47 @@ var ProjectSyncService = class {
     await resetDir(this.tempRoot);
     await ensureDir(this.exportsRoot);
   }
+  async healthCheck() {
+    return {
+      status: "ok",
+      runtime: {
+        cwd: process.cwd(),
+        initCwd: process.env.INIT_CWD?.trim() || null,
+        pwd: process.env.PWD?.trim() || null,
+        searchRoots: [process.cwd()],
+        rootsListFallbackCwds: []
+      },
+      config: {
+        found: true,
+        projectRoot: this.projectRoot,
+        projectConfigPath: path6.join(this.projectRoot, ".primeui", "project.json"),
+        targetProjectPath: path6.relative(
+          this.projectRoot,
+          this.targetProjectRoot
+        ).startsWith(".") ? "./" : `./${path6.relative(this.projectRoot, this.targetProjectRoot)}`,
+        targetProjectRoot: this.targetProjectRoot,
+        source: process.env.PRIMEUI_PROJECT_ROOT?.trim() ? "env.PRIMEUI_PROJECT_ROOT" : "search",
+        error: null
+      },
+      options: [
+        {
+          key: "PRIMEUI_PROJECT_ROOT",
+          description: "Optional absolute root containing .primeui/project.json. Use as explicit override.",
+          currentValue: process.env.PRIMEUI_PROJECT_ROOT?.trim() || null
+        },
+        {
+          key: "PRIMEUI_API_BASE_URL",
+          description: "Optional PrimeUI API base URL override.",
+          currentValue: process.env.PRIMEUI_API_BASE_URL?.trim() || null
+        },
+        {
+          key: "PRIMEUI_API_KEY",
+          description: "Optional API key override. If missing, MCP uses apiKey from .primeui/project.json.",
+          currentValue: process.env.PRIMEUI_API_KEY?.trim() ? "set" : null
+        }
+      ]
+    };
+  }
   async ensureTempLayout() {
     await ensureDir(this.primeUiRoot);
     await ensureDir(this.tempRoot);
@@ -1916,7 +2154,7 @@ var ProjectSyncService = class {
 // src/sources/api-provider.ts
 import { createWriteStream } from "fs";
 import { unlink } from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 import { Readable, Transform } from "stream";
 import { pipeline } from "stream/promises";
 import { z as z3 } from "zod";
@@ -2140,7 +2378,7 @@ var ApiProjectDataProvider = class {
     if (!response.body) {
       throw new PrimeUiApiContractError(endpoint, "response body is empty");
     }
-    await ensureDir(path6.dirname(destinationPath));
+    await ensureDir(path7.dirname(destinationPath));
     const zipStream = Readable.fromWeb(
       response.body
     );
@@ -2230,17 +2468,22 @@ var ApiProjectDataProvider = class {
 function getProjectConfigFallbackCwds() {
   return [process.env.INIT_CWD, process.env.PWD].map((value) => value?.trim()).filter((value) => Boolean(value));
 }
-async function createProjectSyncService() {
+async function createProjectSyncService(rootsFallbackCwds) {
   const resolvedProjectConfig = await resolvePrimeUiProjectConfig({
     cwd: process.cwd(),
     projectRootFromEnv: process.env.PRIMEUI_PROJECT_ROOT,
-    fallbackCwds: getProjectConfigFallbackCwds()
+    fallbackCwds: [...getProjectConfigFallbackCwds(), ...rootsFallbackCwds]
   });
   const projectRoot = resolvedProjectConfig.projectRoot;
-  const targetProjectRoot = path7.resolve(
+  const targetProjectRoot = path8.resolve(
     projectRoot,
     resolvedProjectConfig.projectConfig.targetProjectPath
   );
+  console.error("[primeui-mcp] RESOLVED_PROJECT_ROOT:", projectRoot);
+  console.error(
+    "[primeui-mcp] RESOLVED_PROJECT_CONFIG:",
+    resolvedProjectConfig.projectConfigPath
+  );
   const apiKey = await resolvePrimeUiApiKey({
     projectConfig: resolvedProjectConfig.projectConfig,
     apiKeyFromEnv: process.env.PRIMEUI_API_KEY
@@ -2256,8 +2499,11 @@ async function createProjectSyncService() {
   });
 }
 var LazyProjectSyncSource = class {
+  constructor(getRootsFallbackCwds) {
+    this.getRootsFallbackCwds = getRootsFallbackCwds;
+  }
   async withService(operation) {
-    const service = await createProjectSyncService();
+    const service = await createProjectSyncService(this.getRootsFallbackCwds());
     return operation(service);
   }
   async getProjectInfo() {
@@ -2283,14 +2529,69 @@ var LazyProjectSyncSource = class {
   async clearTemp() {
     return this.withService((service) => service.clearTemp());
   }
+  async healthCheck() {
+    const rootsFallbackCwds = this.getRootsFallbackCwds();
+    const result = await runPrimeUiHealthCheck({
+      cwd: process.cwd(),
+      initCwd: process.env.INIT_CWD,
+      pwd: process.env.PWD,
+      projectRootFromEnv: process.env.PRIMEUI_PROJECT_ROOT,
+      apiBaseUrlFromEnv: process.env.PRIMEUI_API_BASE_URL,
+      apiKeyFromEnv: process.env.PRIMEUI_API_KEY,
+      fallbackCwds: [...getProjectConfigFallbackCwds(), ...rootsFallbackCwds],
+      rootsListFallbackCwds: rootsFallbackCwds
+    });
+    if (result.config.found) {
+      console.error("[primeui-mcp] RESOLVED_PROJECT_ROOT:", result.config.projectRoot);
+      console.error(
+        "[primeui-mcp] RESOLVED_PROJECT_CONFIG:",
+        result.config.projectConfigPath
+      );
+    } else {
+      console.error("[primeui-mcp] RESOLUTION_FAILED:", result.config.error);
+    }
+    return result;
+  }
 };
+function toFileRootPath(rootUri) {
+  try {
+    const parsed = new URL(rootUri);
+    if (parsed.protocol !== "file:") {
+      return null;
+    }
+    return fileURLToPath(parsed);
+  } catch {
+    return null;
+  }
+}
+async function loadClientRootFallbackCwds(server) {
+  try {
+    const response = await server.server.listRoots(void 0, { timeout: 1500 });
+    const roots = response.roots.map((root) => root.uri);
+    const resolvedRoots = roots.map((rootUri) => toFileRootPath(rootUri)).filter((rootPath) => Boolean(rootPath));
+    console.error("[primeui-mcp] roots/list supported:", JSON.stringify(roots));
+    console.error(
+      "[primeui-mcp] roots/list file roots:",
+      JSON.stringify(resolvedRoots)
+    );
+    return resolvedRoots;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("[primeui-mcp] roots/list unavailable:", message);
+    return [];
+  }
+}
 async function main() {
   console.error("CWD:", process.cwd());
   console.error("INIT_CWD:", process.env.INIT_CWD);
   console.error("PWD:", process.env.PWD);
-  const server = createPrimeUiMcpServer(new LazyProjectSyncSource());
+  let rootsFallbackCwds = [];
+  const server = createPrimeUiMcpServer(
+    new LazyProjectSyncSource(() => rootsFallbackCwds)
+  );
   const transport = new StdioServerTransport();
   await server.connect(transport);
+  rootsFallbackCwds = await loadClientRootFallbackCwds(server);
 }
 main().catch((error) => {
   console.error("[primeui-mcp] failed to start", error);