@shippp/mcp 0.1.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shippp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,6 @@
 # @shippp/mcp
 
-Pull production-perfect Chakra UI code from your Shippp design files straight into your IDE agent (Claude Code, Cursor, …).
+Pull production-perfect UI code from your Shippp design files straight into your IDE agent (Claude Code, Cursor, …), and keep a repository current over the official receipt-tracked sync.
 
 ## Setup
 
@@ -34,5 +34,37 @@ Pull production-perfect Chakra UI code from your Shippp design files straight in
 | `shippp_get_design_system` | The whole design system as a package. |
 | `shippp_get_project` | The whole file as a runnable Next.js project. |
 | `shippp_diff` | Your current code vs a fresh generation. |
+| `shippp_sync_plan` | Deterministic sync plan for the bound repository — no writes. |
+| `shippp_sync_apply` | The full sync run: artifact → plan → apply → checks → receipt. |
 
-Read-only. The server never modifies your design.
+The server never modifies your design. The sync tools write ONLY under the
+generated root recorded in the repo's own committed `shippp.target.json`
+binding (created with `shippp_bind_repository` on the Shippp remote MCP):
+hand-modified generated files are structured conflicts and are never
+overwritten, a failed check rolls everything back, and the receipt is written
+only on full success. A compiler/IR/adapter upgrade needs the user's explicit
+approval of the exact delta.
+
+## Repository sync (CLI)
+
+The same deterministic runner ships as a CLI:
+
+```bash
+# preview (no writes)
+SHIPPP_API_KEY=sk_... npx @shippp/mcp plan --root .
+
+# full sync: apply + checks + receipt, with rollback
+SHIPPP_API_KEY=sk_... npx @shippp/mcp sync --root . --check "npm run typecheck"
+```
+
+Flags: `--root <repo>` (default: cwd), `--check <cmd>` (repeatable; runs after
+apply, before the receipt), `--allow-compiler-upgrade` (explicit consent to a
+pending compiler/IR/adapter delta), `--accept-rebound-baseline` (adopt the
+previous binding's receipt as baseline after an approved re-bind). In server
+mode the repo root comes from `SHIPPP_REPO_ROOT` (or the server's cwd) and the
+check command from `SHIPPP_SYNC_CHECKS` — developer configuration, never tool
+input. Exit codes: `0` success, `2` structured refusal, `1` error.
+
+## MCP Registry
+
+Published to the official MCP Registry as `ai.shippp/mcp`.

package/dist/index.js

@@ -1,20 +1,812 @@
 #!/usr/bin/env node
+
+// src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { loadConfig } from "./config.js";
-import { ShipppClient } from "./client.js";
-import { registerTools } from "./tools.js";
-const INSTRUCTIONS = `Shippp exposes DETERMINISTIC, production-perfect Chakra UI code from a designer's Shippp file. Everything returned is GENERATED (never guessed) and reproducible — the same source always yields the same code + hash (see each result's receipt).
 
-Workflow: call shippp_list_units first to discover screen/master ids, then pull code with shippp_get_component / shippp_get_tokens / shippp_get_design_system / shippp_get_project. Write the returned "=== FILE: <path> ===" blocks to those paths. Do NOT hand-edit generated code to reflect a design change — change the design in Shippp and regenerate. Use shippp_diff to see exactly what a designer changed since your current code.`;
+// src/config.ts
+var DEFAULT_API_URL = "https://app.shippp.ai";
+function loadConfig() {
+  const apiKey = process.env.SHIPPP_API_KEY?.trim();
+  if (!apiKey) {
+    console.error(
+      "[shippp-mcp] SHIPPP_API_KEY is not set. Mint a key in your Shippp workspace settings and add it to the MCP server's `env` in your IDE config."
+    );
+    process.exit(1);
+  }
+  const apiUrl = (process.env.SHIPPP_API_URL?.trim() || DEFAULT_API_URL).replace(/\/+$/, "");
+  return { apiUrl, apiKey };
+}
+
+// src/client.ts
+var ShipppApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ShipppApiError";
+  }
+};
+function decodeFiles(files) {
+  return files.map(
+    (f) => f.encoding === "base64" ? { path: f.path, content: new Uint8Array(Buffer.from(f.content, "base64")) } : { path: f.path, content: f.content }
+  );
+}
+var ShipppClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async request(path2, init) {
+    let res;
+    try {
+      res = await fetch(`${this.config.apiUrl}${path2}`, {
+        ...init,
+        headers: {
+          Authorization: `Bearer ${this.config.apiKey}`,
+          "Content-Type": "application/json",
+          ...init.headers ?? {}
+        }
+      });
+    } catch (e) {
+      throw new ShipppApiError(0, `Could not reach Shippp at ${this.config.apiUrl}: ${e.message}`);
+    }
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) throw new ShipppApiError(res.status, body?.error || `HTTP ${res.status}`);
+    return body;
+  }
+  /** List a file's screens + master components (id + name). */
+  manifest(fileId2) {
+    return this.request(`/api/mcp/manifest?fileId=${encodeURIComponent(fileId2)}`, { method: "GET" });
+  }
+  /** Generate code for a unit (or a diff against a baseline). */
+  async generate(fileId2, request, baseline) {
+    const body = await this.request(
+      "/api/mcp/generate",
+      {
+        method: "POST",
+        body: JSON.stringify(baseline ? { fileId: fileId2, request, baseline } : { fileId: fileId2, request })
+      }
+    );
+    if ("files" in body) return { ...body, files: decodeFiles(body.files) };
+    return body;
+  }
+};
+
+// src/tools.ts
+import { z as z3 } from "zod";
+
+// src/runner.ts
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+// ../../src/lib/repoSync/applySync.ts
+import { createHash } from "node:crypto";
+
+// ../../src/lib/repoSync/targetConfig.ts
+import { z } from "zod";
+var TARGET_CONFIG_PATH = "shippp.target.json";
+var TARGET_CONFIG_SCHEMA_VERSION = 1;
+var DEFAULT_SYNC_UNIT = "project";
+var targetConfigSchema = z.object({
+  schemaVersion: z.literal(TARGET_CONFIG_SCHEMA_VERSION),
+  profile: z.string().min(1),
+  profileSchemaVersion: z.number().int().positive(),
+  generatedRoot: z.string().min(1),
+  project: z.object({ fileId: z.string().min(1), name: z.string().min(1) }).optional(),
+  unit: z.enum(["project", "design-system"]).optional()
+});
+var TargetConfigError = class extends Error {
+};
+function isSafeRelativePath(p) {
+  if (p.length === 0 || p.startsWith("/") || p.includes("\\")) return false;
+  const segments = p.split("/");
+  return segments.every((s) => s.length > 0 && s !== "." && s !== "..");
+}
+function parseTargetConfig(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    throw new TargetConfigError(`A ${TARGET_CONFIG_PATH} nem \xE9rv\xE9nyes JSON.`);
+  }
+  const parsed = targetConfigSchema.safeParse(json);
+  if (!parsed.success) {
+    throw new TargetConfigError(
+      `A ${TARGET_CONFIG_PATH} nem felel meg a(z) ${TARGET_CONFIG_SCHEMA_VERSION}. s\xE9maverzi\xF3nak: ${parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+    );
+  }
+  if (!isSafeRelativePath(parsed.data.generatedRoot)) {
+    throw new TargetConfigError(`A generatedRoot nem biztons\xE1gos repo-relat\xEDv \xFAtvonal: "${parsed.data.generatedRoot}".`);
+  }
+  return parsed.data;
+}
+
+// ../../src/lib/repoSync/receiptContract.ts
+import { z as z2 } from "zod";
+var hash = z2.string().regex(/^sha256:[0-9a-f]{64}$/);
+var receiptFileEntrySchema = z2.object({
+  path: z2.string().min(1),
+  hash,
+  bytes: z2.number().int().nonnegative()
+});
+var syncReceiptSchema = z2.object({
+  shippp_receipt: z2.literal("v2"),
+  source: z2.object({ file: z2.string(), unit: z2.string(), version: hash }),
+  target: z2.object({
+    outputProfile: z2.string().min(1),
+    profileSchemaVersion: z2.number().int().positive(),
+    adapterVersion: z2.string().min(1),
+    packagerVersion: z2.string().min(1),
+    packages: z2.object({
+      dependencies: z2.record(z2.string(), z2.string()),
+      devDependencies: z2.record(z2.string(), z2.string())
+    })
+  }),
+  config: z2.object({ engine: z2.string().min(1), irVersion: z2.string().min(1), tokens: hash }),
+  output: z2.object({ hash, files: z2.array(receiptFileEntrySchema) }),
+  reproducible: z2.literal(true),
+  generated_at: z2.string()
+});
+var ReceiptParseError = class extends Error {
+};
+function parseSyncReceipt(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    throw new ReceiptParseError("A receipt nem \xE9rv\xE9nyes JSON.");
+  }
+  const parsed = syncReceiptSchema.safeParse(json);
+  if (!parsed.success) {
+    throw new ReceiptParseError(
+      `A receipt nem felel meg a v2 kontraktusnak: ${parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+    );
+  }
+  return parsed.data;
+}
+function serializeSyncReceipt(receipt) {
+  return `${JSON.stringify(receipt, null, 2)}
+`;
+}
+var compilerEnvOfReceipt = (r) => ({
+  engine: r.config.engine,
+  irVersion: r.config.irVersion,
+  adapterVersion: r.target.adapterVersion,
+  packagerVersion: r.target.packagerVersion
+});
+function compilerDeltaOf(previous, next) {
+  const delta = [];
+  if (previous.config.engine !== next.engine) delta.push(`engine: ${previous.config.engine} \u2192 ${next.engine}`);
+  if (previous.config.irVersion !== next.irVersion) delta.push(`IR: ${previous.config.irVersion} \u2192 ${next.irVersion}`);
+  if (previous.target.adapterVersion !== next.adapterVersion) {
+    delta.push(`adapter: ${previous.target.adapterVersion} \u2192 ${next.adapterVersion}`);
+  }
+  if (previous.target.packagerVersion !== next.packagerVersion) {
+    delta.push(`packager: ${previous.target.packagerVersion} \u2192 ${next.packagerVersion}`);
+  }
+  return delta;
+}
+
+// ../../src/lib/repoSync/syncPlan.ts
+function computeSyncPlan(input) {
+  const entries = [];
+  const conflicts = [];
+  const paths = [.../* @__PURE__ */ new Set([...input.artifact.keys(), ...input.previous?.keys() ?? []])].sort();
+  for (const path2 of paths) {
+    const next = input.artifact.get(path2);
+    const prev = input.previous?.get(path2);
+    const local = input.local.get(path2) ?? null;
+    if (next !== void 0) {
+      if (local === null) {
+        entries.push({ path: path2, action: "create" });
+      } else if (local === next) {
+        entries.push({ path: path2, action: "unchanged" });
+      } else if (prev !== void 0 && local === prev) {
+        entries.push({ path: path2, action: "update" });
+      } else if (prev !== void 0) {
+        conflicts.push({
+          path: path2,
+          kind: "modified",
+          message: `A gener\xE1lt f\xE1jl k\xE9zzel m\xF3dosult: ${path2} \u2014 a sync nem \xEDrja fel\xFCl. Felold\xE1s: snapshotv\xE1laszt\xE1s \xE9s \xFAjragener\xE1l\xE1s, nem k\xE9zi merge.`
+        });
+      } else {
+        conflicts.push({
+          path: path2,
+          kind: "untracked",
+          message: `Nem Shippp-syncelt lok\xE1lis f\xE1jl \xE1ll a gener\xE1lt \xFAtvonalon: ${path2} \u2014 a sync nem \xEDrja fel\xFCl.`
+        });
+      }
+    } else if (prev !== void 0) {
+      if (local === null) {
+        entries.push({ path: path2, action: "unchanged" });
+      } else if (local === prev) {
+        entries.push({ path: path2, action: "delete" });
+      } else {
+        conflicts.push({
+          path: path2,
+          kind: "modified-delete",
+          message: `A t\xF6rlend\u0151 gener\xE1lt f\xE1jl k\xE9zzel m\xF3dosult: ${path2} \u2014 a sync nem t\xF6rli.`
+        });
+      }
+    }
+  }
+  return { entries, conflicts };
+}
+
+// ../../src/lib/repoSync/applySync.ts
+var RECEIPT_FILENAME = "shippp.receipt.json";
+var sha256 = (content) => `sha256:${createHash("sha256").update(content).digest("hex")}`;
+var refusal = (code, message, conflicts) => ({
+  status: "refused",
+  code,
+  message,
+  ...conflicts ? { conflicts } : {}
+});
+function artifactIntegrityIssue(artifact) {
+  const byPath = new Map(artifact.files.map((f) => [f.path, f]));
+  if (byPath.size !== artifact.files.length) return "az artifact f\xE1jllist\xE1j\xE1ban duplik\xE1lt \xFAtvonal van";
+  const mapped = artifact.receipt.output.files;
+  if (mapped.length !== artifact.files.length) return "a receipt f\xE1jl-mappingje \xE9s az artifact f\xE1jlk\xE9szlete elt\xE9r";
+  for (const entry of mapped) {
+    if (!isSafeRelativePath(entry.path)) return `nem biztons\xE1gos artifact-\xFAtvonal: "${entry.path}"`;
+    if (entry.path === RECEIPT_FILENAME) return `az artifact nem tartalmazhat ${RECEIPT_FILENAME} f\xE1jlt`;
+    const file = byPath.get(entry.path);
+    if (!file) return `a receipt olyan f\xE1jlt c\xEDmez, amely nincs az artifactban: ${entry.path}`;
+    if (sha256(file.content) !== entry.hash) return `az artifact-tartalom nem egyezik a receipt hash-\xE9vel: ${entry.path}`;
+  }
+  return null;
+}
+async function resolveContext(fs, artifact, options = {}) {
+  const rawConfig = await fs.read(TARGET_CONFIG_PATH);
+  if (rawConfig === null) {
+    return refusal(
+      "no-target-config",
+      `Nincs ${TARGET_CONFIG_PATH} a repositoryban \u2014 a target be\xE1ll\xEDt\xE1sa explicit setup-l\xE9p\xE9s, a sync nem hozza l\xE9tre.`
+    );
+  }
+  let config;
+  try {
+    config = parseTargetConfig(Buffer.from(rawConfig).toString("utf8"));
+  } catch (e) {
+    if (e instanceof TargetConfigError) return refusal("invalid-target-config", e.message);
+    throw e;
+  }
+  const integrity = artifactIntegrityIssue(artifact);
+  if (integrity) return refusal("artifact-integrity", `Az artifact nem konzisztens: ${integrity}.`);
+  if (config.project && artifact.receipt.source.file !== config.project.fileId) {
+    return refusal(
+      "project-mismatch",
+      `Az artifact forr\xE1sa (${artifact.receipt.source.file}) nem a repository k\xF6t\xF6tt projektje (${config.project.fileId}) \u2014 \xE1tk\xF6t\xE9s kiz\xE1r\xF3lag a bind explicit \xFAtj\xE1n t\xF6rt\xE9nhet.`
+    );
+  }
+  const configUnit = config.unit ?? DEFAULT_SYNC_UNIT;
+  if (artifact.receipt.source.unit !== configUnit) {
+    return refusal(
+      "unit-mismatch",
+      `Az artifact sync-egys\xE9ge (${artifact.receipt.source.unit}) nem a repository k\xF6t\xF6tt egys\xE9ge (${configUnit}).`
+    );
+  }
+  if (artifact.receipt.target.outputProfile !== config.profile) {
+    return refusal(
+      "profile-mismatch",
+      `Az artifact profilja (${artifact.receipt.target.outputProfile}) nem a repository explicit default profilja (${config.profile}) \u2014 a profilv\xE1lt\xE1s k\xFCl\xF6n, explicit folyamat.`
+    );
+  }
+  if (artifact.receipt.target.profileSchemaVersion !== config.profileSchemaVersion) {
+    return refusal(
+      "profile-schema-mismatch",
+      `Az artifact profile schema verzi\xF3ja (${artifact.receipt.target.profileSchemaVersion}) elt\xE9r a repositoryban r\xF6gz\xEDtett\u0151l (${config.profileSchemaVersion}).`
+    );
+  }
+  const receiptPath = `${config.generatedRoot}/${RECEIPT_FILENAME}`;
+  const rawReceipt = await fs.read(receiptPath);
+  let previousReceipt = null;
+  if (rawReceipt !== null) {
+    try {
+      previousReceipt = parseSyncReceipt(Buffer.from(rawReceipt).toString("utf8"));
+    } catch (e) {
+      if (e instanceof ReceiptParseError) return refusal("invalid-previous-receipt", e.message);
+      throw e;
+    }
+  }
+  if (previousReceipt && (previousReceipt.source.unit !== configUnit || config.project && previousReceipt.source.file !== config.project.fileId) && options.acceptReboundBaseline !== true) {
+    return refusal(
+      "receipt-binding-mismatch",
+      `A repository receiptje (${previousReceipt.source.file} / ${previousReceipt.source.unit}) nem a jelenlegi bindinghoz tartozik \u2014 \xE1tk\xF6t\xE9s ut\xE1ni els\u0151 synchez az acceptReboundBaseline explicit d\xF6nt\xE9se kell; a k\xE9zzel m\xF3dos\xEDtott f\xE1jlok v\xE9delme mellette is \xE1ll.`
+    );
+  }
+  const repoPathOf = (artifactPath) => `${config.generatedRoot}/${artifactPath}`;
+  const artifactHashes = new Map(artifact.receipt.output.files.map((e) => [e.path, e.hash]));
+  const previousHashes = previousReceipt ? new Map(previousReceipt.output.files.map((e) => [e.path, e.hash])) : null;
+  const local = /* @__PURE__ */ new Map();
+  for (const path2 of /* @__PURE__ */ new Set([...artifactHashes.keys(), ...previousHashes?.keys() ?? []])) {
+    const bytes = await fs.read(repoPathOf(path2));
+    local.set(path2, bytes === null ? null : sha256(bytes));
+  }
+  const plan = computeSyncPlan({ artifact: artifactHashes, previous: previousHashes, local });
+  return { config, previousReceipt, plan, receiptPath, repoPathOf, localAtPlan: local };
+}
+async function planRepoSync(fs, artifact, options = {}) {
+  const ctx = await resolveContext(fs, artifact, options);
+  if ("status" in ctx) return ctx;
+  return { status: "plan", config: ctx.config, plan: ctx.plan, previousReceipt: ctx.previousReceipt };
+}
+async function applyRepoSync(fs, artifact, options = {}) {
+  const ctx = await resolveContext(fs, artifact, options);
+  if ("status" in ctx) return ctx;
+  const { plan, previousReceipt, receiptPath, repoPathOf, localAtPlan } = ctx;
+  if (previousReceipt) {
+    const delta = compilerDeltaOf(previousReceipt, compilerEnvOfReceipt(artifact.receipt));
+    if (delta.length > 0 && !options.allowCompilerUpgrade) {
+      return refusal(
+        "compiler-upgrade-requires-approval",
+        `A compiler-k\xF6rnyezet v\xE1ltozott (${delta.join(", ")}) \u2014 megl\xE9v\u0151 repository nem kaphat \xFAj verzi\xF3t csendben; explicit j\xF3v\xE1hagy\xE1s sz\xFCks\xE9ges.`
+      );
+    }
+  }
+  if (plan.conflicts.length > 0) {
+    return refusal(
+      "conflict",
+      `A sync ${plan.conflicts.length} konfliktus miatt nem alkalmazhat\xF3; semmi nem \xEDr\xF3dott.`,
+      plan.conflicts
+    );
+  }
+  const contentByPath = new Map(artifact.files.map((f) => [f.path, f.content]));
+  const written = [];
+  const deleted = [];
+  const backups = /* @__PURE__ */ new Map();
+  const rollback = async () => {
+    for (const [repoPath, original] of backups) {
+      if (original === null) await fs.remove(repoPath);
+      else await fs.write(repoPath, original);
+    }
+  };
+  try {
+    for (const entry of plan.entries) {
+      if (entry.action === "unchanged") continue;
+      const repoPath = repoPathOf(entry.path);
+      const currentBytes = await fs.read(repoPath);
+      const currentHash = currentBytes === null ? null : sha256(currentBytes);
+      if (currentHash !== (localAtPlan.get(entry.path) ?? null)) {
+        await rollback();
+        return refusal(
+          "apply-raced",
+          `A lemez a terv \xE9s az alkalmaz\xE1s k\xF6z\xF6tt megv\xE1ltozott (${entry.path}) \u2014 minden kor\xE1bbi v\xE1ltoz\xE1s visszag\xF6rgetve; futtasd \xFAjra a syncet friss tervvel.`
+        );
+      }
+      backups.set(repoPath, currentBytes);
+      if (entry.action === "create" || entry.action === "update") {
+        await fs.write(repoPath, contentByPath.get(entry.path));
+        written.push(entry.path);
+      } else {
+        await fs.remove(repoPath);
+        deleted.push(entry.path);
+      }
+    }
+  } catch (e) {
+    await rollback();
+    return refusal("apply-failed", `Az alkalmaz\xE1s hib\xE1ra futott, minden v\xE1ltoz\xE1s visszag\xF6rgetve: ${e.message}`);
+  }
+  if (options.runChecks) {
+    try {
+      await options.runChecks();
+    } catch (e) {
+      await rollback();
+      return refusal(
+        "checks-failed",
+        `A sync ellen\u0151rz\xE9sei hib\xE1ztak, minden v\xE1ltoz\xE1s visszag\xF6rgetve; a receipt nem friss\xFClt: ${e.message}`
+      );
+    }
+  }
+  try {
+    await fs.write(receiptPath, serializeSyncReceipt(artifact.receipt));
+  } catch (e) {
+    await rollback();
+    return refusal("apply-failed", `A receipt \xEDr\xE1sa hib\xE1ra futott, minden v\xE1ltoz\xE1s visszag\xF6rgetve: ${e.message}`);
+  }
+  return { status: "applied", plan, written, deleted, receiptPath };
+}
+
+// ../../src/lib/repoSync/nodeFs.ts
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+function nodeSyncFs(rootDir) {
+  const resolve = (p) => {
+    const full = path.resolve(rootDir, p);
+    if (full !== rootDir && !full.startsWith(rootDir + path.sep)) {
+      throw new Error(`A(z) "${p}" \xFAtvonal a repo-gy\xF6k\xE9ren k\xEDv\xFClre mutat.`);
+    }
+    return full;
+  };
+  return {
+    async read(p) {
+      try {
+        return new Uint8Array(await fsp.readFile(resolve(p)));
+      } catch (e) {
+        if (e.code === "ENOENT") return null;
+        throw e;
+      }
+    },
+    async write(p, content) {
+      const full = resolve(p);
+      await fsp.mkdir(path.dirname(full), { recursive: true });
+      await fsp.writeFile(full, content);
+    },
+    async remove(p) {
+      await fsp.rm(resolve(p), { force: true });
+    }
+  };
+}
+
+// src/runner.ts
+var execAsync = promisify(exec);
+var refusalOutcome = (r, compilerDelta) => ({
+  status: "refused",
+  code: r.code,
+  message: r.message,
+  ...r.conflicts ? { conflicts: r.conflicts } : {},
+  ...compilerDelta && compilerDelta.length > 0 ? { compilerDelta } : {}
+});
+async function fetchContext(client, root) {
+  const fs = nodeSyncFs(root);
+  const rawConfig = await fs.read(TARGET_CONFIG_PATH);
+  if (rawConfig === null) {
+    return {
+      status: "refused",
+      code: "no-target-config",
+      message: `Nincs ${TARGET_CONFIG_PATH} a repositoryban \u2014 a target be\xE1ll\xEDt\xE1sa explicit setup-l\xE9p\xE9s (shippp_bind_repository), a sync nem hozza l\xE9tre.`
+    };
+  }
+  let config;
+  try {
+    config = parseTargetConfig(Buffer.from(rawConfig).toString("utf8"));
+  } catch (e) {
+    if (e instanceof TargetConfigError) return { status: "refused", code: "invalid-target-config", message: e.message };
+    throw e;
+  }
+  if (!config.project) {
+    return {
+      status: "refused",
+      code: "no-project-binding",
+      message: `A ${TARGET_CONFIG_PATH} nem tartalmaz projekt-bindingot \u2014 futtasd a shippp_bind_repository k\xF6t\xE9st (explicit setup-l\xE9p\xE9s).`
+    };
+  }
+  const unit = config.unit ?? DEFAULT_SYNC_UNIT;
+  const result = await client.generate(config.project.fileId, { unit, profile: config.profile });
+  if (!result || !Array.isArray(result.files) || !result.receipt) {
+    return { status: "refused", code: "invalid-artifact", message: "A backend v\xE1lasza nem gener\xE1l\xE1si artifact." };
+  }
+  let artifact;
+  try {
+    artifact = { files: result.files, receipt: parseSyncReceipt(JSON.stringify(result.receipt)) };
+  } catch (e) {
+    if (e instanceof ReceiptParseError) return { status: "refused", code: "invalid-artifact", message: e.message };
+    throw e;
+  }
+  let compilerDelta = [];
+  const rawPrevious = await fs.read(`${config.generatedRoot}/${RECEIPT_FILENAME}`);
+  if (rawPrevious !== null) {
+    try {
+      const previous = parseSyncReceipt(Buffer.from(rawPrevious).toString("utf8"));
+      compilerDelta = compilerDeltaOf(previous, compilerEnvOfReceipt(artifact.receipt));
+    } catch {
+    }
+  }
+  return { config, artifact, compilerDelta };
+}
+function syncOptionsOf(opts, compilerDelta) {
+  const approved = Array.isArray(opts.allowCompilerUpgrade) ? compilerDelta.length > 0 && opts.allowCompilerUpgrade.length === compilerDelta.length && opts.allowCompilerUpgrade.every((line, i) => line === compilerDelta[i]) : opts.allowCompilerUpgrade === true;
+  return {
+    allowCompilerUpgrade: approved,
+    acceptReboundBaseline: opts.acceptReboundBaseline === true
+  };
+}
+async function planRepo(client, opts) {
+  const ctx = await fetchContext(client, opts.root);
+  if ("status" in ctx) return ctx;
+  const preview = await planRepoSync(nodeSyncFs(opts.root), ctx.artifact, syncOptionsOf(opts, ctx.compilerDelta));
+  if (preview.status === "refused") return refusalOutcome(preview, ctx.compilerDelta);
+  return {
+    status: "plan",
+    fileId: ctx.config.project.fileId,
+    unit: ctx.config.unit ?? DEFAULT_SYNC_UNIT,
+    profile: ctx.config.profile,
+    generatedRoot: ctx.config.generatedRoot,
+    entries: preview.plan.entries.filter((e) => e.action !== "unchanged"),
+    conflicts: preview.plan.conflicts,
+    compilerDelta: ctx.compilerDelta
+  };
+}
+async function applyRepo(client, opts) {
+  const ctx = await fetchContext(client, opts.root);
+  if ("status" in ctx) return ctx;
+  const checks = opts.checks ?? [];
+  const result = await applyRepoSync(nodeSyncFs(opts.root), ctx.artifact, {
+    ...syncOptionsOf(opts, ctx.compilerDelta),
+    runChecks: checks.length > 0 ? async () => {
+      for (const cmd of checks) {
+        try {
+          await execAsync(cmd, { cwd: opts.root, maxBuffer: 16 * 1024 * 1024 });
+        } catch (e) {
+          const err = e;
+          const tail = String(err.stderr || err.stdout || err.message || "").slice(-2e3);
+          throw new Error(`${cmd}
+${tail}`);
+        }
+      }
+    } : void 0
+  });
+  if (result.status === "refused") return refusalOutcome(result, ctx.compilerDelta);
+  return {
+    status: "applied",
+    fileId: ctx.config.project.fileId,
+    unit: ctx.config.unit ?? DEFAULT_SYNC_UNIT,
+    profile: ctx.config.profile,
+    generatedRoot: ctx.config.generatedRoot,
+    written: result.written,
+    deleted: result.deleted,
+    receiptPath: result.receiptPath,
+    checksRan: checks
+  };
+}
+
+// src/tools.ts
+var text = (s) => ({ content: [{ type: "text", text: s }] });
+var fail = (s) => ({ content: [{ type: "text", text: s }], isError: true });
+function errText(e) {
+  if (e instanceof ShipppApiError) {
+    const hint = e.status === 401 ? " \u2014 check SHIPPP_API_KEY." : "";
+    return `Error ${e.status}: ${e.message}${hint}`;
+  }
+  return `Error: ${e.message}`;
+}
+function renderFiles(result) {
+  const files = result.files.map(
+    (f) => typeof f.content === "string" ? `=== FILE: ${f.path} ===
+${f.content}` : `=== FILE: ${f.path} === (binary, ${f.content.byteLength} bytes \u2014 fetch via sync, not chat)`
+  ).join("\n\n");
+  return `${files}
+
+--- RECEIPT (reproducible: ${result.receipt.reproducible}, engine: ${result.receipt.config.engine}) ---
+${JSON.stringify(result.receipt, null, 2)}`;
+}
+function repoRootOf(env = process.env) {
+  return env.SHIPPP_REPO_ROOT?.trim() || process.cwd();
+}
+function checksOf(env = process.env) {
+  const cmd = env.SHIPPP_SYNC_CHECKS?.trim();
+  return cmd ? [cmd] : [];
+}
+function renderDiff(result) {
+  const changed = result.changed_files.map((f) => `${f.status}	${f.path}`).join("\n");
+  return `changed: ${result.changed}
+
+${result.diff || "(no changes)"}
+
+--- files ---
+${changed}
+
+--- RECEIPT ---
+${JSON.stringify(result.receipt, null, 2)}`;
+}
+var fileId = z3.string().min(1).describe("The Shippp file id (from the file's URL, or shippp_list_units).");
+function registerTools(server, client) {
+  server.registerTool(
+    "shippp_list_units",
+    {
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: "List a Shippp file's screens and master components (id + name). Call this FIRST to discover the ids for shippp_get_component.",
+      inputSchema: { fileId }
+    },
+    async ({ fileId: fileId2 }) => {
+      try {
+        const { manifest } = await client.manifest(fileId2);
+        return text(JSON.stringify(manifest, null, 2));
+      } catch (e) {
+        return fail(errText(e));
+      }
+    }
+  );
+  server.registerTool(
+    "shippp_get_component",
+    {
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: "Get ONE component's deterministic Chakra UI code + a reproducibility receipt. `unitType` is 'master' (a design-system component) or 'screen' (a depth-0 artboard). Get ids from shippp_list_units.",
+      inputSchema: {
+        fileId,
+        unitId: z3.string().min(1).describe("The master/screen id from shippp_list_units."),
+        unitType: z3.enum(["master", "screen"])
+      }
+    },
+    async ({ fileId: fileId2, unitId, unitType }) => {
+      try {
+        return text(renderFiles(await client.generate(fileId2, { unit: "component", unitId, unitType })));
+      } catch (e) {
+        return fail(errText(e));
+      }
+    }
+  );
+  server.registerTool(
+    "shippp_get_tokens",
+    {
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: "Get the design system's tokens as a Chakra theme (createSystem) + receipt.",
+      inputSchema: { fileId }
+    },
+    async ({ fileId: fileId2 }) => {
+      try {
+        return text(renderFiles(await client.generate(fileId2, { unit: "tokens" })));
+      } catch (e) {
+        return fail(errText(e));
+      }
+    }
+  );
+  server.registerTool(
+    "shippp_get_design_system",
+    {
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: "Get the whole design system as a publishable package (tokens + theme + recipes + every component + stories + package.json).",
+      inputSchema: { fileId }
+    },
+    async ({ fileId: fileId2 }) => {
+      try {
+        return text(renderFiles(await client.generate(fileId2, { unit: "design-system" })));
+      } catch (e) {
+        return fail(errText(e));
+      }
+    }
+  );
+  server.registerTool(
+    "shippp_get_project",
+    {
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: "Get the whole file as a runnable Next.js project (screens as pages + the design system).",
+      inputSchema: { fileId }
+    },
+    async ({ fileId: fileId2 }) => {
+      try {
+        return text(renderFiles(await client.generate(fileId2, { unit: "project" })));
+      } catch (e) {
+        return fail(errText(e));
+      }
+    }
+  );
+  server.registerTool(
+    "shippp_diff",
+    {
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: "Diff your CURRENT code against a fresh deterministic generation of a unit \u2014 shows exactly what a designer changed. Pass the same unit params as the get tools, plus `baseline` (the files you currently have for that unit).",
+      inputSchema: {
+        fileId,
+        unit: z3.enum(["tokens", "design-system", "project", "component"]),
+        unitId: z3.string().optional().describe("Required when unit='component'."),
+        unitType: z3.enum(["master", "screen"]).optional().describe("Required when unit='component'."),
+        baseline: z3.array(z3.object({ path: z3.string(), content: z3.string() })).describe("Your current files for this unit (path + content).")
+      }
+    },
+    async ({ fileId: fileId2, unit, unitId, unitType, baseline }) => {
+      try {
+        let request;
+        if (unit === "component") {
+          if (!unitId || !unitType) return fail("unit='component' requires unitId + unitType.");
+          request = { unit, unitId, unitType };
+        } else {
+          request = { unit };
+        }
+        return text(renderDiff(await client.generate(fileId2, request, baseline)));
+      } catch (e) {
+        return fail(errText(e));
+      }
+    }
+  );
+  server.registerTool(
+    "shippp_sync_plan",
+    {
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: "Preview the repository's Shippp sync as a deterministic plan \u2014 NO writes. The repo root comes from the developer's own configuration (SHIPPP_REPO_ROOT env, or the server's working directory), never from tool input. Requires a committed shippp.target.json binding (created via shippp_bind_repository on the remote MCP). Returns the create/update/delete entries, hand-modified-file conflicts and any pending compiler/IR/adapter delta that shippp_sync_apply would need explicit approval for.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const outcome = await planRepo(client, { root: repoRootOf() });
+        const body = JSON.stringify(outcome, null, 2);
+        return outcome.status === "refused" ? fail(body) : text(body);
+      } catch (e) {
+        return fail(errText(e));
+      }
+    }
+  );
+  server.registerTool(
+    "shippp_sync_apply",
+    {
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+      description: "Run the full repository sync with the bundled deterministic runner: fetch the bound unit's artifact, plan against the real on-disk state, apply atomically with rollback, run the repo's checks (SHIPPP_SYNC_CHECKS env), and write the receipt ONLY on full success. Writes are confined to the generated root of the repo's own binding; hand-modified generated files are structured conflicts and are never overwritten. If the plan or a refusal reports a compilerDelta, present it to the user and re-call with approvedCompilerDelta set to EXACTLY those lines ONLY after their explicit approval. After an approved re-bind, pass acceptReboundBaseline to adopt the previous binding's receipt as baseline.",
+      inputSchema: {
+        approvedCompilerDelta: z3.array(z3.string().min(1).max(500)).max(20).optional().describe(
+          "The exact compilerDelta lines the user explicitly approved \u2014 a mismatch with the current delta refuses."
+        ),
+        acceptReboundBaseline: z3.boolean().optional().describe("Explicit adoption of a previous binding's leftover receipt as hash baseline after a re-bind.")
+      }
+    },
+    async ({ approvedCompilerDelta, acceptReboundBaseline }) => {
+      try {
+        const outcome = await applyRepo(client, {
+          root: repoRootOf(),
+          allowCompilerUpgrade: approvedCompilerDelta,
+          acceptReboundBaseline,
+          checks: checksOf()
+        });
+        const body = JSON.stringify(outcome, null, 2);
+        return outcome.status === "refused" ? fail(body) : text(body);
+      } catch (e) {
+        return fail(errText(e));
+      }
+    }
+  );
+}
+
+// src/index.ts
+var INSTRUCTIONS = `Shippp exposes DETERMINISTIC, production-perfect UI code generated from a designer's Shippp file. Everything returned is GENERATED (never guessed) and reproducible \u2014 the same source always yields the same code + hash (see each result's receipt).
+
+Workflow: call shippp_list_units first to discover screen/master ids, then pull code with shippp_get_component / shippp_get_tokens / shippp_get_design_system / shippp_get_project. Write the returned "=== FILE: <path> ===" blocks to those paths. Do NOT hand-edit generated code to reflect a design change \u2014 change the design in Shippp and regenerate. Use shippp_diff to see exactly what a designer changed since your current code.
+
+Keeping a repository current: once the repo has a committed shippp.target.json binding (created with shippp_bind_repository on the remote MCP, or written by hand), use shippp_sync_plan to preview and shippp_sync_apply to run the official receipt-tracked sync \u2014 do NOT re-pull whole projects and hand-diff them from chat memory. The runner never overwrites hand-modified generated files (structured conflict), never touches files outside the generated root, runs the repo's checks and writes the receipt only on full success. A compiler/IR/adapter delta needs the user's explicit approval (approvedCompilerDelta with the exact lines).`;
+function parseCliFlags(rest) {
+  const opts = { checks: [] };
+  const errors = [];
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    const [flag, inlineValue] = arg.includes("=") ? [arg.slice(0, arg.indexOf("=")), arg.slice(arg.indexOf("=") + 1)] : [arg, void 0];
+    const value = () => inlineValue ?? rest[++i];
+    switch (flag) {
+      case "--root":
+        opts.root = value();
+        break;
+      case "--check":
+        opts.checks.push(value() ?? "");
+        break;
+      case "--allow-compiler-upgrade":
+        opts.allowCompilerUpgrade = true;
+        break;
+      case "--accept-rebound-baseline":
+        opts.acceptReboundBaseline = true;
+        break;
+      default:
+        errors.push(`Ismeretlen kapcsol\xF3: ${arg}`);
+    }
+  }
+  if (opts.checks.some((c) => !c)) errors.push("A --check kapcsol\xF3hoz parancs kell.");
+  return { opts, errors };
+}
+async function runCli(command, rest) {
+  const { opts, errors } = parseCliFlags(rest);
+  if (errors.length > 0) {
+    console.error(errors.join("\n"));
+    console.error("Haszn\xE1lat: shippp-mcp plan|sync [--root <repo>] [--check <cmd>]... [--allow-compiler-upgrade] [--accept-rebound-baseline]");
+    process.exit(1);
+  }
+  const client = new ShipppClient(loadConfig());
+  const root = opts.root ?? repoRootOf();
+  const outcome = command === "plan" ? await planRepo(client, { ...opts, root }) : await applyRepo(client, { ...opts, root });
+  console.log(JSON.stringify(outcome, null, 2));
+  process.exit(outcome.status === "refused" ? 2 : 0);
+}
 async function main() {
-    const config = loadConfig();
-    const server = new McpServer({ name: "shippp", version: "0.1.0" }, { instructions: INSTRUCTIONS });
-    registerTools(server, new ShipppClient(config));
-    await server.connect(new StdioServerTransport());
-    console.error(`[shippp-mcp] connected via stdio → ${config.apiUrl}`);
+  const [command, ...rest] = process.argv.slice(2);
+  if (command === "plan" || command === "sync") {
+    await runCli(command, rest);
+    return;
+  }
+  if (command !== void 0) {
+    console.error(`Ismeretlen parancs: ${command} \u2014 argumentum n\xE9lk\xFCl stdio MCP szerver indul; sync-hez: shippp-mcp plan|sync`);
+    process.exit(1);
+  }
+  const config = loadConfig();
+  const server = new McpServer({ name: "shippp", version: "0.2.0" }, { instructions: INSTRUCTIONS });
+  registerTools(server, new ShipppClient(config));
+  await server.connect(new StdioServerTransport());
+  console.error(`[shippp-mcp] connected via stdio \u2192 ${config.apiUrl}`);
 }
 main().catch((e) => {
-    console.error("[shippp-mcp] fatal:", e);
-    process.exit(1);
+  console.error("[shippp-mcp] fatal:", e);
+  process.exit(1);
 });

