@primeuicom/mcp 0.1.20 → 0.1.21

package/dist/service.js

@@ -1,15 +1,31 @@
 #!/usr/bin/env node
 
 // src/service.ts
-import path8 from "path";
-import { fileURLToPath } from "url";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
+// src/runtime.ts
+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";
+var PrimeUiProjectConfigError = class extends Error {
+  code;
+  hint;
+  details;
+  constructor(options) {
+    super(options.message);
+    this.name = "PrimeUiProjectConfigError";
+    this.code = options.code;
+    this.hint = options.hint;
+    this.details = options.details ?? {};
+  }
+};
+function buildProjectRootHint() {
+  return "Pass an absolute projectRoot in tool input (for example: /path/to/project) or set PRIMEUI_PROJECT_ROOT.";
+}
 var primeUiProjectConfigSchema = z.object({
   projectId: z.string().trim().min(1),
   apiKey: z.string().trim().min(1),
@@ -54,24 +70,39 @@ async function readPrimeUiProjectConfig(projectConfigPath) {
   try {
     projectConfigRaw = await readFile(projectConfigPath, "utf-8");
   } catch (error) {
-    throw new Error(
-      `[primeui-mcp] failed to read ${PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH}: ${error instanceof Error ? error.message : String(error)}`
-    );
+    throw new PrimeUiProjectConfigError({
+      code: "PROJECT_CONFIG_READ_FAILED",
+      message: `[primeui-mcp] failed to read ${PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH}: ${error instanceof Error ? error.message : String(error)}`,
+      details: {
+        projectConfigPath
+      },
+      hint: buildProjectRootHint()
+    });
   }
   let projectConfigJson;
   try {
     projectConfigJson = JSON.parse(projectConfigRaw);
   } catch (error) {
-    throw new Error(
-      `[primeui-mcp] invalid JSON in ${PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH}: ${error instanceof Error ? error.message : String(error)}`
-    );
+    throw new PrimeUiProjectConfigError({
+      code: "PROJECT_CONFIG_INVALID_JSON",
+      message: `[primeui-mcp] invalid JSON in ${PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH}: ${error instanceof Error ? error.message : String(error)}`,
+      details: {
+        projectConfigPath
+      },
+      hint: buildProjectRootHint()
+    });
   }
   const parsedConfig = primeUiProjectConfigSchema.safeParse(projectConfigJson);
   if (!parsedConfig.success) {
     const details = parsedConfig.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
-    throw new Error(
-      `[primeui-mcp] invalid ${PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH} format: ${details}`
-    );
+    throw new PrimeUiProjectConfigError({
+      code: "PROJECT_CONFIG_INVALID_FORMAT",
+      message: `[primeui-mcp] invalid ${PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH} format: ${details}`,
+      details: {
+        projectConfigPath
+      },
+      hint: buildProjectRootHint()
+    });
   }
   return parsedConfig.data;
 }
@@ -90,35 +121,104 @@ function buildPrimeUiProjectSearchRoots(options) {
   return toUniqueResolvedDirs([...options.fallbackCwds ?? [], options.cwd]);
 }
 async function resolvePrimeUiProjectConfig(options) {
+  const toolProjectRoot = options.projectRootFromTool?.trim();
+  if (toolProjectRoot) {
+    const resolvedToolRoot = path.resolve(toolProjectRoot);
+    const toolProjectConfigPath = path.join(
+      resolvedToolRoot,
+      PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH
+    );
+    if (!await fileExists(toolProjectConfigPath)) {
+      throw new PrimeUiProjectConfigError({
+        code: "PROJECT_CONFIG_NOT_FOUND",
+        message: `[primeui-mcp] ${PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH} not found in provided projectRoot (${resolvedToolRoot}).`,
+        details: {
+          source: "tool",
+          projectRoot: resolvedToolRoot,
+          expectedConfigPath: toolProjectConfigPath,
+          cwd: options.cwd
+        },
+        hint: buildProjectRootHint()
+      });
+    }
+    const projectConfig2 = await readPrimeUiProjectConfig(toolProjectConfigPath);
+    return {
+      projectRoot: resolvedToolRoot,
+      projectConfigPath: toolProjectConfigPath,
+      projectConfig: projectConfig2
+    };
+  }
+  const stickyProjectRoot = options.projectRootFromSticky?.trim();
+  if (stickyProjectRoot) {
+    const resolvedStickyRoot = path.resolve(stickyProjectRoot);
+    const stickyProjectConfigPath = path.join(
+      resolvedStickyRoot,
+      PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH
+    );
+    if (await fileExists(stickyProjectConfigPath)) {
+      const projectConfig2 = await readPrimeUiProjectConfig(
+        stickyProjectConfigPath
+      );
+      return {
+        projectRoot: resolvedStickyRoot,
+        projectConfigPath: stickyProjectConfigPath,
+        projectConfig: projectConfig2
+      };
+    }
+  }
   const envProjectRoot = options.projectRootFromEnv?.trim();
-  let projectConfigPath;
   if (envProjectRoot) {
-    projectConfigPath = path.join(
-      path.resolve(envProjectRoot),
+    const resolvedEnvRoot = path.resolve(envProjectRoot);
+    const envProjectConfigPath = path.join(
+      resolvedEnvRoot,
       PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH
     );
-  } else {
-    const searchRoots = buildPrimeUiProjectSearchRoots({
-      cwd: options.cwd,
-      fallbackCwds: options.fallbackCwds
-    });
-    for (const searchRoot of searchRoots) {
-      const foundProjectConfigPath = await findPrimeUiProjectConfigPath(searchRoot);
-      if (foundProjectConfigPath) {
-        projectConfigPath = foundProjectConfigPath;
-        break;
-      }
+    if (!await fileExists(envProjectConfigPath)) {
+      throw new PrimeUiProjectConfigError({
+        code: "PROJECT_CONFIG_NOT_FOUND",
+        message: `[primeui-mcp] ${PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH} not found in PRIMEUI_PROJECT_ROOT (${resolvedEnvRoot}).`,
+        details: {
+          source: "env",
+          envVar: "PRIMEUI_PROJECT_ROOT",
+          projectRoot: resolvedEnvRoot,
+          expectedConfigPath: envProjectConfigPath,
+          cwd: options.cwd
+        },
+        hint: buildProjectRootHint()
+      });
     }
-    if (!projectConfigPath) {
-      throw new Error(
-        `[primeui-mcp] ${PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH} not found. Searched from: ${searchRoots.join(", ")}. Set PRIMEUI_PROJECT_ROOT.`
-      );
+    const projectConfig2 = await readPrimeUiProjectConfig(envProjectConfigPath);
+    return {
+      projectRoot: resolvedEnvRoot,
+      projectConfigPath: envProjectConfigPath,
+      projectConfig: projectConfig2
+    };
+  }
+  const searchRoots = buildPrimeUiProjectSearchRoots({
+    cwd: options.cwd,
+    fallbackCwds: options.fallbackCwds
+  });
+  let projectConfigPath;
+  for (const searchRoot of searchRoots) {
+    const foundProjectConfigPath = await findPrimeUiProjectConfigPath(searchRoot);
+    if (foundProjectConfigPath) {
+      projectConfigPath = foundProjectConfigPath;
+      break;
     }
   }
   if (!projectConfigPath) {
-    throw new Error(
-      `[primeui-mcp] ${PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH} not found. Set PRIMEUI_PROJECT_ROOT.`
-    );
+    throw new PrimeUiProjectConfigError({
+      code: "PROJECT_CONFIG_NOT_FOUND",
+      message: `[primeui-mcp] ${PRIMEUI_PROJECT_CONFIG_RELATIVE_PATH} not found. Searched from: ${searchRoots.join(
+        ", "
+      )}.`,
+      details: {
+        source: "search",
+        cwd: options.cwd,
+        searchedRoots: searchRoots
+      },
+      hint: buildProjectRootHint()
+    });
   }
   const projectRoot = path.dirname(path.dirname(projectConfigPath));
   const projectConfig = await readPrimeUiProjectConfig(projectConfigPath);
@@ -135,886 +235,52 @@ async function resolvePrimeUiApiKey(options) {
   }
   const projectConfigApiKey = options.projectConfig.apiKey.trim();
   if (!projectConfigApiKey) {
-    throw new Error(
-      "[primeui-mcp] PRIMEUI_API_KEY is missing in env and .primeui/project.json"
-    );
+    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;
 }
 
-// src/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-
-// src/instructions.ts
-import { z as z2 } from "zod/v3";
-var pageSchema = z2.object({
-  id: z2.string().describe(
-    "Stable PrimeUI page identifier. Use this to match the same page across tool responses."
-  ),
-  title: z2.string().describe(
-    "Human-readable page title. Show this to the user when confirming which pages to import."
-  ),
-  slug: z2.string().describe(
-    "PrimeUI route slug, for example '/', '/pricing', '/docs/getting-started'. Use to match user intent."
-  ),
-  pageType: z2.string().describe(
-    "PrimeUI page type classification (for example landing, docs, pricing, blogIndex, legal)."
-  ),
-  isReadyToExport: z2.boolean().describe(
-    "True when this page has an active export-ready variant. Only ready pages are expected in export output."
-  ),
-  pagePath: z2.string().describe(
-    "Relative file path to the page source inside downloaded export root. Copy page code from this exact path."
-  ),
-  componentsPath: z2.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 exportStatusSchema = z2.enum(["in_progress", "completed", "failed"]).describe(
-  "Export lifecycle state. Use 'completed' before calling download_export."
-);
-var exportItemSchema = z2.object({
-  id: z2.string().describe(
-    "Export identifier. Pass this value to download_export input.id."
-  ),
-  status: exportStatusSchema,
-  createdAt: z2.string().describe("Export creation timestamp in ISO-8601 UTC format.")
-}).describe("Single export record from PrimeUI export history.");
-var exportSummarySchema = z2.object({
-  total: z2.number().describe("Total pages processed in this export run."),
-  successful: z2.number().describe("Number of pages exported successfully."),
-  failed: z2.number().describe("Number of pages that failed export.")
-});
-var exportComponentSchema = z2.object({
-  componentKey: z2.string().describe("Global component key from export manifest."),
-  enabled: z2.boolean().describe("True when this global component was exported."),
-  files: z2.array(z2.string()).describe("Files associated with this global component."),
-  message: z2.string().describe("Export status message for this global component.")
-});
-var exportPageManifestSchema = z2.object({
-  success: z2.boolean().describe("True when page export succeeded in this export run."),
-  message: z2.string().describe("Export status message for this page."),
-  files: z2.array(z2.string()).describe(
-    "Authoritative list of page-related files from PrimeUI export manifest, including shared project files required by this page."
-  )
-});
-var exportPageSchema = z2.object({
-  id: z2.string().describe("Stable PrimeUI page identifier for this export entry."),
-  title: z2.string().optional().describe(
-    "Optional page title from export manifest. Can be undefined for some legacy records."
-  ),
-  slug: z2.string().describe("PrimeUI page slug included in this export."),
-  pageType: z2.string().describe("PrimeUI page type for routing/path resolution."),
-  isReadyToExport: z2.literal(true).describe("Always true for pages included in export payload."),
-  pagePath: z2.string().describe("Page source file path relative to export root."),
-  componentsPath: z2.string().describe("Page components directory path relative to export root."),
-  manifest: exportPageManifestSchema
-});
-var fileTransferSchema = z2.object({
-  sourcePath: z2.string().describe("Relative source file path inside downloaded export root."),
-  targetPath: z2.string().describe("Relative target file path inside user project root.")
-});
-var conflictFileSchema = fileTransferSchema.extend({
-  diff: z2.string().describe(
-    "Unified diff between user file and export file. For binary files the diff contains a plain message."
-  ),
-  isBinary: z2.boolean().describe("True if conflict comparison was treated as binary data.")
-});
-var dependencySectionSchema = z2.enum([
-  "dependencies",
-  "devDependencies",
-  "peerDependencies"
-]);
-var dependencyToAddSchema = z2.object({
-  packageName: z2.string().describe("Dependency package name that was missing in user package.json."),
-  version: z2.string().describe("Version from exported project's package.json."),
-  section: dependencySectionSchema.describe(
-    "package.json section where dependency should be added."
-  )
-});
-var dependencyVersionConflictSchema = z2.object({
-  packageName: z2.string().describe("Dependency package name with version mismatch."),
-  section: dependencySectionSchema.describe(
-    "Section where export expects this dependency."
-  ),
-  exportVersion: z2.string().describe("Version found in exported project's package.json."),
-  userVersion: z2.string().describe("Version currently present in user's package.json.")
-});
-var pageDetailsSchema = pageSchema.extend({
-  pageInstruction: z2.string().nullable().describe(
-    "Current instruction text for the active page variant. Null when no active variant is set."
-  )
-});
-var pageVariantSchema = z2.object({
-  id: z2.string().describe("Active variant identifier."),
-  name: z2.string().describe("Active variant display name.")
-}).nullable().describe(
-  "Active page variant. Null when page has no active variant and components are unavailable."
-);
-var pageComponentSchema = z2.object({
-  blockId: z2.string().describe("Stable block identifier. Use as primary component instance ID."),
-  componentId: z2.string().describe("Component key from variant blocks payload (block.key)."),
-  componentGroup: z2.string().describe("Component family/group normalized from component key."),
-  slot: z2.string().nullable().describe("Optional slot value from block payload."),
-  props: z2.record(z2.unknown()).nullable().describe("Raw block props payload from PrimeUI.")
-});
-var inspectPageReportRowSchema = z2.object({
-  number: z2.number().describe("1-based row number matching report order."),
-  componentGroup: z2.string().describe("Component family/group label."),
-  componentId: z2.string().describe("Component key (block key)."),
-  blockId: z2.string().describe("Primary component instance identifier for future operations."),
-  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."),
-  codexWorkspaceRoot: z2.string().nullable().describe(
-    "CODEX_WORKSPACE_ROOT provided by Codex clients (tool-call scoped in some clients)."
-  ),
-  vscodeCwd: z2.string().nullable().describe("VSCODE_CWD environment value, if provided by the runtime."),
-  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",
-  "sync pages",
-  "pull page",
-  "transfer page",
-  "get page from PrimeUI",
-  "bring page from PrimeUI",
-  "export from PrimeUI"
-].join(", ");
-var WORKFLOW_SUMMARY = `
-WORKFLOW ORDER (always follow this sequence):
-1. clear_temp -> cleanup stale temp files from previous runs before starting new import flow
-2. get_project_info -> discover PrimeUI pages
-3. Reconcile PrimeUI pages with local project pages/routes/paths, then confirm target pages with user
-4. inspect_page -> inspect selected page components and produce a structured comparison table
-5. create_export -> generate export snapshot and local manifest with page file lists + global components
-6. download_export -> download to temp directory
-7. copy_page -> copy one page safely (repeat for each selected page)
-8. Reconcile integration points and resolve reported conflicts, if any
-`.trim();
-var initialInstructions = `
-PrimeUI MCP enables importing pages from PrimeUI Studio into your local project.
-
-TRIGGER EXAMPLES (semantic intent, not exact phrase matching): ${TRIGGER_PHRASES}
-
-${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.
-- Decision matrix:
-  - PrimeUI + local page exists -> candidate for update/review.
-  - PrimeUI exists, local missing -> import candidate.
-  - Local exists, PrimeUI missing -> custom local page, no action unless user asks.
-  - Both exist but path mismatch -> ambiguous, export + compare before deciding.
-- For targeted component-level analysis on a specific page, call inspect_page before export/copy.
-- After inspect_page returns report table, supplement that table with local project page state:
-  mark what already exists, what is missing, and what differs.
-- Before creating export, ask user which pages to add/update (specific pages or all missing pages) and keep that choice in thread context.
-- create_export response includes:
-  - page-level manifest files per page ('pages[].manifest.files'),
-  - global components list ('export.components').
-  Mention both to user after create_export, because this is the source of truth for copy decisions.
-- The downloaded export in .primeui/temp/ contains a full standalone Next.js project.
-  Do NOT copy it wholesale.
-- Always call copy_page for each confirmed page instead of manual file copy.
-- copy_page performs safe copy only:
-  - new files are copied,
-  - identical files are reported,
-  - conflicting files are NEVER overwritten and are returned with diff.
-- copy_page reads and validates files only from 'pages[].manifest.files' in local sidecar manifest.
-- copy_page may add only missing dependencies to user's package.json.
-  It never upgrades existing dependency versions and never runs dependency installation.
-- After page copy operations, inspect integration points (navigation configs, link menus, route registries, page indexes).
-- 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).
+// src/services/project-sync-service.ts
+import path5 from "path";
+import { readFile as readFile4 } from "fs/promises";
 
-RETURNS:
-- Runtime paths (cwd, CODEX_WORKSPACE_ROOT, VSCODE_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
+// src/lib/fs.ts
+import { mkdir, rm, writeFile } from "fs/promises";
+import path2 from "path";
+import extractZipArchive from "extract-zip";
+async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+async function resetDir(dirPath) {
+  await rm(dirPath, { recursive: true, force: true });
+  await mkdir(dirPath, { recursive: true });
+}
+async function writeUtf8(filePath, content) {
+  await ensureDir(path2.dirname(filePath));
+  await writeFile(filePath, content, "utf-8");
+}
+async function extractZip(zipPath, targetDir) {
+  await ensureDir(targetDir);
+  try {
+    await extractZipArchive(zipPath, { dir: targetDir });
+  } catch (error) {
+    const details = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to extract zip at "${zipPath}". ${details}`);
   }
-};
-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.
-
-WHEN TO USE: Call this FIRST when user wants to import, add, sync, pull, or transfer a page from PrimeUI. Intent examples (semantic intent, not exact phrase matching): ${TRIGGER_PHRASES}.
+}
 
-AFTER CALLING:
-- Scan the user's local project to discover existing pages/routes and related page component folders.
-- Build a reconciliation report between PrimeUI and local project with action labels:
-  - Page exists in both PrimeUI and local project.
-  - Page exists in PrimeUI but not in local project -> import candidate.
-  - Page exists in local project but not in PrimeUI -> custom local page, no action by default.
-  - Page exists in both but slug/pagePath/componentsPath mapping does not match -> ambiguous, requires export-based comparison before decision.
-- If user already requested specific pages, first verify those pages exist in PrimeUI and are isReadyToExport: true.
-- If any requested page is not found or not ready, report this immediately and ask for replacement page choices.
-- Ask the user which pages to add or update now (specific page list or all missing pages) and keep this decision in thread context.
-- Import works per page. Multiple pages are allowed, but each page transfer is handled explicitly.
-- Only after user decision is clear, proceed to create_export.
-
-${WORKFLOW_SUMMARY}`,
-  inputSchema: {},
-  outputSchema: {
-    projectId: z2.string().describe(
-      "PrimeUI project identifier associated with the API key and current import session context."
-    ),
-    projectName: z2.string().describe(
-      "Human-readable PrimeUI project name for confirmations in chat."
-    ),
-    metadata: z2.record(z2.unknown()).describe(
-      "Additional project metadata from PrimeUI. May include project-description and other context fields."
-    ),
-    pages: z2.array(pageSchema).describe(
-      "All pages visible for this project context. Filter by user request and isReadyToExport before creating export."
-    )
-  },
-  annotations: {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: true
-  }
-};
-var toolInspectPage = {
-  title: "PrimeUI Inspect Page",
-  description: `Targeted inspection tool for one PrimeUI page. Returns page details, active variant (if present), raw components payload, and a formatted report table.
-
-WHEN TO USE:
-- Call this after get_project_info when user wants component-level analysis for a specific page.
-- Use this before export/copy when user asks to compare or selectively update page sections.
-
-AFTER CALLING:
-- Use report + reportRows to present the component table:
-  Number (1-based), ComponentGroup (ComponentId), Title/Description, blockId.
-- Then supplement this table with the CURRENT local project page state:
-  what already exists, what is missing, and what differs.
-- Do not assume componentId is unique. Use blockId as the primary component instance identifier.
-
-If page has no active variant, components is null (not empty array), and report explains why.
-
-${WORKFLOW_SUMMARY}`,
-  inputSchema: {
-    pageSlug: z2.string().describe(
-      "PrimeUI page slug to inspect, for example '/', '/pricing', '/docs/getting-started'."
-    )
-  },
-  outputSchema: {
-    page: pageDetailsSchema.describe(
-      "Single PrimeUI page details resolved by slug with pageInstruction."
-    ),
-    variant: pageVariantSchema,
-    components: z2.array(pageComponentSchema).nullable().describe(
-      "Raw component instances from active variant. Null when page has no active variant."
-    ),
-    report: z2.string().describe(
-      "Formatted report table generated by MCP from component payload (includes extracted title/description summary)."
-    ),
-    reportRows: z2.array(inspectPageReportRowSchema).describe(
-      "Structured report rows with 1-based numbering and extracted title/description fields."
-    )
-  },
-  annotations: {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: true
-  }
-};
-var toolListExports = {
-  title: "PrimeUI Export List",
-  description: `Auxiliary tool to list previously created exports with their IDs, statuses, and creation dates. This is NOT the starting point for page import - start with get_project_info instead.
-
-WHEN TO USE: This is an OPTIONAL helper tool, NOT part of the main import flow. Use it only when:
-- Something went wrong with an export and you need to check its status.
-- The user explicitly references a previous export by date or context.
-- You need to verify whether an export initiated via PrimeUI Studio UI has completed.
-
-Note: exports can be created both through create_export AND by the user directly in PrimeUI Studio UI. This tool shows all of them.
-
-Do NOT use this tool as a substitute for create_export. Always create a fresh export unless the user explicitly asks to use a previous one.
-
-${WORKFLOW_SUMMARY}`,
-  inputSchema: {},
-  outputSchema: {
-    exports: z2.array(exportItemSchema).describe(
-      "Available exports sorted by API policy. Use item.id to download a specific prior export if user asks."
-    )
-  },
-  annotations: {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: true
-  }
-};
-var toolCreateExport = {
-  title: "PrimeUI Create Export",
-  description: `Create a new export snapshot from the current PrimeUI project state and wait for completion. Returns strict export manifest payload from API, including page-level file manifests and global components.
-
-WHEN TO USE: Call this AFTER the user has confirmed which pages they want to import via get_project_info. This tool is REQUIRED before download_export, unless the user explicitly and directly asked to download a specific previous export.
-
-AFTER CALLING:
-- Verify that all user-selected pages are present in the export result AND have isReadyToExport: true.
-- If path mismatch pages were flagged during project-info reconciliation, ensure they are included for deeper comparison after download.
-- If any required page is missing or not ready, report and pause for user decision before proceeding.
-- Mention that global components are available in export.components and can be transferred separately if needed.
-- Local sidecar manifest is saved to .primeui/temp/exports/[exportId].manifest.json from this API payload.
-- Use the returned export ID to call download_export.
-
-${WORKFLOW_SUMMARY}`,
-  inputSchema: {},
-  outputSchema: {
-    export: z2.object({
-      id: z2.string().describe(
-        "Freshly created export identifier. Use this as download_export input.id."
-      ),
-      status: exportStatusSchema,
-      createdAt: z2.string().describe("Export creation timestamp in ISO-8601 UTC format."),
-      expiresAt: z2.string().nullable().describe(
-        "Export expiration timestamp in ISO-8601 UTC format, or null when export has no explicit expiration."
-      ),
-      summary: exportSummarySchema.describe(
-        "Export run summary with total/successful/failed counters."
-      ),
-      components: z2.array(exportComponentSchema).describe(
-        "Global component export manifest. These components are independent from page-level manifests."
-      )
-    }).describe("Created export summary."),
-    pages: z2.array(exportPageSchema).describe(
-      "Strict page payload associated with this export, including per-page manifest files list."
-    )
-  },
-  annotations: {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: false,
-    openWorldHint: true
-  }
-};
-var toolDownloadExport = {
-  title: "PrimeUI Download Export",
-  description: `Download a completed export into .primeui/temp/exports/[exportId]. Downloads and extracts the full export as a standalone Next.js project into the temp directory. This does NOT modify the user's project - files land only in .primeui/temp/.
-
-Do NOT call this as the first step. Requires export ID from create_export. Start with get_project_info instead.
-
-WHEN TO USE: Call this AFTER create_export has returned a completed export. Requires export ID from create_export so MCP can use the matching local sidecar manifest.
-
-NOTE:
-- Download of an export ID without local sidecar manifest will fail.
-- For previous exports, create a fresh export first when possible.
-
-AFTER DOWNLOAD:
-- Use manifestPath from this response as the contract for page slug/path mapping and manifest file lists in copy operations.
-- For each selected page, call copy_page with:
-  - originPageSlug (required),
-  - actualPageSlug (optional, if route remap is needed).
-- If there are unresolved conflicts in copy report, stop and ask the user.
-- Do not force cleanup at flow end; keep downloaded export files available for validation and follow-up checks.
-
-  ${WORKFLOW_SUMMARY}`,
-  inputSchema: {
-    id: z2.string().describe(
-      "Export identifier to download. Prefer export.id from create_export; use list_exports only on explicit user request."
-    )
-  },
-  outputSchema: {
-    exportId: z2.string().describe(
-      "Downloaded export identifier. Should match the requested input.id for traceability."
-    ),
-    projectPath: z2.string().describe(
-      "Absolute local path to extracted export root in .primeui/temp/exports/[exportId]. Read files from here only."
-    ),
-    manifestPath: z2.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: z2.array(exportPageSchema).describe(
-      "Page descriptors loaded from local sidecar export manifest for import decisions."
-    )
-  },
-  annotations: {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: true
-  }
-};
-var toolCopyPage = {
-  title: "PrimeUI Copy Page",
-  description: `Safely copy one page from downloaded export into the user's local project. Works only with local files in .primeui/temp/exports and does NOT call PrimeUI API.
-
-WHEN TO USE:
-- Call this AFTER download_export.
-- Call once per selected page.
-- Use actualPageSlug only when user wants to remap route during import.
-
-BEHAVIOR:
-- Reads export sidecar manifest to resolve originPageSlug -> pagePath/componentsPath.
-- Copies and validates files strictly from pages[].manifest.files for the selected page.
-- Never overwrites existing conflicting files.
-- Reports:
-  a) copied new files,
-  b) identical existing files,
-  c) conflicting files with diff,
-  d) missing dependencies added to package.json,
-  e) dependency version conflicts (report-only, no auto upgrade).
-- Adds only missing dependencies to package.json (dependencies/devDependencies/peerDependencies).
-- Never updates existing dependency versions and never runs install commands.
-
-${WORKFLOW_SUMMARY}`,
-  inputSchema: {
-    originPageSlug: z2.string().describe(
-      "Source page slug from PrimeUI project pages list, for example '/', '/pricing', '/docs'."
-    ),
-    actualPageSlug: z2.string().optional().describe(
-      "Optional destination slug in user's project. If omitted, originPageSlug is used."
-    )
-  },
-  outputSchema: {
-    exportId: z2.string().describe("Resolved local export identifier used for copy operation."),
-    exportPath: z2.string().describe("Absolute path to local extracted export project root."),
-    originPageSlug: z2.string().describe("Normalized source page slug requested for copy."),
-    actualPageSlug: z2.string().describe("Normalized destination slug used for target route paths."),
-    sourcePagePath: z2.string().describe("Source page path relative to export root."),
-    targetPagePath: z2.string().describe("Destination page path relative to user project root."),
-    sourceComponentsPath: z2.string().describe("Source components directory relative to export root."),
-    targetComponentsPath: z2.string().describe(
-      "Destination components directory relative to user project root."
-    ),
-    newFiles: z2.array(fileTransferSchema).describe("New files copied into user project without conflicts."),
-    identicalFiles: z2.array(fileTransferSchema).describe(
-      "Existing files in user project that are byte-identical to export files."
-    ),
-    conflictFiles: z2.array(conflictFileSchema).describe(
-      "Files that already exist and differ from export version. Never overwritten."
-    ),
-    addedDependencies: z2.array(dependencyToAddSchema).describe(
-      "Dependencies that were missing and have been added to user's package.json."
-    ),
-    dependenciesVersionConflicts: z2.array(dependencyVersionConflictSchema).describe(
-      "Dependencies with version mismatch between export and user project. Report only."
-    ),
-    summary: z2.object({
-      totalCandidateFiles: z2.number().describe(
-        "Total number of candidate files considered for page copy from pages[].manifest.files."
-      ),
-      copiedFiles: z2.number().describe("Number of files copied as new."),
-      identicalFiles: z2.number().describe("Number of files detected as identical."),
-      conflictFiles: z2.number().describe("Number of conflicting files not copied."),
-      addedDependencies: z2.number().describe("Count of dependencies added to package.json."),
-      dependenciesVersionConflicts: z2.number().describe("Count of dependency version mismatches reported.")
-    })
-  },
-  annotations: {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: false,
-    openWorldHint: false
-  }
-};
-var toolClearTemp = {
-  title: "PrimeUI Clear Temp",
-  description: `Delete all files in .primeui/temp/ and recreate empty temp structure.
-
-Call this at the START of a new import flow, before get_project_info/create_export, to reset stale temp state from previous runs.
-
-WHEN TO USE: Call once at the beginning of each new import flow. Do not call this between page imports in the same flow.
-
-Safe to call multiple times. Only affects .primeui/temp/ directory - never touches the user's project files.
-
-${WORKFLOW_SUMMARY}`,
-  inputSchema: {},
-  outputSchema: {
-    success: z2.boolean().describe(
-      "True when temp cleanup completed and baseline temp structure was recreated."
-    )
-  },
-  annotations: {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: false
-  }
-};
-
-// src/server.ts
-function okResult(title, data) {
-  return {
-    content: [{ type: "text", text: `${title} completed` }],
-    structuredContent: data
-  };
-}
-function errorResult(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return {
-    isError: true,
-    content: [{ type: "text", text: `primeui mcp error: ${message}` }]
-  };
-}
-function createPrimeUiMcpServer(source) {
-  const server = new McpServer(
-    {
-      name: "primeui-mcp-server",
-      version: "0.1.0"
-    },
-    {
-      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(),
-            codexWorkspaceRoot: process.env.CODEX_WORKSPACE_ROOT?.trim() || null,
-            vscodeCwd: process.env.VSCODE_CWD?.trim() || null,
-            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,
-    async () => {
-      try {
-        const info = await source.getProjectInfo();
-        return okResult("get_project_info", info);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "inspect_page",
-    toolInspectPage,
-    async ({ pageSlug }) => {
-      try {
-        const result = await source.inspectPage(pageSlug);
-        return okResult("inspect_page", result);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "list_exports",
-    toolListExports,
-    async () => {
-      try {
-        const exportsList = await source.listExports();
-        return okResult("list_exports", { exports: exportsList });
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "create_export",
-    toolCreateExport,
-    async () => {
-      try {
-        const result = await source.createExport();
-        return okResult("create_export", result);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "download_export",
-    toolDownloadExport,
-    async ({ id }) => {
-      try {
-        const result = await source.downloadExportById(id);
-        return okResult("download_export", result);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "clear_temp",
-    toolClearTemp,
-    async () => {
-      try {
-        await source.clearTemp();
-        return okResult("clear_temp", { success: true });
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  server.registerTool(
-    "copy_page",
-    toolCopyPage,
-    async ({ originPageSlug, actualPageSlug }) => {
-      try {
-        const result = await source.copyPage(
-          originPageSlug,
-          actualPageSlug
-        );
-        return okResult("copy_page", result);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-  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: "CODEX_WORKSPACE_ROOT",
-      description: "Preferred workspace root from Codex clients. May appear only during tool calls.",
-      currentValue: input.codexWorkspaceRoot
-    },
-    {
-      key: "VSCODE_CWD",
-      description: "Workspace cwd hint set by some VS Code runtimes. Used as project search fallback.",
-      currentValue: input.vscodeCwd
-    },
-    {
-      key: "INIT_CWD",
-      description: "Install/runtime cwd hint. Used as fallback when workspace-specific env is unavailable.",
-      currentValue: input.initCwd
-    },
-    {
-      key: "PWD",
-      description: "Shell working directory hint. Used as fallback when workspace-specific env is unavailable.",
-      currentValue: input.pwd
-    },
-    {
-      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 prioritizes CODEX_WORKSPACE_ROOT/VSCODE_CWD, then roots/list file roots, INIT_CWD, PWD, and finally process.cwd().",
-      currentValue: null
-    }
-  ];
-}
-async function runPrimeUiHealthCheck(input) {
-  const projectRootFromEnv = normalizeOptional(input.projectRootFromEnv);
-  const apiBaseUrlFromEnv = normalizeOptional(input.apiBaseUrlFromEnv);
-  const apiKeyFromEnv = normalizeOptional(input.apiKeyFromEnv);
-  const codexWorkspaceRoot = normalizeOptional(input.codexWorkspaceRoot);
-  const vscodeCwd = normalizeOptional(input.vscodeCwd);
-  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),
-        codexWorkspaceRoot,
-        vscodeCwd,
-        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,
-        codexWorkspaceRoot,
-        vscodeCwd,
-        initCwd,
-        pwd
-      })
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      status: "degraded",
-      runtime: {
-        cwd: path2.resolve(input.cwd),
-        codexWorkspaceRoot,
-        vscodeCwd,
-        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,
-        codexWorkspaceRoot,
-        vscodeCwd,
-        initCwd,
-        pwd
-      })
-    };
-  }
-}
-
-// src/services/project-sync-service.ts
-import path6 from "path";
-import { readFile as readFile4 } from "fs/promises";
-
-// src/lib/fs.ts
-import { mkdir, rm, writeFile } from "fs/promises";
-import path3 from "path";
-import extractZipArchive from "extract-zip";
-async function ensureDir(dirPath) {
-  await mkdir(dirPath, { recursive: true });
-}
-async function resetDir(dirPath) {
-  await rm(dirPath, { recursive: true, force: true });
-  await mkdir(dirPath, { recursive: true });
-}
-async function writeUtf8(filePath, content) {
-  await ensureDir(path3.dirname(filePath));
-  await writeFile(filePath, content, "utf-8");
-}
-async function extractZip(zipPath, targetDir) {
-  await ensureDir(targetDir);
-  try {
-    await extractZipArchive(zipPath, { dir: targetDir });
-  } catch (error) {
-    const details = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to extract zip at "${zipPath}". ${details}`);
-  }
-}
-
-// src/services/page-copy-service.ts
-import { readFile as readFile3, readdir, stat as stat3, writeFile as writeFile2 } from "fs/promises";
-import path5 from "path";
+// src/services/page-copy-service.ts
+import { readFile as readFile3, readdir, stat as stat3, writeFile as writeFile2 } from "fs/promises";
+import path4 from "path";
 
 // src/lib/import-graph.ts
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
 import { builtinModules } from "module";
