@primeuicom/mcp 0.1.9 → 0.1.11

package/dist/service.js

@@ -1,26 +1,1763 @@
 #!/usr/bin/env node
+
+// src/service.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { createPrimeUiMcpServer } from "./server.js";
-import { ProjectSyncService } from "./services/project-sync-service.js";
-import { ApiProjectDataProvider } from "./sources/api-provider.js";
-async function main() {
-    const projectRoot = process.env.PRIMEUI_PROJECT_ROOT || process.cwd();
-    const apiKey = process.env.PRIMEUI_API_KEY;
-    const provider = new ApiProjectDataProvider({
-        apiKey,
-        baseUrl: process.env.PRIMEUI_API_BASE_URL,
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/instructions.ts
+import { z } from "zod/v3";
+var pageSchema = z.object({
+  id: z.string().describe(
+    "Stable PrimeUI page identifier. Use this to match the same page across tool responses."
+  ),
+  title: z.string().describe(
+    "Human-readable page title. Show this to the user when confirming which pages to import."
+  ),
+  slug: z.string().describe(
+    "PrimeUI route slug, for example '/', '/pricing', '/docs/getting-started'. Use to match user intent."
+  ),
+  pageType: z.string().describe(
+    "PrimeUI page type classification (for example landing, docs, pricing, blogIndex, legal)."
+  ),
+  isReadyToExport: z.boolean().describe(
+    "True when this page has an active export-ready variant. Only ready pages are expected in export output."
+  ),
+  pagePath: z.string().describe(
+    "Relative file path to the page source inside downloaded export root. Copy page code from this exact path."
+  ),
+  componentsPath: z.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 = z.enum(["in_progress", "completed", "failed"]).describe(
+  "Export lifecycle state. Use 'completed' before calling primeui_download_export."
+);
+var exportItemSchema = z.object({
+  id: z.string().describe(
+    "Export identifier. Pass this value to primeui_download_export input.id."
+  ),
+  status: exportStatusSchema,
+  createdAt: z.string().describe("Export creation timestamp in ISO-8601 UTC format.")
+}).describe("Single export record from PrimeUI export history.");
+var fileTransferSchema = z.object({
+  sourcePath: z.string().describe("Relative source file path inside downloaded export root."),
+  targetPath: z.string().describe("Relative target file path inside user project root.")
+});
+var conflictFileSchema = fileTransferSchema.extend({
+  diff: z.string().describe(
+    "Unified diff between user file and export file. For binary files the diff contains a plain message."
+  ),
+  isBinary: z.boolean().describe("True if conflict comparison was treated as binary data.")
+});
+var dependencySectionSchema = z.enum([
+  "dependencies",
+  "devDependencies",
+  "peerDependencies"
+]);
+var dependencyToAddSchema = z.object({
+  packageName: z.string().describe("Dependency package name that was missing in user package.json."),
+  version: z.string().describe("Version from exported project's package.json."),
+  section: dependencySectionSchema.describe(
+    "package.json section where dependency should be added."
+  )
+});
+var dependencyVersionConflictSchema = z.object({
+  packageName: z.string().describe("Dependency package name with version mismatch."),
+  section: dependencySectionSchema.describe(
+    "Section where export expects this dependency."
+  ),
+  exportVersion: z.string().describe("Version found in exported project's package.json."),
+  userVersion: z.string().describe("Version currently present in user's package.json.")
+});
+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. primeui_get_project_info -> discover PrimeUI pages
+2. Reconcile PrimeUI pages with local project pages/routes/paths, then confirm target pages with user
+3. primeui_create_export -> generate export snapshot for agreed pages/analysis scope
+4. primeui_download_export -> download to temp directory
+5. primeui_copy_page -> copy one page safely (repeat for each selected page)
+6. Reconcile integration points and resolve reported conflicts, if any
+7. primeui_clear_temp -> cleanup temp files
+`.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.
+- After primeui_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.
+- Before creating export, ask user which pages to add/update (specific pages or all missing pages) and keep that choice in thread context.
+- The downloaded export in .primeui/temp/ contains a full standalone Next.js project.
+  Do NOT copy it wholesale.
+- Always call primeui_copy_page for each confirmed page instead of manual file copy.
+- primeui_copy_page performs safe copy only:
+  - new files are copied,
+  - identical files are reported,
+  - conflicting files are NEVER overwritten and are returned with diff.
+- primeui_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 primeui_create_export.
+
+${WORKFLOW_SUMMARY}`,
+  inputSchema: {},
+  outputSchema: {
+    projectId: z.string().describe(
+      "PrimeUI project identifier associated with the API key and current import session context."
+    ),
+    projectName: z.string().describe(
+      "Human-readable PrimeUI project name for confirmations in chat."
+    ),
+    metadata: z.record(z.unknown()).describe(
+      "Additional project metadata from PrimeUI. May include project-description and other context fields."
+    ),
+    pages: z.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 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 primeui_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 primeui_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 primeui_create_export. Always create a fresh export unless the user explicitly asks to use a previous one.
+
+${WORKFLOW_SUMMARY}`,
+  inputSchema: {},
+  outputSchema: {
+    exports: z.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 export ID and the list of pages included in the export.
+
+WHEN TO USE: Call this AFTER the user has confirmed which pages they want to import via primeui_get_project_info. This tool is REQUIRED before primeui_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.
+- Use the returned export ID to call primeui_download_export.
+
+${WORKFLOW_SUMMARY}`,
+  inputSchema: {},
+  outputSchema: {
+    export: z.object({
+      id: z.string().describe(
+        "Freshly created export identifier. Use this as primeui_download_export input.id."
+      ),
+      status: exportStatusSchema
+    }).describe("Created export summary."),
+    pages: z.array(pageSchema).describe(
+      "Page snapshot associated with this export operation. Validate requested pages here before download/import."
+    )
+  },
+  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 primeui_create_export. Start with primeui_get_project_info instead.
+
+WHEN TO USE: Call this AFTER primeui_create_export has returned a completed export. Requires export ID from primeui_create_export so MCP can use the matching local pages snapshot for sidecar manifest generation.
+
+NOTE:
+- Download of an export ID without local pages snapshot may 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 in copy operations.
+- For each selected page, call primeui_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.
+- Only after all requested pages are copied and reconciled, call primeui_clear_temp.
+
+  ${WORKFLOW_SUMMARY}`,
+  inputSchema: {
+    id: z.string().describe(
+      "Export identifier to download. Prefer export.id from primeui_create_export; use primeui_list_exports only on explicit user request."
+    )
+  },
+  outputSchema: {
+    exportId: z.string().describe(
+      "Downloaded export identifier. Should match the requested input.id for traceability."
+    ),
+    projectPath: z.string().describe(
+      "Absolute local path to extracted export root in .primeui/temp/exports/[exportId]. Read files from here only."
+    ),
+    manifestPath: z.string().describe(
+      "Absolute path to sidecar export manifest file (.primeui/temp/exports/[exportId].manifest.json). primeui_copy_page depends on this file."
+    ),
+    pages: z.array(pageSchema).describe(
+      "Page descriptors for import decisions. Use pagePath/componentsPath from each item when copying code into user project."
+    )
+  },
+  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 primeui_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 page file + full page components folder + recursively discovered internal dependencies.
+- 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: z.string().describe(
+      "Source page slug from PrimeUI project pages list, for example '/', '/pricing', '/docs'."
+    ),
+    actualPageSlug: z.string().optional().describe(
+      "Optional destination slug in user's project. If omitted, originPageSlug is used."
+    )
+  },
+  outputSchema: {
+    exportId: z.string().describe("Resolved local export identifier used for copy operation."),
+    exportPath: z.string().describe("Absolute path to local extracted export project root."),
+    originPageSlug: z.string().describe("Normalized source page slug requested for copy."),
+    actualPageSlug: z.string().describe("Normalized destination slug used for target route paths."),
+    sourcePagePath: z.string().describe("Source page path relative to export root."),
+    targetPagePath: z.string().describe("Destination page path relative to user project root."),
+    sourceComponentsPath: z.string().describe("Source components directory relative to export root."),
+    targetComponentsPath: z.string().describe(
+      "Destination components directory relative to user project root."
+    ),
+    newFiles: z.array(fileTransferSchema).describe("New files copied into user project without conflicts."),
+    identicalFiles: z.array(fileTransferSchema).describe(
+      "Existing files in user project that are byte-identical to export files."
+    ),
+    conflictFiles: z.array(conflictFileSchema).describe(
+      "Files that already exist and differ from export version. Never overwritten."
+    ),
+    addedDependencies: z.array(dependencyToAddSchema).describe(
+      "Dependencies that were missing and have been added to user's package.json."
+    ),
+    dependenciesVersionConflicts: z.array(dependencyVersionConflictSchema).describe(
+      "Dependencies with version mismatch between export and user project. Report only."
+    ),
+    summary: z.object({
+      totalCandidateFiles: z.number().describe("Total number of candidate files considered for page copy."),
+      copiedFiles: z.number().describe("Number of files copied as new."),
+      identicalFiles: z.number().describe("Number of files detected as identical."),
+      conflictFiles: z.number().describe("Number of conflicting files not copied."),
+      addedDependencies: z.number().describe("Count of dependencies added to package.json."),
+      dependenciesVersionConflicts: z.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.
+
+Do NOT call this unless ALL requested pages have been successfully imported into the user's project.
+
+WHEN TO USE: Call this as the FINAL step after ALL requested pages have been successfully imported into the user's project. Do not call this between page imports - wait until all pages are done.
+
+Safe to call multiple times. Only affects .primeui/temp/ directory - never touches the user's project files.
+
+${WORKFLOW_SUMMARY}`,
+  inputSchema: {},
+  outputSchema: {
+    success: z.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(
+    "primeui_get_project_info",
+    toolGetProjectInfo,
+    async () => {
+      try {
+        const info = await source.getProjectInfo();
+        return okResult("primeui_get_project_info", info);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+  server.registerTool(
+    "primeui_list_exports",
+    toolListExports,
+    async () => {
+      try {
+        const exportsList = await source.listExports();
+        return okResult("primeui_list_exports", { exports: exportsList });
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+  server.registerTool(
+    "primeui_create_export",
+    toolCreateExport,
+    async () => {
+      try {
+        const result = await source.createExport();
+        return okResult("primeui_create_export", result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+  server.registerTool(
+    "primeui_download_export",
+    toolDownloadExport,
+    async ({ id }) => {
+      try {
+        const result = await source.downloadExportById(id);
+        return okResult("primeui_download_export", result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+  server.registerTool(
+    "primeui_clear_temp",
+    toolClearTemp,
+    async () => {
+      try {
+        await source.clearTemp();
+        return okResult("primeui_clear_temp", { success: true });
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+  server.registerTool(
+    "primeui_copy_page",
+    toolCopyPage,
+    async ({ originPageSlug, actualPageSlug }) => {
+      try {
+        const result = await source.copyPage(
+          originPageSlug,
+          actualPageSlug
+        );
+        return okResult("primeui_copy_page", result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+  return server;
+}
+
+// src/services/project-sync-service.ts
+import path4 from "path";
+import { readFile as readFile3 } from "fs/promises";
+
+// src/lib/fs.ts
+import { mkdir, rm, writeFile } from "fs/promises";
+import path 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(path.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 readFile2, readdir, stat as stat2, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
+
+// src/lib/import-graph.ts
+import { readFile, stat } from "fs/promises";
+import { builtinModules } from "module";
+import path2 from "path";
+var INTERNAL_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json"
+];
+var PARSEABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+]);
+var BUILTIN_MODULES = /* @__PURE__ */ new Set([
+  ...builtinModules,
+  ...builtinModules.map((item) => `node:${item}`)
+]);
+var STATIC_IMPORT_RE = /\bimport\s+(?:type\s+)?(?:[\s\S]*?\sfrom\s+)?["']([^"']+)["']/g;
+var EXPORT_FROM_RE = /\bexport\s+(?:[\s\S]*?\sfrom\s+)["']([^"']+)["']/g;
+var DYNAMIC_IMPORT_RE = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
+var REQUIRE_RE = /\brequire\s*\(\s*["']([^"']+)["']\s*\)/g;
+function collectSpecifiers(content) {
+  const results = /* @__PURE__ */ new Set();
+  let match = null;
+  for (const re of [
+    STATIC_IMPORT_RE,
+    EXPORT_FROM_RE,
+    DYNAMIC_IMPORT_RE,
+    REQUIRE_RE
+  ]) {
+    re.lastIndex = 0;
+    while ((match = re.exec(content)) !== null) {
+      const specifier = match[1]?.trim();
+      if (specifier) {
+        results.add(specifier);
+      }
+    }
+  }
+  return [...results];
+}
+function getExternalPackageName(specifier) {
+  if (!specifier || specifier.startsWith(".") || specifier.startsWith("/")) {
+    return null;
+  }
+  if (specifier.startsWith("node:")) {
+    return null;
+  }
+  if (specifier.startsWith("@/") || specifier.startsWith("@root/")) {
+    return null;
+  }
+  const parts = specifier.split("/");
+  if (parts.length === 0) {
+    return null;
+  }
+  if (specifier.startsWith("@")) {
+    if (parts.length < 2) {
+      return null;
+    }
+    return `${parts[0]}/${parts[1]}`;
+  }
+  return parts[0] ?? null;
+}
+async function pathExists(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveFileCandidate(candidateBase) {
+  const ext = path2.extname(candidateBase);
+  if (ext) {
+    if (await pathExists(candidateBase)) {
+      return candidateBase;
+    }
+    return null;
+  }
+  for (const extension of INTERNAL_EXTENSIONS) {
+    const withExtension = `${candidateBase}${extension}`;
+    if (await pathExists(withExtension)) {
+      return withExtension;
+    }
+  }
+  if (await pathExists(candidateBase)) {
+    const stats = await stat(candidateBase);
+    if (stats.isFile()) {
+      return candidateBase;
+    }
+    if (stats.isDirectory()) {
+      for (const extension of INTERNAL_EXTENSIONS) {
+        const indexCandidate = path2.join(candidateBase, `index${extension}`);
+        if (await pathExists(indexCandidate)) {
+          return indexCandidate;
+        }
+      }
+    }
+  }
+  return null;
+}
+async function resolveImportToFile(projectRoot, importerFilePath, specifier) {
+  const externalPackageName = getExternalPackageName(specifier);
+  if (externalPackageName) {
+    if (!BUILTIN_MODULES.has(externalPackageName)) {
+      return {
+        kind: "external",
+        packageName: externalPackageName
+      };
+    }
+    return { kind: "unknown" };
+  }
+  let candidateBase = null;
+  if (specifier.startsWith("@/")) {
+    candidateBase = path2.join(projectRoot, "src", specifier.slice(2));
+  } else if (specifier.startsWith("@root/")) {
+    candidateBase = path2.join(projectRoot, specifier.slice(6));
+  } else if (specifier.startsWith(".")) {
+    candidateBase = path2.resolve(path2.dirname(importerFilePath), specifier);
+  } else if (specifier.startsWith("/")) {
+    candidateBase = path2.join(projectRoot, specifier.slice(1));
+  } else {
+    return { kind: "unknown" };
+  }
+  const resolved = await resolveFileCandidate(candidateBase);
+  if (!resolved) {
+    return { kind: "unknown" };
+  }
+  return {
+    kind: "internal",
+    filePath: resolved
+  };
+}
+function shouldParseFile(filePath) {
+  return PARSEABLE_EXTENSIONS.has(path2.extname(filePath).toLowerCase());
+}
+async function buildImportGraph(input) {
+  const projectRoot = path2.resolve(input.projectRoot);
+  const queue = input.entryFiles.map((filePath) => path2.resolve(filePath));
+  const visited = /* @__PURE__ */ new Set();
+  const internalFiles = /* @__PURE__ */ new Set();
+  const externalPackages = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const currentFilePath = queue.shift();
+    if (!currentFilePath || visited.has(currentFilePath)) {
+      continue;
+    }
+    visited.add(currentFilePath);
+    internalFiles.add(currentFilePath);
+    if (!shouldParseFile(currentFilePath)) {
+      continue;
+    }
+    let content = "";
+    try {
+      content = await readFile(currentFilePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const specifiers = collectSpecifiers(content);
+    for (const specifier of specifiers) {
+      const resolved = await resolveImportToFile(
+        projectRoot,
+        currentFilePath,
+        specifier
+      );
+      if (resolved.kind === "internal") {
+        if (!visited.has(resolved.filePath)) {
+          queue.push(resolved.filePath);
+        }
+        continue;
+      }
+      if (resolved.kind === "external") {
+        externalPackages.add(resolved.packageName);
+      }
+    }
+  }
+  return {
+    internalFiles: [...internalFiles].sort(),
+    externalPackages: [...externalPackages].sort()
+  };
+}
+
+// src/lib/page-paths.ts
+var WEBSITE_APP_ROOT = "src/app/(website)";
+var PAGE_COMPONENTS_ROOT = "src/components/pages";
+var normalizeSlug = (slug) => {
+  const trimmed = slug.trim();
+  if (!trimmed || trimmed === "/") {
+    return "/";
+  }
+  const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  const withoutTrailingSlash = withLeadingSlash.replace(/\/+$/, "");
+  return withoutTrailingSlash || "/";
+};
+var slugToFolderPath = (normalizedSlug) => {
+  if (normalizedSlug === "/") {
+    return "";
+  }
+  return normalizedSlug.slice(1);
+};
+var toPathSegment = (value) => {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9/-]+/g, "-");
+  const compact = normalized.replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return compact || "page";
+};
+var buildWebsitePagePath = (normalizedSlug) => {
+  if (normalizedSlug === "/") {
+    return `${WEBSITE_APP_ROOT}/page.tsx`;
+  }
+  return `${WEBSITE_APP_ROOT}${normalizedSlug}/page.tsx`;
+};
+var buildComponentsPath = (folderPath) => `${PAGE_COMPONENTS_ROOT}/${folderPath}`;
+var resolveBlogSectionRoot = (slugFolderPath) => {
+  if (!slugFolderPath) {
+    return "blog";
+  }
+  const segments = slugFolderPath.split("/").filter(Boolean);
+  if (segments.length <= 1) {
+    return "blog";
+  }
+  return segments.slice(0, -1).join("/");
+};
+function resolvePrimeUiPageExportPaths({
+  pageType,
+  slug
+}) {
+  const normalizedSlug = normalizeSlug(slug);
+  const slugFolderPath = slugToFolderPath(normalizedSlug);
+  switch (pageType) {
+    case "landing": {
+      const componentsFolder = slugFolderPath || "home";
+      return {
+        pagePath: buildWebsitePagePath(normalizedSlug),
+        componentsPath: buildComponentsPath(componentsFolder)
+      };
+    }
+    case "pricing":
+    case "contact-us": {
+      const componentsFolder = slugFolderPath || pageType;
+      return {
+        pagePath: buildWebsitePagePath(normalizedSlug),
+        componentsPath: buildComponentsPath(componentsFolder)
+      };
+    }
+    case "docs": {
+      const docsFolder = slugFolderPath || "docs";
+      return {
+        pagePath: `${WEBSITE_APP_ROOT}/${docsFolder}/[[...slug]]/page.tsx`,
+        componentsPath: buildComponentsPath("docs")
+      };
+    }
+    case "blogIndex": {
+      const blogFolder = slugFolderPath || "blog";
+      return {
+        pagePath: `${WEBSITE_APP_ROOT}/${blogFolder}/page.tsx`,
+        componentsPath: buildComponentsPath("blog")
+      };
+    }
+    case "blogPost": {
+      const blogSectionRoot = resolveBlogSectionRoot(slugFolderPath);
+      return {
+        pagePath: `${WEBSITE_APP_ROOT}/${blogSectionRoot}/[slug]/page.tsx`,
+        componentsPath: buildComponentsPath("blog")
+      };
+    }
+    case "legal":
+      return {
+        pagePath: buildWebsitePagePath(normalizedSlug),
+        componentsPath: buildComponentsPath("legal")
+      };
+    default: {
+      const fallbackFolder = slugFolderPath || toPathSegment(pageType);
+      return {
+        pagePath: buildWebsitePagePath(normalizedSlug),
+        componentsPath: buildComponentsPath(fallbackFolder)
+      };
+    }
+  }
+}
+
+// src/lib/text-diff.ts
+var DEFAULT_MAX_DIFF_CHARS = 16e3;
+var MAX_LCS_CELLS = 2e6;
+function computeOps(oldLines, newLines) {
+  const oldLength = oldLines.length;
+  const newLength = newLines.length;
+  const table = Array.from(
+    { length: oldLength + 1 },
+    () => Array(newLength + 1).fill(0)
+  );
+  for (let i2 = oldLength - 1; i2 >= 0; i2 -= 1) {
+    for (let j2 = newLength - 1; j2 >= 0; j2 -= 1) {
+      if (oldLines[i2] === newLines[j2]) {
+        table[i2][j2] = table[i2 + 1][j2 + 1] + 1;
+      } else {
+        table[i2][j2] = Math.max(table[i2 + 1][j2], table[i2][j2 + 1]);
+      }
+    }
+  }
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < oldLength && j < newLength) {
+    if (oldLines[i] === newLines[j]) {
+      ops.push({ kind: "equal", value: oldLines[i] ?? "" });
+      i += 1;
+      j += 1;
+      continue;
+    }
+    if (table[i + 1][j] >= table[i][j + 1]) {
+      ops.push({ kind: "delete", value: oldLines[i] ?? "" });
+      i += 1;
+      continue;
+    }
+    ops.push({ kind: "insert", value: newLines[j] ?? "" });
+    j += 1;
+  }
+  while (i < oldLength) {
+    ops.push({ kind: "delete", value: oldLines[i] ?? "" });
+    i += 1;
+  }
+  while (j < newLength) {
+    ops.push({ kind: "insert", value: newLines[j] ?? "" });
+    j += 1;
+  }
+  return ops;
+}
+function buildUnifiedDiff(input) {
+  const maxChars = input.maxChars ?? DEFAULT_MAX_DIFF_CHARS;
+  if (input.oldText === input.newText) {
+    return "";
+  }
+  const oldLines = input.oldText.split(/\r?\n/);
+  const newLines = input.newText.split(/\r?\n/);
+  const cells = (oldLines.length + 1) * (newLines.length + 1);
+  if (cells > MAX_LCS_CELLS) {
+    return [
+      `--- ${input.oldLabel}`,
+      `+++ ${input.newLabel}`,
+      "@@ diff omitted @@",
+      "Diff is too large to render safely."
+    ].join("\n");
+  }
+  const ops = computeOps(oldLines, newLines);
+  const output = [
+    `--- ${input.oldLabel}`,
+    `+++ ${input.newLabel}`,
+    `@@ -1,${oldLines.length} +1,${newLines.length} @@`
+  ];
+  for (const op of ops) {
+    if (op.kind === "equal") {
+      output.push(` ${op.value}`);
+      continue;
+    }
+    if (op.kind === "delete") {
+      output.push(`-${op.value}`);
+      continue;
+    }
+    output.push(`+${op.value}`);
+  }
+  const diff = output.join("\n");
+  if (diff.length <= maxChars) {
+    return diff;
+  }
+  return `${diff.slice(0, maxChars)}
+... [diff truncated]`;
+}
+
+// src/services/page-copy-service.ts
+var DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies"
+];
+var REWRITABLE_IMPORT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+]);
+function normalizeSlug2(slug) {
+  const trimmed = slug.trim();
+  if (!trimmed || trimmed === "/") {
+    return "/";
+  }
+  const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  return withLeadingSlash.replace(/\/+$/, "") || "/";
+}
+function toPosixPath(value) {
+  return value.split(path3.sep).join("/");
+}
+function toProjectRelative(rootPath, absolutePath) {
+  return toPosixPath(path3.relative(rootPath, absolutePath));
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isBinaryBuffer(buffer) {
+  const limit = Math.min(buffer.length, 8e3);
+  for (let index = 0; index < limit; index += 1) {
+    if (buffer[index] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function stripSrcPrefix(relativePath) {
+  return relativePath.replace(/^src\//, "");
+}
+function buildImportRewritePlan(sourceComponentsPath, targetComponentsPath) {
+  const normalizedSource = toPosixPath(sourceComponentsPath);
+  const normalizedTarget = toPosixPath(targetComponentsPath);
+  if (normalizedSource === normalizedTarget) {
+    return null;
+  }
+  const sourceAtAliasPrefix = `@/${stripSrcPrefix(normalizedSource)}`;
+  const targetAtAliasPrefix = `@/${stripSrcPrefix(normalizedTarget)}`;
+  const sourceRootAliasPrefix = `@root/${normalizedSource}`;
+  const targetRootAliasPrefix = `@root/${normalizedTarget}`;
+  return {
+    sourceAtAliasPrefix,
+    targetAtAliasPrefix,
+    sourceRootAliasPrefix,
+    targetRootAliasPrefix
+  };
+}
+function replaceAliasPrefixInImportStrings(content, sourcePrefix, targetPrefix) {
+  const pattern = new RegExp(
+    `(["'\`])${escapeRegExp(sourcePrefix)}(?=\\/|\\1)`,
+    "g"
+  );
+  return content.replace(pattern, `$1${targetPrefix}`);
+}
+function rewriteImportsForRemappedSlug(content, plan) {
+  const afterAtAlias = replaceAliasPrefixInImportStrings(
+    content,
+    plan.sourceAtAliasPrefix,
+    plan.targetAtAliasPrefix
+  );
+  return replaceAliasPrefixInImportStrings(
+    afterAtAlias,
+    plan.sourceRootAliasPrefix,
+    plan.targetRootAliasPrefix
+  );
+}
+function buildPlannedSourceBuffer(sourceBuffer, sourceFilePath, importRewritePlan) {
+  if (!importRewritePlan) {
+    return sourceBuffer;
+  }
+  const extension = path3.extname(sourceFilePath).toLowerCase();
+  if (!REWRITABLE_IMPORT_EXTENSIONS.has(extension)) {
+    return sourceBuffer;
+  }
+  if (isBinaryBuffer(sourceBuffer)) {
+    return sourceBuffer;
+  }
+  const sourceText = sourceBuffer.toString("utf-8");
+  const rewritten = rewriteImportsForRemappedSlug(sourceText, importRewritePlan);
+  if (rewritten === sourceText) {
+    return sourceBuffer;
+  }
+  return Buffer.from(rewritten, "utf-8");
+}
+async function readJsonFile(filePath) {
+  const content = await readFile2(filePath, "utf-8");
+  return JSON.parse(content);
+}
+async function fileExists(filePath) {
+  try {
+    await stat2(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isPageRecord(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const maybe = value;
+  return typeof maybe.id === "string" && typeof maybe.title === "string" && typeof maybe.slug === "string" && typeof maybe.pageType === "string" && typeof maybe.isReadyToExport === "boolean" && typeof maybe.pagePath === "string" && typeof maybe.componentsPath === "string";
+}
+function parseManifest(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error("Invalid export manifest format.");
+  }
+  const maybe = value;
+  if (maybe.schemaVersion !== 1 || typeof maybe.generatedAt !== "string" || typeof maybe.exportId !== "string" || typeof maybe.projectPath !== "string" || !Array.isArray(maybe.pages)) {
+    throw new Error("Export manifest does not match expected schema.");
+  }
+  if (!maybe.pages.every(isPageRecord)) {
+    throw new Error("Export manifest pages payload is invalid.");
+  }
+  return {
+    schemaVersion: 1,
+    generatedAt: maybe.generatedAt,
+    exportId: maybe.exportId,
+    projectPath: maybe.projectPath,
+    pages: maybe.pages
+  };
+}
+async function listFilesRecursively(dirPath) {
+  const files = [];
+  const stack = [dirPath];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) {
+      continue;
+    }
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = path3.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(absolutePath);
+        continue;
+      }
+      if (entry.isFile()) {
+        files.push(absolutePath);
+      }
+    }
+  }
+  return files;
+}
+async function resolveSingleExportDirectory(exportsRoot) {
+  const entries = await readdir(exportsRoot, { withFileTypes: true });
+  const exportDirectories = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+  if (exportDirectories.length === 0) {
+    throw new Error(
+      "No downloaded exports found in .primeui/temp/exports. Run primeui_download_export first."
+    );
+  }
+  if (exportDirectories.length > 1) {
+    throw new Error(
+      "Multiple export folders found in .primeui/temp/exports. Clear temp with primeui_clear_temp and download one export."
+    );
+  }
+  const exportId = exportDirectories[0] ?? "";
+  return {
+    exportId,
+    exportPath: path3.join(exportsRoot, exportId)
+  };
+}
+function ensureSafeTargetPath(projectRoot, targetPath) {
+  const relative = path3.relative(projectRoot, targetPath);
+  if (relative.startsWith("..") || path3.isAbsolute(relative)) {
+    throw new Error(
+      `Refusing to write outside project root. Computed target: ${targetPath}`
+    );
+  }
+}
+function getDependencyVersion(packageJson, packageName) {
+  for (const section of DEPENDENCY_SECTIONS) {
+    const sectionData = packageJson[section];
+    if (!sectionData || typeof sectionData !== "object") {
+      continue;
+    }
+    const value = sectionData[packageName];
+    if (typeof value === "string") {
+      return {
+        section,
+        version: value
+      };
+    }
+  }
+  return null;
+}
+function getOrCreateDependencySection(packageJson, section) {
+  const existing = packageJson[section];
+  if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+    const created = {};
+    packageJson[section] = created;
+    return created;
+  }
+  return existing;
+}
+function sortDependencySections(packageJson) {
+  for (const section of DEPENDENCY_SECTIONS) {
+    const sectionData = packageJson[section];
+    if (!sectionData || typeof sectionData !== "object" || Array.isArray(sectionData)) {
+      continue;
+    }
+    const sorted = Object.fromEntries(
+      Object.entries(sectionData).sort(
+        ([a], [b]) => a.localeCompare(b)
+      )
+    );
+    packageJson[section] = sorted;
+  }
+}
+function resolveTargetFilePath(input) {
+  const {
+    sourceFilePath,
+    sourcePagePath,
+    sourceComponentsPath,
+    targetPagePath,
+    targetComponentsPath,
+    exportRoot,
+    projectRoot
+  } = input;
+  if (sourceFilePath === sourcePagePath) {
+    return targetPagePath;
+  }
+  const componentsPrefix = `${sourceComponentsPath}${path3.sep}`;
+  if (sourceFilePath === sourceComponentsPath || sourceFilePath.startsWith(componentsPrefix)) {
+    const relativeToComponents = path3.relative(
+      sourceComponentsPath,
+      sourceFilePath
+    );
+    return path3.join(targetComponentsPath, relativeToComponents);
+  }
+  const relativeToExport = path3.relative(exportRoot, sourceFilePath);
+  if (relativeToExport.startsWith("..") || path3.isAbsolute(relativeToExport)) {
+    throw new Error(`Source file is outside export root: ${sourceFilePath}`);
+  }
+  return path3.join(projectRoot, relativeToExport);
+}
+async function copyPageFromExport(input) {
+  const normalizedOriginSlug = normalizeSlug2(input.originPageSlug);
+  const normalizedActualSlug = normalizeSlug2(
+    input.actualPageSlug ?? input.originPageSlug
+  );
+  const isSlugRemapped = normalizedActualSlug !== normalizedOriginSlug;
+  const { exportId, exportPath } = await resolveSingleExportDirectory(
+    input.exportsRoot
+  );
+  const manifestPath = path3.join(
+    input.exportsRoot,
+    `${exportId}.manifest.json`
+  );
+  if (!await fileExists(manifestPath)) {
+    throw new Error(
+      `Export manifest is missing at ${manifestPath}. Run primeui_download_export to regenerate it.`
+    );
+  }
+  const manifest = parseManifest(await readJsonFile(manifestPath));
+  if (manifest.exportId !== exportId) {
+    throw new Error(
+      `Manifest exportId mismatch: expected ${exportId}, got ${manifest.exportId}. Re-download export.`
+    );
+  }
+  const page = manifest.pages.find(
+    (item) => normalizeSlug2(item.slug) === normalizedOriginSlug
+  );
+  if (!page) {
+    throw new Error(
+      `Page not found in manifest for slug: ${normalizedOriginSlug}`
+    );
+  }
+  const sourcePagePath = path3.join(exportPath, page.pagePath);
+  const sourceComponentsPath = path3.join(exportPath, page.componentsPath);
+  const sourcePageStats = await stat2(sourcePagePath).catch(() => null);
+  if (!sourcePageStats?.isFile()) {
+    throw new Error(`Source page file not found: ${sourcePagePath}`);
+  }
+  const sourceComponentsStats = await stat2(sourceComponentsPath).catch(
+    () => null
+  );
+  if (!sourceComponentsStats?.isDirectory()) {
+    throw new Error(
+      `Source components folder not found: ${sourceComponentsPath}`
+    );
+  }
+  const targetPaths = normalizedActualSlug === normalizedOriginSlug ? {
+    pagePath: page.pagePath,
+    componentsPath: page.componentsPath
+  } : resolvePrimeUiPageExportPaths({
+    pageType: page.pageType,
+    slug: normalizedActualSlug
+  });
+  const targetPagePath = path3.join(input.projectRoot, targetPaths.pagePath);
+  const targetComponentsPath = path3.join(
+    input.projectRoot,
+    targetPaths.componentsPath
+  );
+  const importRewritePlan = isSlugRemapped ? buildImportRewritePlan(page.componentsPath, targetPaths.componentsPath) : null;
+  ensureSafeTargetPath(input.projectRoot, targetPagePath);
+  ensureSafeTargetPath(input.projectRoot, targetComponentsPath);
+  const componentFiles = await listFilesRecursively(sourceComponentsPath);
+  const seedFiles = [sourcePagePath, ...componentFiles];
+  const importGraph = await buildImportGraph({
+    projectRoot: exportPath,
+    entryFiles: seedFiles
+  });
+  const candidateFiles = [...new Set(importGraph.internalFiles)].sort(
+    (a, b) => a.localeCompare(b)
+  );
+  const newFiles = [];
+  const identicalFiles = [];
+  const conflictFiles = [];
+  for (const sourceFilePath of candidateFiles) {
+    const targetFilePath = resolveTargetFilePath({
+      sourceFilePath,
+      sourcePagePath,
+      sourceComponentsPath,
+      targetPagePath,
+      targetComponentsPath,
+      exportRoot: exportPath,
+      projectRoot: input.projectRoot
+    });
+    ensureSafeTargetPath(input.projectRoot, targetFilePath);
+    const sourceBuffer = await readFile2(sourceFilePath);
+    const plannedSourceBuffer = buildPlannedSourceBuffer(
+      sourceBuffer,
+      sourceFilePath,
+      importRewritePlan
+    );
+    let targetBuffer = null;
+    try {
+      targetBuffer = await readFile2(targetFilePath);
+    } catch {
+      targetBuffer = null;
+    }
+    const sourceRelative = toProjectRelative(exportPath, sourceFilePath);
+    const targetRelative = toProjectRelative(input.projectRoot, targetFilePath);
+    if (!targetBuffer) {
+      await ensureDir(path3.dirname(targetFilePath));
+      await writeFile2(targetFilePath, plannedSourceBuffer);
+      newFiles.push({
+        sourcePath: sourceRelative,
+        targetPath: targetRelative
+      });
+      continue;
+    }
+    if (plannedSourceBuffer.equals(targetBuffer)) {
+      identicalFiles.push({
+        sourcePath: sourceRelative,
+        targetPath: targetRelative
+      });
+      continue;
+    }
+    const isBinary = isBinaryBuffer(plannedSourceBuffer) || isBinaryBuffer(targetBuffer);
+    const diff = isBinary ? "Binary files differ." : buildUnifiedDiff({
+      oldText: targetBuffer.toString("utf-8"),
+      newText: plannedSourceBuffer.toString("utf-8"),
+      oldLabel: `user/${targetRelative}`,
+      newLabel: `export/${sourceRelative}`
+    });
+    conflictFiles.push({
+      sourcePath: sourceRelative,
+      targetPath: targetRelative,
+      diff,
+      isBinary
+    });
+  }
+  const exportPackageJsonPath = path3.join(exportPath, "package.json");
+  const userPackageJsonPath = path3.join(input.projectRoot, "package.json");
+  if (!await fileExists(exportPackageJsonPath)) {
+    throw new Error(`Export package.json not found: ${exportPackageJsonPath}`);
+  }
+  if (!await fileExists(userPackageJsonPath)) {
+    throw new Error(`User package.json not found: ${userPackageJsonPath}`);
+  }
+  const exportPackageJson = await readJsonFile(
+    exportPackageJsonPath
+  );
+  const userPackageJson = await readJsonFile(userPackageJsonPath);
+  const addedDependencies = [];
+  const dependenciesVersionConflicts = [];
+  for (const packageName of importGraph.externalPackages) {
+    const exportDependency = getDependencyVersion(
+      exportPackageJson,
+      packageName
+    );
+    if (!exportDependency) {
+      continue;
+    }
+    const userDependency = getDependencyVersion(userPackageJson, packageName);
+    if (!userDependency) {
+      const sectionData = getOrCreateDependencySection(
+        userPackageJson,
+        exportDependency.section
+      );
+      sectionData[packageName] = exportDependency.version;
+      addedDependencies.push({
+        packageName,
+        version: exportDependency.version,
+        section: exportDependency.section
+      });
+      continue;
+    }
+    if (userDependency.version !== exportDependency.version) {
+      dependenciesVersionConflicts.push({
+        packageName,
+        section: exportDependency.section,
+        exportVersion: exportDependency.version,
+        userVersion: userDependency.version
+      });
+    }
+  }
+  if (addedDependencies.length > 0) {
+    sortDependencySections(userPackageJson);
+    await writeFile2(
+      userPackageJsonPath,
+      `${JSON.stringify(userPackageJson, null, 2)}
+`,
+      "utf-8"
+    );
+  }
+  return {
+    exportId,
+    exportPath,
+    originPageSlug: normalizedOriginSlug,
+    actualPageSlug: normalizedActualSlug,
+    sourcePagePath: page.pagePath,
+    targetPagePath: targetPaths.pagePath,
+    sourceComponentsPath: page.componentsPath,
+    targetComponentsPath: targetPaths.componentsPath,
+    newFiles,
+    identicalFiles,
+    conflictFiles,
+    addedDependencies: addedDependencies.sort(
+      (a, b) => a.packageName.localeCompare(b.packageName)
+    ),
+    dependenciesVersionConflicts: dependenciesVersionConflicts.sort(
+      (a, b) => a.packageName.localeCompare(b.packageName)
+    ),
+    summary: {
+      totalCandidateFiles: candidateFiles.length,
+      copiedFiles: newFiles.length,
+      identicalFiles: identicalFiles.length,
+      conflictFiles: conflictFiles.length,
+      addedDependencies: addedDependencies.length,
+      dependenciesVersionConflicts: dependenciesVersionConflicts.length
+    }
+  };
+}
+
+// src/services/project-sync-service.ts
+function isProjectPage(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const maybe = value;
+  return typeof maybe.id === "string" && typeof maybe.title === "string" && typeof maybe.slug === "string" && typeof maybe.pageType === "string" && typeof maybe.isReadyToExport === "boolean" && typeof maybe.pagePath === "string" && typeof maybe.componentsPath === "string";
+}
+function buildPagesSnapshotPath(exportsRoot, exportId) {
+  return path4.join(exportsRoot, `${exportId}.pages.snapshot.json`);
+}
+function parsePagesSnapshot(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error("Export pages snapshot is invalid.");
+  }
+  const maybe = value;
+  if (maybe.schemaVersion !== 1 || typeof maybe.generatedAt !== "string" || typeof maybe.exportId !== "string" || !Array.isArray(maybe.pages)) {
+    throw new Error("Export pages snapshot does not match expected schema.");
+  }
+  if (!maybe.pages.every(isProjectPage)) {
+    throw new Error("Export pages snapshot has invalid pages payload.");
+  }
+  return {
+    schemaVersion: 1,
+    generatedAt: maybe.generatedAt,
+    exportId: maybe.exportId,
+    pages: maybe.pages
+  };
+}
+var ProjectSyncService = class {
+  provider;
+  projectRoot;
+  primeUiRoot;
+  tempRoot;
+  exportsRoot;
+  constructor(options) {
+    this.projectRoot = options.projectRoot;
+    this.provider = options.provider;
+    this.primeUiRoot = path4.join(this.projectRoot, ".primeui");
+    this.tempRoot = path4.join(this.primeUiRoot, "temp");
+    this.exportsRoot = path4.join(this.tempRoot, "exports");
+  }
+  async getProjectInfo() {
+    await this.ensureTempLayout();
+    return this.provider.getProjectInfo();
+  }
+  async listExports() {
+    await this.ensureTempLayout();
+    return this.provider.listExports();
+  }
+  async createExport() {
+    await this.ensureTempLayout();
+    const result = await this.provider.createExport();
+    const pagesSnapshotPath = buildPagesSnapshotPath(
+      this.exportsRoot,
+      result.export.id
+    );
+    const snapshot = {
+      schemaVersion: 1,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      exportId: result.export.id,
+      pages: result.pages
+    };
+    await writeUtf8(
+      pagesSnapshotPath,
+      `${JSON.stringify(snapshot, null, 2)}
+`
+    );
+    return result;
+  }
+  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}`);
+    }
+    const targetZipPath = path4.join(this.exportsRoot, `${id}.zip`);
+    const targetProjectPath = path4.join(this.exportsRoot, id);
+    await ensureDir(this.exportsRoot);
+    await this.provider.downloadExportArchive(id, targetZipPath);
+    await resetDir(targetProjectPath);
+    await extractZip(targetZipPath, targetProjectPath);
+    const pagesSnapshotPath = buildPagesSnapshotPath(this.exportsRoot, id);
+    let pagesSnapshot;
+    try {
+      const snapshotRaw = JSON.parse(
+        await readFile3(pagesSnapshotPath, "utf-8")
+      );
+      pagesSnapshot = parsePagesSnapshot(snapshotRaw);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Export pages snapshot is required for download id "${id}". Run primeui_create_export for this export before downloading. Details: ${reason}`
+      );
+    }
+    if (pagesSnapshot.exportId !== id) {
+      throw new Error(
+        `Export pages snapshot mismatch for id "${id}". Run primeui_create_export and retry download.`
+      );
+    }
+    const pages = pagesSnapshot.pages;
+    const manifestPath = path4.join(this.exportsRoot, `${id}.manifest.json`);
+    const manifest = {
+      schemaVersion: 1,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      exportId: id,
+      projectPath: targetProjectPath,
+      pages
+    };
+    await writeUtf8(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+    return {
+      exportId: id,
+      projectPath: targetProjectPath,
+      manifestPath,
+      pages
+    };
+  }
+  async copyPage(originPageSlug, actualPageSlug) {
+    await this.ensureTempLayout();
+    return copyPageFromExport({
+      projectRoot: this.projectRoot,
+      exportsRoot: this.exportsRoot,
+      originPageSlug,
+      actualPageSlug
+    });
+  }
+  async clearTemp() {
+    await resetDir(this.tempRoot);
+    await writeUtf8(path4.join(this.tempRoot, ".gitkeep"), "");
+    await ensureDir(this.exportsRoot);
+  }
+  async ensureTempLayout() {
+    await ensureDir(this.primeUiRoot);
+    await ensureDir(this.tempRoot);
+    await ensureDir(this.exportsRoot);
+    await writeUtf8(path4.join(this.tempRoot, ".gitkeep"), "");
+  }
+};
+
+// src/sources/api-provider.ts
+import { createWriteStream } from "fs";
+import { unlink } from "fs/promises";
+import path5 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 exportStatusSchema2 = z2.enum(["in_progress", "completed", "failed"]);
+var projectPageSchema = z2.object({
+  id: z2.string(),
+  title: z2.string(),
+  slug: z2.string(),
+  pageType: z2.string(),
+  isReadyToExport: z2.boolean(),
+  pagePath: z2.string(),
+  componentsPath: z2.string()
+});
+var projectInfoSchema = z2.object({
+  projectId: z2.string(),
+  projectName: z2.string(),
+  metadata: z2.record(z2.unknown()),
+  pages: z2.array(projectPageSchema)
+});
+var exportsResponseSchema = z2.object({
+  exports: z2.array(
+    z2.object({
+      id: z2.string(),
+      status: exportStatusSchema2,
+      createdAt: z2.string().datetime({ offset: true })
+    })
+  )
+});
+var createExportResponseSchema = z2.object({
+  export: z2.object({
+    id: z2.string(),
+    status: exportStatusSchema2
+  }),
+  pages: z2.array(projectPageSchema)
+});
+var PrimeUiApiContractError = class extends Error {
+  constructor(endpoint, details) {
+    super(`PrimeUI API contract mismatch for "${endpoint}": ${details}`);
+    this.name = "PrimeUiApiContractError";
+  }
+};
+var normalizeApiRoot = (rawBaseUrl) => {
+  const normalizedBase = rawBaseUrl.trim() || DEFAULT_API_BASE_URL;
+  const parsed = new URL(normalizedBase);
+  const normalizedPath = parsed.pathname.replace(/\/+$/, "");
+  if (normalizedPath.endsWith("/api/v1")) {
+    parsed.pathname = `${normalizedPath}/`;
+    return parsed.toString();
+  }
+  parsed.pathname = `${normalizedPath}/api/v1/`.replace(
+    "//api/v1/",
+    "/api/v1/"
+  );
+  return parsed.toString();
+};
+var isJsonContentType = (contentType) => contentType.includes("application/json") || contentType.includes("+json");
+var isZipContentType = (contentType) => ZIP_CONTENT_TYPES.some((allowedType) => contentType.includes(allowedType));
+var looksLikeZipArchive = (buffer) => {
+  if (buffer.length < 4) {
+    return false;
+  }
+  if (buffer[0] !== 80 || buffer[1] !== 75) {
+    return false;
+  }
+  const signature = `${buffer[2]}:${buffer[3]}`;
+  return signature === "3:4" || signature === "5:6" || signature === "7:8";
+};
+var createZipSignatureGuard = (endpoint) => {
+  let signature = Buffer.alloc(0);
+  let validated = false;
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      if (!validated) {
+        const requiredBytes = Math.max(0, 4 - signature.length);
+        if (requiredBytes > 0) {
+          signature = Buffer.concat([
+            signature,
+            chunkBuffer.subarray(0, requiredBytes)
+          ]);
+        }
+        if (signature.length >= 4) {
+          if (!looksLikeZipArchive(signature)) {
+            callback(
+              new PrimeUiApiContractError(
+                endpoint,
+                "response body is not a valid zip archive"
+              )
+            );
+            return;
+          }
+          validated = true;
+        }
+      }
+      callback(null, chunkBuffer);
+    },
+    flush(callback) {
+      if (!validated) {
+        callback(
+          new PrimeUiApiContractError(
+            endpoint,
+            "response body is not a valid zip archive"
+          )
+        );
+        return;
+      }
+      callback();
+    }
+  });
+};
+var ApiProjectDataProvider = class {
+  apiKey;
+  apiRoot;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.apiRoot = normalizeApiRoot(options.baseUrl ?? DEFAULT_API_BASE_URL);
+  }
+  async getProjectInfo() {
+    return this.requestJson("project", projectInfoSchema);
+  }
+  async listExports() {
+    const response = await this.requestJson(
+      "project/exports",
+      exportsResponseSchema
+    );
+    return response.exports;
+  }
+  async createExport() {
+    return this.requestJson("project/exports", createExportResponseSchema, {
+      method: "POST"
+    });
+  }
+  /**
+   * Consumer-side runtime contract for GET /api/v1/project/exports/:exportId/download.
+   * Producer source of truth: apps/studio/src/app/api/v1/project/exports/[exportId]/download/route.ts
+   * Keep content-type and archive format checks synchronized with the producer response.
+   */
+  async downloadExportArchive(exportId, destinationPath) {
+    const endpoint = `project/exports/${encodeURIComponent(exportId)}/download`;
+    const apiKey = this.requireApiKey();
+    const response = await fetch(this.buildUrl(endpoint), {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      const details = await this.readError(response);
+      throw new Error(
+        `PrimeUI API request failed (${response.status}) while downloading export "${exportId}": ${details}`
+      );
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!isZipContentType(contentType)) {
+      throw new PrimeUiApiContractError(
+        endpoint,
+        `expected zip content-type but got "${contentType || "unknown"}"`
+      );
+    }
+    if (!response.body) {
+      throw new PrimeUiApiContractError(endpoint, "response body is empty");
+    }
+    await ensureDir(path5.dirname(destinationPath));
+    const zipStream = Readable.fromWeb(
+      response.body
+    );
+    const signatureGuard = createZipSignatureGuard(endpoint);
+    const fileStream = createWriteStream(destinationPath);
+    try {
+      await pipeline(zipStream, signatureGuard, fileStream);
+    } catch (error) {
+      await unlink(destinationPath).catch(() => void 0);
+      throw error;
+    }
+  }
+  buildUrl(endpoint) {
+    return new URL(endpoint, this.apiRoot).toString();
+  }
+  async requestJson(endpoint, schema, requestInit = {}) {
+    const apiKey = this.requireApiKey();
+    const method = requestInit.method ?? "GET";
+    const response = await fetch(this.buildUrl(endpoint), {
+      ...requestInit,
+      method,
+      headers: {
+        ...requestInit.headers ?? {},
+        Authorization: `Bearer ${apiKey}`
+      }
     });
+    if (!response.ok) {
+      const details = await this.readError(response);
+      throw new Error(
+        `PrimeUI API request failed (${response.status}) for "${endpoint}": ${details}`
+      );
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!isJsonContentType(contentType)) {
+      throw new PrimeUiApiContractError(
+        endpoint,
+        `expected JSON content-type but got "${contentType || "unknown"}"`
+      );
+    }
+    let payload;
+    try {
+      payload = await response.json();
+    } catch {
+      throw new PrimeUiApiContractError(
+        endpoint,
+        "response body is not valid JSON"
+      );
+    }
+    const parsed = schema.safeParse(payload);
+    if (!parsed.success) {
+      const details = parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
+      throw new PrimeUiApiContractError(endpoint, details);
+    }
+    return parsed.data;
+  }
+  async readError(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    try {
+      if (isJsonContentType(contentType)) {
+        const body = await response.json();
+        if (body?.message && body?.code) {
+          return `${body.code}: ${body.message}`;
+        }
+        if (body?.message) {
+          return body.message;
+        }
+      } else {
+        const bodyText = await response.text();
+        if (bodyText.trim()) {
+          return bodyText.trim();
+        }
+      }
+    } catch {
+    }
+    return response.statusText || "Unknown error";
+  }
+  requireApiKey() {
+    const apiKey = this.apiKey?.trim();
     if (!apiKey) {
-        console.error("[primeui-mcp] warning: PRIMEUI_API_KEY is not set; API-backed tools will fail until it is configured.");
+      throw new Error("PRIMEUI_API_KEY is required to call PrimeUI API tools.");
     }
-    const syncService = new ProjectSyncService({ projectRoot, provider });
-    const server = createPrimeUiMcpServer(syncService);
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error(`[primeui-mcp] running for root: ${projectRoot}`);
+    return apiKey;
+  }
+};
+
+// src/service.ts
+async function main() {
+  const projectRoot = process.env.PRIMEUI_PROJECT_ROOT || process.cwd();
+  const apiKey = process.env.PRIMEUI_API_KEY;
+  const provider = new ApiProjectDataProvider({
+    apiKey,
+    baseUrl: process.env.PRIMEUI_API_BASE_URL
+  });
+  if (!apiKey) {
+    console.error(
+      "[primeui-mcp] warning: PRIMEUI_API_KEY is not set; API-backed tools will fail until it is configured."
+    );
+  }
+  const syncService = new ProjectSyncService({ projectRoot, provider });
+  const server = createPrimeUiMcpServer(syncService);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`[primeui-mcp] running for root: ${projectRoot}`);
 }
 main().catch((error) => {
-    console.error("[primeui-mcp] failed to start", error);
-    process.exit(1);
+  console.error("[primeui-mcp] failed to start", error);
+  process.exit(1);
 });
 //# sourceMappingURL=service.js.map