package/package.json

@@ -1,17 +1,20 @@
 {
   "name": "@shippp/mcp",
-  "version": "0.1.0",
-  "description": "Shippp MCP server — pull deterministic, production-perfect Chakra UI code from your Shippp design files, straight into your IDE agent.",
+  "version": "0.2.0",
+  "mcpName": "ai.shippp/mcp",
+  "description": "Shippp MCP server + local sync runner — pull deterministic, production-perfect UI code from your Shippp design files, and keep your repository current over the receipt-tracked sync.",
   "type": "module",
   "bin": {
     "shippp-mcp": "dist/index.js"
   },
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
-    "build": "tsc",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "build": "npm run typecheck && esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:@modelcontextprotocol/sdk --external:zod",
     "start": "node dist/index.js",
     "prepublishOnly": "rm -rf dist && npm run build"
   },
@@ -25,12 +28,20 @@
     "chakra-ui",
     "design-to-code"
   ],
-  "license": "UNLICENSED",
+  "license": "MIT",
+  "homepage": "https://shippp.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Comet-Studio-Io/shippp.git",
+    "directory": "packages/mcp"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {
+    "@types/node": "^24.0.0",
+    "esbuild": "^0.24.0",
     "typescript": "^5.6.0"
   }
 }

package/dist/client.js