-import path4 from "path";
+import path3 from "path";
 var INTERNAL_EXTENSIONS = [
   ".ts",
   ".tsx",
@@ -1090,7 +356,7 @@ async function pathExists(filePath) {
   }
 }
 async function resolveFileCandidate(candidateBase) {
-  const ext = path4.extname(candidateBase);
+  const ext = path3.extname(candidateBase);
   if (ext) {
     if (await pathExists(candidateBase)) {
       return candidateBase;
@@ -1110,7 +376,7 @@ async function resolveFileCandidate(candidateBase) {
     }
     if (stats.isDirectory()) {
       for (const extension of INTERNAL_EXTENSIONS) {
-        const indexCandidate = path4.join(candidateBase, `index${extension}`);
+        const indexCandidate = path3.join(candidateBase, `index${extension}`);
         if (await pathExists(indexCandidate)) {
           return indexCandidate;
         }
@@ -1132,13 +398,13 @@ async function resolveImportToFile(projectRoot, importerFilePath, specifier) {
   }
   let candidateBase = null;
   if (specifier.startsWith("@/")) {
-    candidateBase = path4.join(projectRoot, "src", specifier.slice(2));
+    candidateBase = path3.join(projectRoot, "src", specifier.slice(2));
   } else if (specifier.startsWith("@root/")) {
-    candidateBase = path4.join(projectRoot, specifier.slice(6));
+    candidateBase = path3.join(projectRoot, specifier.slice(6));
   } else if (specifier.startsWith(".")) {
-    candidateBase = path4.resolve(path4.dirname(importerFilePath), specifier);
+    candidateBase = path3.resolve(path3.dirname(importerFilePath), specifier);
   } else if (specifier.startsWith("/")) {
-    candidateBase = path4.join(projectRoot, specifier.slice(1));
+    candidateBase = path3.join(projectRoot, specifier.slice(1));
   } else {
     return { kind: "unknown" };
   }
@@ -1152,12 +418,12 @@ async function resolveImportToFile(projectRoot, importerFilePath, specifier) {
   };
 }
 function shouldParseFile(filePath) {
-  return PARSEABLE_EXTENSIONS.has(path4.extname(filePath).toLowerCase());
+  return PARSEABLE_EXTENSIONS.has(path3.extname(filePath).toLowerCase());
 }
 async function buildImportGraph(input) {
   const shouldFollowInternalImports = input.followInternalImports ?? true;
-  const projectRoot = path4.resolve(input.projectRoot);
-  const queue = input.entryFiles.map((filePath) => path4.resolve(filePath));
+  const projectRoot = path3.resolve(input.projectRoot);
+  const queue = input.entryFiles.map((filePath) => path3.resolve(filePath));
   const visited = /* @__PURE__ */ new Set();
   const internalFiles = /* @__PURE__ */ new Set();
   const externalPackages = /* @__PURE__ */ new Set();
@@ -1410,10 +676,10 @@ function normalizeSlug2(slug) {
   return withLeadingSlash.replace(/\/+$/, "") || "/";
 }
 function toPosixPath(value) {
-  return value.split(path5.sep).join("/");
+  return value.split(path4.sep).join("/");
 }
 function toProjectRelative(rootPath, absolutePath) {
-  return toPosixPath(path5.relative(rootPath, absolutePath));
+  return toPosixPath(path4.relative(rootPath, absolutePath));
 }
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -1470,7 +736,7 @@ function buildPlannedSourceBuffer(sourceBuffer, sourceFilePath, importRewritePla
   if (!importRewritePlan) {
     return sourceBuffer;
   }
-  const extension = path5.extname(sourceFilePath).toLowerCase();
+  const extension = path4.extname(sourceFilePath).toLowerCase();
   if (!REWRITABLE_IMPORT_EXTENSIONS.has(extension)) {
     return sourceBuffer;
   }
@@ -1572,9 +838,9 @@ async function resolveManifestCandidateFiles(input) {
       );
     }
     const normalizedRelative = toPosixPath(trimmed).replace(/^\.\/+/, "");
-    const absolutePath = path5.resolve(input.exportPath, normalizedRelative);
-    const relative = path5.relative(input.exportPath, absolutePath);
-    if (relative.startsWith("..") || path5.isAbsolute(relative)) {
+    const absolutePath = path4.resolve(input.exportPath, normalizedRelative);
+    const relative = path4.relative(input.exportPath, absolutePath);
+    if (relative.startsWith("..") || path4.isAbsolute(relative)) {
       throw new Error(
         `Export manifest for page "${input.pageSlug}" contains path outside export root: ${trimmed}`
       );
@@ -1605,12 +871,12 @@ async function resolveSingleExportDirectory(exportsRoot) {
   const exportId = exportDirectories[0] ?? "";
   return {
     exportId,
-    exportPath: path5.join(exportsRoot, exportId)
+    exportPath: path4.join(exportsRoot, exportId)
   };
 }
 function ensureSafeTargetPath(projectRoot, targetPath) {
-  const relative = path5.relative(projectRoot, targetPath);
-  if (relative.startsWith("..") || path5.isAbsolute(relative)) {
+  const relative = path4.relative(projectRoot, targetPath);
+  if (relative.startsWith("..") || path4.isAbsolute(relative)) {
     throw new Error(
       `Refusing to write outside project root. Computed target: ${targetPath}`
     );
@@ -1668,19 +934,19 @@ function resolveTargetFilePath(input) {
   if (sourceFilePath === sourcePagePath) {
     return targetPagePath;
   }
-  const componentsPrefix = `${sourceComponentsPath}${path5.sep}`;
+  const componentsPrefix = `${sourceComponentsPath}${path4.sep}`;
   if (sourceFilePath === sourceComponentsPath || sourceFilePath.startsWith(componentsPrefix)) {
-    const relativeToComponents = path5.relative(
+    const relativeToComponents = path4.relative(
       sourceComponentsPath,
       sourceFilePath
     );
-    return path5.join(targetComponentsPath, relativeToComponents);
+    return path4.join(targetComponentsPath, relativeToComponents);
   }
-  const relativeToExport = path5.relative(exportRoot, sourceFilePath);
-  if (relativeToExport.startsWith("..") || path5.isAbsolute(relativeToExport)) {
+  const relativeToExport = path4.relative(exportRoot, sourceFilePath);
+  if (relativeToExport.startsWith("..") || path4.isAbsolute(relativeToExport)) {
     throw new Error(`Source file is outside export root: ${sourceFilePath}`);
   }
-  return path5.join(projectRoot, relativeToExport);
+  return path4.join(projectRoot, relativeToExport);
 }
 async function copyPageFromExport(input) {
   const normalizedOriginSlug = normalizeSlug2(input.originPageSlug);
@@ -1691,7 +957,7 @@ async function copyPageFromExport(input) {
   const { exportId, exportPath } = await resolveSingleExportDirectory(
     input.exportsRoot
   );
-  const manifestPath = path5.join(
+  const manifestPath = path4.join(
     input.exportsRoot,
     `${exportId}.manifest.json`
   );
@@ -1714,8 +980,8 @@ async function copyPageFromExport(input) {
       `Page not found in manifest for slug: ${normalizedOriginSlug}`
     );
   }
-  const sourcePagePath = path5.join(exportPath, page.pagePath);
-  const sourceComponentsPath = path5.join(exportPath, page.componentsPath);
+  const sourcePagePath = path4.join(exportPath, page.pagePath);
+  const sourceComponentsPath = path4.join(exportPath, page.componentsPath);
   const sourcePageStats = await stat3(sourcePagePath).catch(() => null);
   if (!sourcePageStats?.isFile()) {
     throw new Error(`Source page file not found: ${sourcePagePath}`);
@@ -1735,8 +1001,8 @@ async function copyPageFromExport(input) {
     pageType: page.pageType,
     slug: normalizedActualSlug
   });
-  const targetPagePath = path5.join(input.projectRoot, targetPaths.pagePath);
-  const targetComponentsPath = path5.join(
+  const targetPagePath = path4.join(input.projectRoot, targetPaths.pagePath);
+  const targetComponentsPath = path4.join(
     input.projectRoot,
     targetPaths.componentsPath
   );
@@ -1782,7 +1048,7 @@ async function copyPageFromExport(input) {
     const sourceRelative = toProjectRelative(exportPath, sourceFilePath);
     const targetRelative = toProjectRelative(input.projectRoot, targetFilePath);
     if (!targetBuffer) {
-      await ensureDir(path5.dirname(targetFilePath));
+      await ensureDir(path4.dirname(targetFilePath));
       await writeFile2(targetFilePath, plannedSourceBuffer);
       newFiles.push({
         sourcePath: sourceRelative,
@@ -1811,8 +1077,8 @@ async function copyPageFromExport(input) {
       isBinary
     });
   }
-  const exportPackageJsonPath = path5.join(exportPath, "package.json");
-  const userPackageJsonPath = path5.join(input.projectRoot, "package.json");
+  const exportPackageJsonPath = path4.join(exportPath, "package.json");
+  const userPackageJsonPath = path4.join(input.projectRoot, "package.json");
   if (!await fileExists2(exportPackageJsonPath)) {
     throw new Error(`Export package.json not found: ${exportPackageJsonPath}`);
   }
@@ -2018,7 +1284,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 path6.join(exportsRoot, `${exportId}.manifest.json`);
+  return path5.join(exportsRoot, `${exportId}.manifest.json`);
 }
 function parseExportManifest(value) {
   if (!value || typeof value !== "object") {
@@ -2036,645 +1302,1195 @@ function parseExportManifest(value) {
   if (typeof exportObject.id !== "string" || !isExportStatus2(status) || typeof exportObject.createdAt !== "string" || !("expiresAt" in exportObject) || !(typeof exportObject.expiresAt === "string" || exportObject.expiresAt === null) || !isExportSummary(summary) || !Array.isArray(components) || !components.every(isExportedComponent) || !Array.isArray(maybe.pages)) {
     throw new Error("Export manifest does not match expected schema.");
   }
-  if (!maybe.pages.every(isExportPage)) {
-    throw new Error("Export manifest pages payload is invalid.");
+  if (!maybe.pages.every(isExportPage)) {
+    throw new Error("Export manifest pages payload is invalid.");
+  }
+  return {
+    export: {
+      id: exportObject.id,
+      status,
+      createdAt: exportObject.createdAt,
+      expiresAt: exportObject.expiresAt,
+      summary,
+      components
+    },
+    pages: maybe.pages
+  };
+}
+var ProjectSyncService = class {
+  provider;
+  projectRoot;
+  targetProjectRoot;
+  primeUiRoot;
+  tempRoot;
+  exportsRoot;
+  constructor(options) {
+    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");
+  }
+  async getProjectInfo(_context) {
+    await this.ensureTempLayout();
+    return this.provider.getProjectInfo();
+  }
+  async listExports(_context) {
+    await this.ensureTempLayout();
+    return this.provider.listExports();
+  }
+  async createExport(_context) {
+    await this.ensureTempLayout();
+    const result = await this.provider.createExport();
+    const manifestPath = buildManifestPath(this.exportsRoot, result.export.id);
+    await writeUtf8(manifestPath, `${JSON.stringify(result, null, 2)}
+`);
+    return result;
+  }
+  async downloadExportById(id, _context) {
+    await this.ensureTempLayout();
+    const exportsList = await this.provider.listExports();
+    const selected = exportsList.find((item) => item.id === id);
+    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 manifestPath = buildManifestPath(this.exportsRoot, id);
+    let manifest;
+    try {
+      manifest = parseExportManifest(
+        JSON.parse(await readFile4(manifestPath, "utf-8"))
+      );
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Export manifest is required for download id "${id}". Run create_export for this export before downloading. Details: ${reason}`
+      );
+    }
+    if (manifest.export.id !== id) {
+      throw new Error(
+        `Export manifest mismatch for id "${id}". Run create_export and retry download.`
+      );
+    }
+    await ensureDir(this.exportsRoot);
+    await this.provider.downloadExportArchive(id, targetZipPath);
+    await resetDir(targetProjectPath);
+    await extractZip(targetZipPath, targetProjectPath);
+    const pages = manifest.pages;
+    return {
+      exportId: id,
+      projectPath: targetProjectPath,
+      manifestPath,
+      pages
+    };
+  }
+  async inspectPage(slug, _context) {
+    await this.ensureTempLayout();
+    const pageDetails = await this.provider.getProjectPageBySlug(slug);
+    const reportPayload = buildInspectPageReport(pageDetails);
+    return {
+      ...pageDetails,
+      report: reportPayload.report,
+      reportRows: reportPayload.reportRows
+    };
+  }
+  async copyPage(originPageSlug, actualPageSlug, _context) {
+    await this.ensureTempLayout();
+    return copyPageFromExport({
+      projectRoot: this.targetProjectRoot,
+      exportsRoot: this.exportsRoot,
+      originPageSlug,
+      actualPageSlug
+    });
+  }
+  async clearTemp(_context) {
+    await resetDir(this.tempRoot);
+    await ensureDir(this.exportsRoot);
+  }
+  async ensureTempLayout() {
+    await ensureDir(this.primeUiRoot);
+    await ensureDir(this.tempRoot);
+    await ensureDir(this.exportsRoot);
+  }
+};
+
+// 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;
   }
-  return {
-    export: {
-      id: exportObject.id,
-      status,
-      createdAt: exportObject.createdAt,
-      expiresAt: exportObject.expiresAt,
-      summary,
-      components
+  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);
     },
-    pages: maybe.pages
-  };
-}
-var ProjectSyncService = class {
-  provider;
-  projectRoot;
-  targetProjectRoot;
-  primeUiRoot;
-  tempRoot;
-  exportsRoot;
+    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.projectRoot = options.projectRoot;
-    this.targetProjectRoot = options.targetProjectRoot;
-    this.provider = options.provider;
-    this.primeUiRoot = path6.join(this.projectRoot, ".primeui");
-    this.tempRoot = path6.join(this.primeUiRoot, "temp");
-    this.exportsRoot = path6.join(this.tempRoot, "exports");
+    this.apiKey = options.apiKey;
+    this.apiRoot = normalizeApiRoot(options.baseUrl ?? DEFAULT_API_BASE_URL);
   }
   async getProjectInfo() {
-    await this.ensureTempLayout();
-    return this.provider.getProjectInfo();
+    return this.requestJson("project", projectInfoSchema);
+  }
+  async getProjectPageBySlug(slug) {
+    const encodedSlug = encodeURIComponent(slug);
+    return this.requestJson(
+      `project/page?slug=${encodedSlug}`,
+      projectPageDetailsSchema
+    );
   }
   async listExports() {
-    await this.ensureTempLayout();
-    return this.provider.listExports();
+    const response = await this.requestJson(
+      "project/exports",
+      exportsResponseSchema
+    );
+    return response.exports;
   }
   async createExport() {
-    await this.ensureTempLayout();
-    const result = await this.provider.createExport();
-    const manifestPath = buildManifestPath(this.exportsRoot, result.export.id);
-    await writeUtf8(manifestPath, `${JSON.stringify(result, null, 2)}
-`);
-    return result;
+    return this.requestJson("project/exports", createExportResponseSchema, {
+      method: "POST"
+    });
   }
-  async downloadExportById(id) {
-    await this.ensureTempLayout();
-    const exportsList = await this.provider.listExports();
-    const selected = exportsList.find((item) => item.id === id);
-    if (!selected) {
-      throw new Error(`Export not found: ${id}`);
+  /**
+   * 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 targetZipPath = path6.join(this.exportsRoot, `${id}.zip`);
-    const targetProjectPath = path6.join(this.exportsRoot, id);
-    const manifestPath = buildManifestPath(this.exportsRoot, id);
-    let manifest;
-    try {
-      manifest = parseExportManifest(
-        JSON.parse(await readFile4(manifestPath, "utf-8"))
+    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) {
-      const reason = error instanceof Error ? error.message : String(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(
-        `Export manifest is required for download id "${id}". Run create_export for this export before downloading. Details: ${reason}`
+        `PrimeUI API request failed (${response.status}) for "${endpoint}": ${details}`
       );
     }
-    if (manifest.export.id !== id) {
-      throw new Error(
-        `Export manifest mismatch for id "${id}". Run create_export and retry download.`
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!isJsonContentType(contentType)) {
+      throw new PrimeUiApiContractError(
+        endpoint,
+        `expected JSON content-type but got "${contentType || "unknown"}"`
       );
     }
-    await ensureDir(this.exportsRoot);
-    await this.provider.downloadExportArchive(id, targetZipPath);
-    await resetDir(targetProjectPath);
-    await extractZip(targetZipPath, targetProjectPath);
-    const pages = manifest.pages;
-    return {
-      exportId: id,
-      projectPath: targetProjectPath,
-      manifestPath,
-      pages
-    };
+    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 inspectPage(slug) {
-    await this.ensureTempLayout();
-    const pageDetails = await this.provider.getProjectPageBySlug(slug);
-    const reportPayload = buildInspectPageReport(pageDetails);
-    return {
-      ...pageDetails,
-      report: reportPayload.report,
-      reportRows: reportPayload.reportRows
-    };
+  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);
+}
+var LazyProjectSyncSource = class {
+  env;
+  getCwd;
+  createProvider;
+  stickyProjectRoot;
+  constructor(options = {}) {
+    this.env = options.env ?? process.env;
+    this.getCwd = options.getCwd ?? (() => process.cwd());
+    this.createProvider = options.createProvider ?? defaultCreateProvider;
+  }
+  async withService(context, operation) {
+    const service = await this.createProjectSyncService(context);
+    return operation(service);
+  }
+  async withMutationService(context, operation) {
+    const service = await this.createProjectSyncService(context);
+    return operation(service);
   }
-  async copyPage(originPageSlug, actualPageSlug) {
-    await this.ensureTempLayout();
-    return copyPageFromExport({
-      projectRoot: this.targetProjectRoot,
-      exportsRoot: this.exportsRoot,
-      originPageSlug,
-      actualPageSlug
+  async createProjectSyncService(context) {
+    const resolvedProjectConfig = await resolvePrimeUiProjectConfig({
+      cwd: this.getCwd(),
+      projectRootFromTool: context?.projectRoot,
+      projectRootFromSticky: this.stickyProjectRoot,
+      projectRootFromEnv: this.env.PRIMEUI_PROJECT_ROOT
+    });
+    const projectRoot = resolvedProjectConfig.projectRoot;
+    const targetProjectRoot = path7.resolve(
+      projectRoot,
+      resolvedProjectConfig.projectConfig.targetProjectPath
+    );
+    const apiKey = await resolvePrimeUiApiKey({
+      projectConfig: resolvedProjectConfig.projectConfig,
+      apiKeyFromEnv: this.env.PRIMEUI_API_KEY
+    });
+    this.stickyProjectRoot = projectRoot;
+    const provider = this.createProvider({
+      apiKey,
+      baseUrl: this.env.PRIMEUI_API_BASE_URL
+    });
+    return new ProjectSyncService({
+      projectRoot,
+      targetProjectRoot,
+      provider
     });
   }
-  async clearTemp() {
-    await resetDir(this.tempRoot);
-    await ensureDir(this.exportsRoot);
+  async getProjectInfo(context) {
+    return this.withService(
+      context,
+      (service) => service.getProjectInfo(context)
+    );
   }
-  async healthCheck() {
-    return {
-      status: "ok",
-      runtime: {
-        cwd: process.cwd(),
-        codexWorkspaceRoot: process.env.CODEX_WORKSPACE_ROOT?.trim() || null,
-        vscodeCwd: process.env.VSCODE_CWD?.trim() || null,
-        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: "CODEX_WORKSPACE_ROOT",
-          description: "Preferred workspace root from Codex clients. May appear only during tool calls.",
-          currentValue: process.env.CODEX_WORKSPACE_ROOT?.trim() || null
-        },
-        {
-          key: "VSCODE_CWD",
-          description: "Workspace cwd hint set by some VS Code runtimes. Used as project search fallback.",
-          currentValue: process.env.VSCODE_CWD?.trim() || null
-        },
-        {
-          key: "INIT_CWD",
-          description: "Install/runtime cwd hint. Used as fallback when workspace-specific env is unavailable.",
-          currentValue: process.env.INIT_CWD?.trim() || null
-        },
-        {
-          key: "PWD",
-          description: "Shell working directory hint. Used as fallback when workspace-specific env is unavailable.",
-          currentValue: process.env.PWD?.trim() || null
-        },
-        {
-          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 listExports(context) {
+    return this.withService(context, (service) => service.listExports(context));
   }
-  async ensureTempLayout() {
-    await ensureDir(this.primeUiRoot);
-    await ensureDir(this.tempRoot);
-    await ensureDir(this.exportsRoot);
+  async createExport(context) {
+    return this.withService(
+      context,
+      (service) => service.createExport(context)
+    );
+  }
+  async downloadExportById(id, context) {
+    return this.withService(
+      context,
+      (service) => service.downloadExportById(id, context)
+    );
+  }
+  async inspectPage(slug, context) {
+    return this.withService(
+      context,
+      (service) => service.inspectPage(slug, context)
+    );
+  }
+  async copyPage(originPageSlug, actualPageSlug, context) {
+    return this.withMutationService(
+      context,
+      (service) => service.copyPage(originPageSlug, actualPageSlug, context)
+    );
+  }
+  async clearTemp(context) {
+    return this.withMutationService(
+      context,
+      (service) => service.clearTemp(context)
+    );
   }
 };
 
-// src/sources/api-provider.ts
-import { createWriteStream } from "fs";
-import { unlink } from "fs/promises";
-import path7 from "path";
-import { Readable, Transform } from "stream";
-import { pipeline } from "stream/promises";
-import { z as z3 } 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 exportStatusSchema2 = 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;
+// src/server.ts
+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(
+    "Stable PrimeUI page identifier. Use this to match the same page across tool responses."
+  ),
+  title: z3.string().describe(
+    "Human-readable page title. Show this to the user when confirming which pages to import."
+  ),
+  slug: z3.string().describe(
+    "PrimeUI route slug, for example '/', '/pricing', '/docs/getting-started'. Use to match user intent."
+  ),
+  pageType: z3.string().describe(
+    "PrimeUI page type classification (for example landing, docs, pricing, blogIndex, legal)."
+  ),
+  isReadyToExport: z3.boolean().describe(
+    "True when this page has an active export-ready variant. Only ready pages are expected in export output."
+  ),
+  pagePath: z3.string().describe(
+    "Relative file path to the page source inside downloaded export root. Copy page code from this exact path."
+  ),
+  componentsPath: z3.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(
+  "Export lifecycle state. Use 'completed' before calling download_export."
+);
+var exportItemSchema = z3.object({
+  id: z3.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.")
+}).describe("Single export record from PrimeUI export history.");
 var exportSummarySchema2 = z3.object({
-  total: z3.number(),
-  successful: z3.number(),
-  failed: z3.number()
+  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 exportedComponentSchema = z3.object({
-  componentKey: z3.string(),
-  enabled: z3.boolean(),
-  files: z3.array(z3.string()),
-  message: z3.string()
+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 exportPageManifestSchema2 = z3.object({
-  success: z3.boolean(),
-  message: z3.string(),
-  files: z3.array(z3.string())
+  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(
+    "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(),
-  title: z3.string().optional(),
-  slug: z3.string(),
-  pageType: z3.string(),
-  isReadyToExport: z3.literal(true),
-  pagePath: z3.string(),
-  componentsPath: z3.string(),
+  id: z3.string().describe("Stable PrimeUI page identifier for this export entry."),
+  title: z3.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."),
   manifest: exportPageManifestSchema2
 });
-var projectInfoSchema = z3.object({
-  projectId: z3.string(),
-  projectName: z3.string(),
-  metadata: z3.record(z3.unknown()),
-  pages: z3.array(projectPageSchema)
+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 projectPageComponentSchema = z3.object({
-  blockId: z3.string(),
-  componentId: z3.string(),
-  componentGroup: z3.string(),
-  slot: z3.string().nullable(),
-  props: z3.record(z3.unknown()).nullable()
+var conflictFileSchema = fileTransferSchema.extend({
+  diff: z3.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.")
 });
-var projectPageDetailsSchema = z3.object({
-  page: projectPageObjectSchema.extend({
-    pageInstruction: z3.string().nullable()
+var dependencySectionSchema = z3.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."),
+  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."),
+  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.")
+});
+var pageDetailsSchema = pageSchema.extend({
+  pageInstruction: z3.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.")
+}).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 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 projectRootInputSchema = z3.string().optional().describe(
+  "Optional absolute project root path. Use when .primeui/project.json cannot be auto-resolved from current working directory."
+);
+var toolErrorOutputSchema = z3.object({
+  error: z3.object({
+    code: z3.string().describe("Machine-readable error code."),
+    message: z3.string().describe("Human-readable error message."),
+    hint: z3.string().optional().describe("Actionable guidance to fix the error.")
+  }).catchall(z3.unknown()).describe("Structured error payload for failed tool execution.")
+});
+function withToolErrorOutputSchema(successShape) {
+  return z3.union([z3.object(successShape), toolErrorOutputSchema]);
+}
+var TRIGGER_PHRASES = [
+  "import page from PrimeUI",
+  "add page from PrimeUI",
+  "sync pages",
+  "pull page",
+  "transfer page",
+  "get page from PrimeUI",
+  "bring page from PrimeUI",
+  "export from PrimeUI"
+].join(", ");
+var WORKFLOW_SUMMARY = `
+WORKFLOW ORDER (always follow this sequence):
+1. clear_temp -> cleanup stale temp files from previous runs before starting new import flow
+2. get_project_info -> discover PrimeUI pages
+3. Reconcile PrimeUI pages with local project pages/routes/paths, then confirm target pages with user
+4. inspect_page -> inspect selected page components and produce a structured comparison table
+5. create_export -> generate export snapshot and local manifest with page file lists + global components
+6. download_export -> download to temp directory
+7. copy_page -> copy one page safely (repeat for each selected page)
+8. Reconcile integration points and resolve reported conflicts, if any
+`.trim();
+var initialInstructions = `
+PrimeUI MCP enables importing pages from PrimeUI Studio into your local project.
+
+TRIGGER EXAMPLES (semantic intent, not exact phrase matching): ${TRIGGER_PHRASES}
+
+${WORKFLOW_SUMMARY}
+
+CRITICAL RULES FOR PAGE IMPORT:
+- Import is PAGE-BY-PAGE only. Never import the entire project at once.
+- 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.
+- Decision matrix:
+  - PrimeUI + local page exists -> candidate for update/review.
+  - PrimeUI exists, local missing -> import candidate.
+  - Local exists, PrimeUI missing -> custom local page, no action unless user asks.
+  - Both exist but path mismatch -> ambiguous, export + compare before deciding.
+- For targeted component-level analysis on a specific page, call inspect_page before export/copy.
+- After inspect_page returns report table, supplement that table with local project page state:
+  mark what already exists, what is missing, and what differs.
+- Before creating export, ask user which pages to add/update (specific pages or all missing pages) and keep that choice in thread context.
+- create_export response includes:
+  - page-level manifest files per page ('pages[].manifest.files'),
+  - global components list ('export.components').
+  Mention both to user after create_export, because this is the source of truth for copy decisions.
+- The downloaded export in .primeui/temp/ contains a full standalone Next.js project.
+  Do NOT copy it wholesale.
+- Always call copy_page for each confirmed page instead of manual file copy.
+- copy_page performs safe copy only:
+  - new files are copied,
+  - identical files are reported,
+  - conflicting files are NEVER overwritten and are returned with diff.
+- copy_page reads and validates files only from 'pages[].manifest.files' in local sidecar manifest.
+- copy_page may add only missing dependencies to user's package.json.
+  It never upgrades existing dependency versions and never runs dependency installation.
+- After page copy operations, inspect integration points (navigation configs, link menus, route registries, page indexes).
+- 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 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.
+
+WHEN TO USE: Call this FIRST when user wants to import, add, sync, pull, or transfer a page from PrimeUI. Intent examples (semantic intent, not exact phrase matching): ${TRIGGER_PHRASES}.
+
+AFTER CALLING:
+- Scan the user's local project to discover existing pages/routes and related page component folders.
+- Build a reconciliation report between PrimeUI and local project with action labels:
+  - Page exists in both PrimeUI and local project.
+  - Page exists in PrimeUI but not in local project -> import candidate.
+  - Page exists in local project but not in PrimeUI -> custom local page, no action by default.
+  - Page exists in both but slug/pagePath/componentsPath mapping does not match -> ambiguous, requires export-based comparison before decision.
+- If user already requested specific pages, first verify those pages exist in PrimeUI and are isReadyToExport: true.
+- If any requested page is not found or not ready, report this immediately and ask for replacement page choices.
+- Ask the user which pages to add or update now (specific page list or all missing pages) and keep this decision in thread context.
+- Import works per page. Multiple pages are allowed, but each page transfer is handled explicitly.
+- Only after user decision is clear, proceed to create_export.
+
+${WORKFLOW_SUMMARY}`,
+  inputSchema: {
+    projectRoot: projectRootInputSchema
+  },
+  outputSchema: withToolErrorOutputSchema({
+    projectId: z3.string().describe(
+      "PrimeUI project identifier associated with the API key and current import session context."
+    ),
+    projectName: z3.string().describe(
+      "Human-readable PrimeUI project name for confirmations in chat."
+    ),
+    metadata: z3.record(z3.unknown()).describe(
+      "Additional project metadata from PrimeUI. May include project-description and other context fields."
+    ),
+    pages: z3.array(pageSchema).describe(
+      "All pages visible for this project context. Filter by user request and isReadyToExport before creating export."
+    )
+  }),
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  }
+};
+var toolInspectPage = {
+  title: "PrimeUI Inspect Page",
+  description: `Targeted inspection tool for one PrimeUI page. Returns page details, active variant (if present), raw components payload, and a formatted report table.
+
+WHEN TO USE:
+- Call this after get_project_info when user wants component-level analysis for a specific page.
+- Use this before export/copy when user asks to compare or selectively update page sections.
+
+AFTER CALLING:
+- Use report + reportRows to present the component table:
+  Number (1-based), ComponentGroup (ComponentId), Title/Description, blockId.
+- Then supplement this table with the CURRENT local project page state:
+  what already exists, what is missing, and what differs.
+- Do not assume componentId is unique. Use blockId as the primary component instance identifier.
+
+If page has no active variant, components is null (not empty array), and report explains why.
+
+${WORKFLOW_SUMMARY}`,
+  inputSchema: {
+    projectRoot: projectRootInputSchema,
+    pageSlug: z3.string().describe(
+      "PrimeUI page slug to inspect, for example '/', '/pricing', '/docs/getting-started'."
+    )
+  },
+  outputSchema: withToolErrorOutputSchema({
+    page: pageDetailsSchema.describe(
+      "Single PrimeUI page details resolved by slug with pageInstruction."
+    ),
+    variant: pageVariantSchema,
+    components: z3.array(pageComponentSchema).nullable().describe(
+      "Raw component instances from active variant. Null when page has no active variant."
+    ),
+    report: z3.string().describe(
+      "Formatted report table generated by MCP from component payload (includes extracted title/description summary)."
+    ),
+    reportRows: z3.array(inspectPageReportRowSchema).describe(
+      "Structured report rows with 1-based numbering and extracted title/description fields."
+    )
+  }),
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  }
+};
+var toolListExports = {
+  title: "PrimeUI Export List",
+  description: `Auxiliary tool to list previously created exports with their IDs, statuses, and creation dates. This is NOT the starting point for page import - start with get_project_info instead.
+
+WHEN TO USE: This is an OPTIONAL helper tool, NOT part of the main import flow. Use it only when:
+- Something went wrong with an export and you need to check its status.
+- The user explicitly references a previous export by date or context.
+- You need to verify whether an export initiated via PrimeUI Studio UI has completed.
+
+Note: exports can be created both through create_export AND by the user directly in PrimeUI Studio UI. This tool shows all of them.
+
+Do NOT use this tool as a substitute for create_export. Always create a fresh export unless the user explicitly asks to use a previous one.
+
+${WORKFLOW_SUMMARY}`,
+  inputSchema: {
+    projectRoot: projectRootInputSchema
+  },
+  outputSchema: withToolErrorOutputSchema({
+    exports: z3.array(exportItemSchema).describe(
+      "Available exports sorted by API policy. Use item.id to download a specific prior export if user asks."
+    )
   }),
-  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(),
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  }
+};
+var toolCreateExport = {
+  title: "PrimeUI Create Export",
+  description: `Create a new export snapshot from the current PrimeUI project state and wait for completion. Returns strict export manifest payload from API, including page-level file manifests and global components.
+
+WHEN TO USE: Call this AFTER the user has confirmed which pages they want to import via get_project_info. This tool is REQUIRED before download_export, unless the user explicitly and directly asked to download a specific previous export.
+
+AFTER CALLING:
+- Verify that all user-selected pages are present in the export result AND have isReadyToExport: true.
+- If path mismatch pages were flagged during project-info reconciliation, ensure they are included for deeper comparison after download.
+- If any required page is missing or not ready, report and pause for user decision before proceeding.
+- Mention that global components are available in export.components and can be transferred separately if needed.
+- Local sidecar manifest is saved to .primeui/temp/exports/[exportId].manifest.json from this API payload.
+- Use the returned export ID to call download_export.
+
+${WORKFLOW_SUMMARY}`,
+  inputSchema: {
+    projectRoot: projectRootInputSchema
+  },
+  outputSchema: withToolErrorOutputSchema({
+    export: z3.object({
+      id: z3.string().describe(
+        "Freshly created export identifier. Use this as download_export input.id."
+      ),
       status: exportStatusSchema2,
-      createdAt: z3.string().datetime({ offset: true })
-    })
-  )
-});
-var createExportResponseSchema = z3.object({
-  export: z3.object({
-    id: z3.string(),
-    status: exportStatusSchema2,
-    createdAt: z3.string().datetime({ offset: true }),
-    expiresAt: z3.string().datetime({ offset: true }).nullable(),
-    summary: exportSummarySchema2,
-    components: z3.array(exportedComponentSchema)
+      createdAt: z3.string().describe("Export creation timestamp in ISO-8601 UTC format."),
+      expiresAt: z3.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(
+        "Global component export manifest. These components are independent from page-level manifests."
+      )
+    }).describe("Created export summary."),
+    pages: z3.array(exportPageSchema2).describe(
+      "Strict page payload associated with this export, including per-page manifest files list."
+    )
   }),
-  pages: z3.array(exportPageSchema2)
-});
-var PrimeUiApiContractError = class extends Error {
-  constructor(endpoint, details) {
-    super(`PrimeUI API contract mismatch for "${endpoint}": ${details}`);
-    this.name = "PrimeUiApiContractError";
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
   }
 };
-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();
+var toolDownloadExport = {
+  title: "PrimeUI Download Export",
+  description: `Download a completed export into .primeui/temp/exports/[exportId]. Downloads and extracts the full export as a standalone Next.js project into the temp directory. This does NOT modify the user's project - files land only in .primeui/temp/.
+
+Do NOT call this as the first step. Requires export ID from create_export. Start with get_project_info instead.
+
+WHEN TO USE: Call this AFTER create_export has returned a completed export. Requires export ID from create_export so MCP can use the matching local sidecar manifest.
+
+NOTE:
+- Download of an export ID without local sidecar manifest will fail.
+- For previous exports, create a fresh export first when possible.
+
+AFTER DOWNLOAD:
+- Use manifestPath from this response as the contract for page slug/path mapping and manifest file lists in copy operations.
+- For each selected page, call copy_page with:
+  - originPageSlug (required),
+  - actualPageSlug (optional, if route remap is needed).
+- If there are unresolved conflicts in copy report, stop and ask the user.
+- Do not force cleanup at flow end; keep downloaded export files available for validation and follow-up checks.
+
+  ${WORKFLOW_SUMMARY}`,
+  inputSchema: {
+    projectRoot: projectRootInputSchema,
+    id: z3.string().describe(
+      "Export identifier to download. Prefer export.id from create_export; use list_exports only on explicit user request."
+    )
+  },
+  outputSchema: withToolErrorOutputSchema({
+    exportId: z3.string().describe(
+      "Downloaded export identifier. Should match the requested input.id for traceability."
+    ),
+    projectPath: z3.string().describe(
+      "Absolute local path to extracted export root in .primeui/temp/exports/[exportId]. Read files from here only."
+    ),
+    manifestPath: z3.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(
+      "Page descriptors loaded from local sidecar export manifest for import decisions."
+    )
+  }),
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
   }
-  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;
+var toolCopyPage = {
+  title: "PrimeUI Copy Page",
+  description: `Safely copy one page from downloaded export into the user's local project. Works only with local files in .primeui/temp/exports and does NOT call PrimeUI API.
+
+WHEN TO USE:
+- Call this AFTER download_export.
+- Call once per selected page.
+- Use actualPageSlug only when user wants to remap route during import.
+
+BEHAVIOR:
+- Reads export sidecar manifest to resolve originPageSlug -> pagePath/componentsPath.
+- Copies and validates files strictly from pages[].manifest.files for the selected page.
+- Never overwrites existing conflicting files.
+- Reports:
+  a) copied new files,
+  b) identical existing files,
+  c) conflicting files with diff,
+  d) missing dependencies added to package.json,
+  e) dependency version conflicts (report-only, no auto upgrade).
+- Adds only missing dependencies to package.json (dependencies/devDependencies/peerDependencies).
+- Never updates existing dependency versions and never runs install commands.
+
+${WORKFLOW_SUMMARY}`,
+  inputSchema: {
+    projectRoot: projectRootInputSchema,
+    originPageSlug: z3.string().describe(
+      "Source page slug from PrimeUI project pages list, for example '/', '/pricing', '/docs'."
+    ),
+    actualPageSlug: z3.string().optional().describe(
+      "Optional destination slug in user's project. If omitted, originPageSlug is used."
+    )
+  },
+  outputSchema: withToolErrorOutputSchema({
+    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(
+      "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(
+      "Existing files in user project that are byte-identical to export files."
+    ),
+    conflictFiles: z3.array(conflictFileSchema).describe(
+      "Files that already exist and differ from export version. Never overwritten."
+    ),
+    addedDependencies: z3.array(dependencyToAddSchema).describe(
+      "Dependencies that were missing and have been added to user's package.json."
+    ),
+    dependenciesVersionConflicts: z3.array(dependencyVersionConflictSchema).describe(
+      "Dependencies with version mismatch between export and user project. Report only."
+    ),
+    summary: z3.object({
+      totalCandidateFiles: z3.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.")
+    })
+  }),
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: 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"
-    });
+var toolClearTemp = {
+  title: "PrimeUI Clear Temp",
+  description: `Delete all files in .primeui/temp/ and recreate empty temp structure.
+
+Call this at the START of a new import flow, before get_project_info/create_export, to reset stale temp state from previous runs.
+
+WHEN TO USE: Call once at the beginning of each new import flow. Do not call this between page imports in the same flow.
+
+Safe to call multiple times. Only affects .primeui/temp/ directory - never touches the user's project files.
+
+${WORKFLOW_SUMMARY}`,
+  inputSchema: {
+    projectRoot: projectRootInputSchema
+  },
+  outputSchema: withToolErrorOutputSchema({
+    success: z3.boolean().describe(
+      "True when temp cleanup completed and baseline temp structure was recreated."
+    )
+  }),
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
   }
-  /**
-   * 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}`
+};
+
+// src/server.ts
+function okResult(title, data) {
+  return {
+    content: [{ type: "text", text: `${title} completed` }],
+    structuredContent: data
+  };
+}
+function errorResult(error) {
+  if (error instanceof PrimeUiProjectConfigError) {
+    const text = error.hint ? `primeui mcp error: ${error.message}
+Hint: ${error.hint}` : `primeui mcp error: ${error.message}`;
+    return {
+      isError: true,
+      content: [{ type: "text", text }],
+      structuredContent: {
+        error: {
+          code: error.code,
+          message: error.message,
+          ...error.hint ? { hint: error.hint } : {},
+          ...error.details
+        }
       }
-    });
-    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(path7.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}`
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    isError: true,
+    content: [{ type: "text", text: `primeui mcp error: ${message}` }],
+    structuredContent: {
+      error: {
+        code: "UNKNOWN_ERROR",
+        message
       }
-    });
-    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"
-      );
+  };
+}
+function createPrimeUiMcpServer(source) {
+  const server = new McpServer(
+    {
+      name: "primeui-mcp-server",
+      version: "0.1.0"
+    },
+    {
+      instructions: initialInstructions
     }
-    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);
+  );
+  server.registerTool(
+    "get_project_info",
+    toolGetProjectInfo,
+    async ({ projectRoot }) => {
+      try {
+        const info = await source.getProjectInfo({
+          projectRoot
+        });
+        return okResult("get_project_info", info);
+      } catch (error) {
+        return errorResult(error);
+      }
     }
-    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();
-        }
+  );
+  server.registerTool(
+    "inspect_page",
+    toolInspectPage,
+    async ({ pageSlug, projectRoot }) => {
+      try {
+        const result = await source.inspectPage(
+          pageSlug,
+          { projectRoot }
+        );
+        return okResult("inspect_page", result);
+      } catch (error) {
+        return errorResult(error);
       }
-    } 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.");
+  );
+  server.registerTool(
+    "list_exports",
+    toolListExports,
+    async ({ projectRoot }) => {
+      try {
+        const exportsList = await source.listExports({
+          projectRoot
+        });
+        return okResult("list_exports", { exports: exportsList });
+      } catch (error) {
+        return errorResult(error);
+      }
     }
-    return apiKey;
-  }
-};
-
-// src/service.ts
-function getProjectConfigFallbackCwds(rootsFallbackCwds = []) {
-  return [
-    process.env.CODEX_WORKSPACE_ROOT,
-    process.env.VSCODE_CWD,
-    ...rootsFallbackCwds,
-    process.env.INIT_CWD,
-    process.env.PWD
-  ].map((value) => value?.trim()).filter((value) => Boolean(value));
-}
-async function createProjectSyncService(rootsFallbackCwds) {
-  const fallbackCwds = getProjectConfigFallbackCwds(rootsFallbackCwds);
-  console.error(
-    "[primeui-mcp] TOOL_CALL_ENV:",
-    JSON.stringify({
-      CODEX_WORKSPACE_ROOT: process.env.CODEX_WORKSPACE_ROOT ?? null,
-      VSCODE_CWD: process.env.VSCODE_CWD ?? null,
-      INIT_CWD: process.env.INIT_CWD ?? null,
-      PWD: process.env.PWD ?? null
-    })
   );
-  const resolvedProjectConfig = await resolvePrimeUiProjectConfig({
-    cwd: process.cwd(),
-    projectRootFromEnv: process.env.PRIMEUI_PROJECT_ROOT,
-    fallbackCwds
-  });
-  const projectRoot = resolvedProjectConfig.projectRoot;
-  const targetProjectRoot = path8.resolve(
-    projectRoot,
-    resolvedProjectConfig.projectConfig.targetProjectPath
+  server.registerTool(
+    "create_export",
+    toolCreateExport,
+    async ({ projectRoot }) => {
+      try {
+        const result = await source.createExport({
+          projectRoot
+        });
+        return okResult("create_export", result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
   );
-  console.error("[primeui-mcp] RESOLVED_PROJECT_ROOT:", projectRoot);
-  console.error(
-    "[primeui-mcp] RESOLVED_PROJECT_CONFIG:",
-    resolvedProjectConfig.projectConfigPath
+  server.registerTool(
+    "download_export",
+    toolDownloadExport,
+    async ({ id, projectRoot }) => {
+      try {
+        const result = await source.downloadExportById(
+          id,
+          { projectRoot }
+        );
+        return okResult("download_export", result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
   );
-  const apiKey = await resolvePrimeUiApiKey({
-    projectConfig: resolvedProjectConfig.projectConfig,
-    apiKeyFromEnv: process.env.PRIMEUI_API_KEY
-  });
-  const provider = new ApiProjectDataProvider({
-    apiKey,
-    baseUrl: process.env.PRIMEUI_API_BASE_URL
-  });
-  return new ProjectSyncService({
-    projectRoot,
-    targetProjectRoot,
-    provider
-  });
-}
-var LazyProjectSyncSource = class {
-  constructor(getRootsFallbackCwds) {
-    this.getRootsFallbackCwds = getRootsFallbackCwds;
-  }
-  async withService(operation) {
-    const service = await createProjectSyncService(this.getRootsFallbackCwds());
-    return operation(service);
-  }
-  async getProjectInfo() {
-    return this.withService((service) => service.getProjectInfo());
-  }
-  async listExports() {
-    return this.withService((service) => service.listExports());
-  }
-  async createExport() {
-    return this.withService((service) => service.createExport());
-  }
-  async downloadExportById(id) {
-    return this.withService((service) => service.downloadExportById(id));
-  }
-  async inspectPage(slug) {
-    return this.withService((service) => service.inspectPage(slug));
-  }
-  async copyPage(originPageSlug, actualPageSlug) {
-    return this.withService(
-      (service) => service.copyPage(originPageSlug, actualPageSlug)
-    );
-  }
-  async clearTemp() {
-    return this.withService((service) => service.clearTemp());
-  }
-  async healthCheck() {
-    const rootsFallbackCwds = this.getRootsFallbackCwds();
-    const fallbackCwds = getProjectConfigFallbackCwds(rootsFallbackCwds);
-    const result = await runPrimeUiHealthCheck({
-      cwd: process.cwd(),
-      codexWorkspaceRoot: process.env.CODEX_WORKSPACE_ROOT,
-      vscodeCwd: process.env.VSCODE_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,
-      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);
+  server.registerTool(
+    "clear_temp",
+    toolClearTemp,
+    async ({ projectRoot }) => {
+      try {
+        await source.clearTemp({ projectRoot });
+        return okResult("clear_temp", { success: true });
+      } catch (error) {
+        return errorResult(error);
+      }
     }
-    return result;
-  }
-};
-function toFileRootPath(rootUri) {
-  try {
-    const parsed = new URL(rootUri);
-    if (parsed.protocol !== "file:") {
-      return null;
+  );
+  server.registerTool(
+    "copy_page",
+    toolCopyPage,
+    async ({
+      originPageSlug,
+      actualPageSlug,
+      projectRoot
+    }) => {
+      try {
+        const result = await source.copyPage(
+          originPageSlug,
+          actualPageSlug,
+          { projectRoot }
+        );
+        return okResult("copy_page", result);
+      } catch (error) {
+        return errorResult(error);
+      }
     }
-    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 [];
-  }
+  );
+  return server;
 }
+
+// src/service.ts
 async function main() {
-  console.error("CWD:", process.cwd());
-  console.error("CODEX_WORKSPACE_ROOT:", process.env.CODEX_WORKSPACE_ROOT);
-  console.error("VSCODE_CWD:", process.env.VSCODE_CWD);
-  console.error("INIT_CWD:", process.env.INIT_CWD);
-  console.error("PWD:", process.env.PWD);
-  let rootsFallbackCwds = [];
-  const server = createPrimeUiMcpServer(
-    new LazyProjectSyncSource(() => rootsFallbackCwds)
-  );
+  const source = new LazyProjectSyncSource();
+  const server = createPrimeUiMcpServer(source);
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  rootsFallbackCwds = await loadClientRootFallbackCwds(server);
 }
 main().catch((error) => {
   console.error("[primeui-mcp] failed to start", error);