@@ -1,43 +0,0 @@
-export class ShipppApiError extends Error {
-    status;
-    constructor(status, message) {
-        super(message);
-        this.status = status;
-        this.name = "ShipppApiError";
-    }
-}
-export class ShipppClient {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    async request(path, init) {
-        let res;
-        try {
-            res = await fetch(`${this.config.apiUrl}${path}`, {
-                ...init,
-                headers: {
-                    Authorization: `Bearer ${this.config.apiKey}`,
-                    "Content-Type": "application/json",
-                    ...(init.headers ?? {}),
-                },
-            });
-        }
-        catch (e) {
-            throw new ShipppApiError(0, `Could not reach Shippp at ${this.config.apiUrl}: ${e.message}`);
-        }
-        const body = (await res.json().catch(() => ({})));
-        if (!res.ok)
-            throw new ShipppApiError(res.status, body?.error || `HTTP ${res.status}`);
-        return body;
-    }
-    manifest(fileId) {
-        return this.request(`/api/mcp/manifest?fileId=${encodeURIComponent(fileId)}`, { method: "GET" });
-    }
-    generate(fileId, request, baseline) {
-        return this.request("/api/mcp/generate", {
-            method: "POST",
-            body: JSON.stringify(baseline ? { fileId, request, baseline } : { fileId, request }),
-        });
-    }
-}

package/dist/config.js

@@ -1,11 +0,0 @@
-const DEFAULT_API_URL = "https://app.shippp.ai";
-export function loadConfig() {
-    const apiKey = process.env.SHIPPP_API_KEY?.trim();
-    if (!apiKey) {
-        console.error("[shippp-mcp] SHIPPP_API_KEY is not set. Mint a key in your Shippp workspace " +
-            "settings and add it to the MCP server's `env` in your IDE config.");
-        process.exit(1);
-    }
-    const apiUrl = (process.env.SHIPPP_API_URL?.trim() || DEFAULT_API_URL).replace(/\/+$/, "");
-    return { apiUrl, apiKey };
-}

package/dist/tools.js

@@ -1,110 +0,0 @@
-import { z } from "zod";
-import { ShipppApiError } from "./client.js";
-const text = (s) => ({ content: [{ type: "text", text: s }] });
-const fail = (s) => ({ content: [{ type: "text", text: s }], isError: true });
-function errText(e) {
-    if (e instanceof ShipppApiError) {
-        const hint = e.status === 401 ? " — check SHIPPP_API_KEY." : "";
-        return `Error ${e.status}: ${e.message}${hint}`;
-    }
-    return `Error: ${e.message}`;
-}
-function renderFiles(result) {
-    const files = result.files.map((f) => `=== FILE: ${f.path} ===\n${f.content}`).join("\n\n");
-    return `${files}\n\n--- RECEIPT (reproducible: ${result.receipt.reproducible}, engine: ${result.receipt.config.engine}) ---\n${JSON.stringify(result.receipt, null, 2)}`;
-}
-function renderDiff(result) {
-    const changed = result.changed_files.map((f) => `${f.status}\t${f.path}`).join("\n");
-    return `changed: ${result.changed}\n\n${result.diff || "(no changes)"}\n\n--- files ---\n${changed}\n\n--- RECEIPT ---\n${JSON.stringify(result.receipt, null, 2)}`;
-}
-const fileId = z.string().min(1).describe("The Shippp file id (from the file's URL, or shippp_list_units).");
-export function registerTools(server, client) {
-    server.registerTool("shippp_list_units", {
-        description: "List a Shippp file's screens and master components (id + name). Call this FIRST to discover the ids for shippp_get_component.",
-        inputSchema: { fileId },
-    }, async ({ fileId }) => {
-        try {
-            const { manifest } = await client.manifest(fileId);
-            return text(JSON.stringify(manifest, null, 2));
-        }
-        catch (e) {
-            return fail(errText(e));
-        }
-    });
-    server.registerTool("shippp_get_component", {
-        description: "Get ONE component's deterministic Chakra UI code + a reproducibility receipt. `unitType` is 'master' (a design-system component) or 'screen' (a depth-0 artboard). Get ids from shippp_list_units.",
-        inputSchema: {
-            fileId,
-            unitId: z.string().min(1).describe("The master/screen id from shippp_list_units."),
-            unitType: z.enum(["master", "screen"]),
-        },
-    }, async ({ fileId, unitId, unitType }) => {
-        try {
-            return text(renderFiles((await client.generate(fileId, { unit: "component", unitId, unitType }))));
-        }
-        catch (e) {
-            return fail(errText(e));
-        }
-    });
-    server.registerTool("shippp_get_tokens", {
-        description: "Get the design system's tokens as a Chakra theme (createSystem) + receipt.",
-        inputSchema: { fileId },
-    }, async ({ fileId }) => {
-        try {
-            return text(renderFiles((await client.generate(fileId, { unit: "tokens" }))));
-        }
-        catch (e) {
-            return fail(errText(e));
-        }
-    });
-    server.registerTool("shippp_get_design_system", {
-        description: "Get the whole design system as a publishable package (tokens + theme + recipes + every component + stories + package.json).",
-        inputSchema: { fileId },
-    }, async ({ fileId }) => {
-        try {
-            return text(renderFiles((await client.generate(fileId, { unit: "design-system" }))));
-        }
-        catch (e) {
-            return fail(errText(e));
-        }
-    });
-    server.registerTool("shippp_get_project", {
-        description: "Get the whole file as a runnable Next.js project (screens as pages + the design system).",
-        inputSchema: { fileId },
-    }, async ({ fileId }) => {
-        try {
-            return text(renderFiles((await client.generate(fileId, { unit: "project" }))));
-        }
-        catch (e) {
-            return fail(errText(e));
-        }
-    });
-    server.registerTool("shippp_diff", {
-        description: "Diff your CURRENT code against a fresh deterministic generation of a unit — shows exactly what a designer changed. Pass the same unit params as the get tools, plus `baseline` (the files you currently have for that unit).",
-        inputSchema: {
-            fileId,
-            unit: z.enum(["tokens", "design-system", "project", "component"]),
-            unitId: z.string().optional().describe("Required when unit='component'."),
-            unitType: z.enum(["master", "screen"]).optional().describe("Required when unit='component'."),
-            baseline: z
-                .array(z.object({ path: z.string(), content: z.string() }))
-                .describe("Your current files for this unit (path + content)."),
-        },
-    }, async ({ fileId, unit, unitId, unitType, baseline }) => {
-        try {
-            let request;
-            if (unit === "component") {
-                if (!unitId || !unitType)
-                    return fail("unit='component' requires unitId + unitType.");
-                request = { unit, unitId, unitType };
-            }
-            else {
-                request = { unit };
-            }
-            return text(renderDiff((await client.generate(fileId, request, baseline))));
-        }
-        catch (e) {
-            return fail(errText(e));
-        }
-    });
-}