swatch-token 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,660 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+
+// src/mcp.ts
+import { createInterface } from "node:readline";
+
+// src/server/project.ts
+import { existsSync, readFileSync as readFileSync2, readdirSync, statSync as statSync2 } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import postcss2 from "postcss";
+
+// src/server/files.ts
+import { readFileSync, statSync, writeFileSync } from "node:fs";
+
+// src/server/stylesheet.ts
+import postcss from "postcss";
+var THEMES = ["light", "dark"];
+var LIGHT_SEL = /^(:root|html|:root,\s*html|html,\s*:root)$/;
+var DARK_FIRST = /^(:root|html)?(\.dark|\[data-(theme|mode|color-scheme)=["']?dark["']?\])$/;
+var DARK_MEDIA = /^\(\s*prefers-color-scheme\s*:\s*dark\s*\)$/;
+function enclosing(block) {
+  let media = null;
+  for (let p = block.parent; p && p.type !== "root"; p = p.parent) {
+    if (p.type !== "atrule") return { media, ok: false };
+    const at = p;
+    if (at.name === "layer") continue;
+    if (at.name === "media" && DARK_MEDIA.test(at.params.trim()) && !media) {
+      media = at.params;
+      continue;
+    }
+    return { media, ok: false };
+  }
+  return { media, ok: true };
+}
+function contextOf(block) {
+  const { media, ok } = enclosing(block);
+  if (!ok) return { theme: null, media };
+  if (block.type === "atrule") {
+    const declares = block.name === "theme" && !/\b(inline|reference)\b/.test(block.params);
+    return { theme: declares && !media ? "light" : null, media };
+  }
+  const sel = block.selector.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
+  if (media) return { theme: LIGHT_SEL.test(sel) ? "dark" : null, media };
+  if (LIGHT_SEL.test(sel)) return { theme: "light", media };
+  const first = sel.split(",")[0].trim();
+  return { theme: DARK_FIRST.test(first) ? "dark" : null, media };
+}
+function parse(css, from) {
+  const root = postcss.parse(css, { from });
+  const decls = [];
+  const blocks = { light: [], dark: [] };
+  let dark = null;
+  const take = (block) => {
+    const { theme, media } = contextOf(block);
+    if (!theme) return;
+    blocks[theme].push(block);
+    if (theme === "dark" && !dark && block.type === "rule") dark = { selector: block.selector.replace(/\s+/g, " ").trim(), media };
+    for (const node of block.nodes ?? []) if (node.type === "decl" && node.prop.startsWith("--")) decls.push({ decl: node, theme });
+  };
+  root.walk((node) => {
+    if (node.type === "rule") take(node);
+    else if (node.type === "atrule" && node.name === "theme") take(node);
+  });
+  return { root, decls, blocks, dark };
+}
+var shown = (d) => d ? d.value.trim() + (d.important ? " !important" : "") : null;
+function readText(css, from = "stylesheet.css") {
+  const { decls, dark } = parse(css, from);
+  const tokens = /* @__PURE__ */ new Map();
+  for (const { decl, theme } of decls) {
+    const t = tokens.get(decl.prop) ?? {};
+    t[theme] = shown(decl);
+    tokens.set(decl.prop, t);
+  }
+  return { tokens, dark };
+}
+function check(e) {
+  if (!e || typeof e !== "object") throw new Error("bad edit");
+  if (!THEMES.includes(e.theme)) throw new Error(`unknown theme "${e.theme}"`);
+  if (typeof e.name !== "string" || !/^--[a-zA-Z0-9_-]+$/.test(e.name)) throw new Error(`bad token name "${e.name}"`);
+  if (typeof e.value !== "string" || /[;{}\n\r\\]/.test(e.value) || e.value.length > 2e3) throw new Error(`bad value for ${e.name}`);
+  if (e.value.trim() === "") return;
+  try {
+    const rule = postcss.parse(`a{--x:${e.value}}`).first;
+    if (rule?.type !== "rule" || rule.nodes.length !== 1 || rule.first?.type !== "decl") throw new Error();
+    if (/\/\*/.test(e.value)) throw new Error();
+  } catch {
+    throw new Error(`bad value for ${e.name}: ${e.value}`);
+  }
+}
+function writeText(css, edits, from = "stylesheet.css") {
+  edits.forEach(check);
+  const parsed2 = parse(css, from);
+  const changes = [];
+  const lastPerBlock = (theme, name) => {
+    const m = /* @__PURE__ */ new Map();
+    for (const d of parsed2.decls) if (d.theme === theme && d.decl.prop === name) m.set(d.decl.parent, d);
+    return [...m.values()];
+  };
+  const drop = (d) => {
+    const decl = d.decl, block = decl.parent;
+    const next = decl.next();
+    if (next?.type === "comment" && !/\n/.test(next.raws.before ?? "")) next.remove();
+    if (block.last === decl) {
+      const tail = decl.value.match(/\s*$/)?.[0] ?? "";
+      if (tail && !block.raws.after) {
+        block.raws.after = tail;
+        block.raws.semicolon = true;
+      }
+    }
+    decl.remove();
+    parsed2.decls.splice(parsed2.decls.indexOf(d), 1);
+  };
+  for (const { theme, name, value: raw } of edits) {
+    const important = /\s*!important\s*$/i.test(raw);
+    const value = raw.replace(/\s*!important\s*$/i, "").trim();
+    const all = parsed2.decls.filter((d) => d.theme === theme && d.decl.prop === name);
+    const from2 = shown(all.at(-1)?.decl);
+    const to = value === "" ? null : value + (important ? " !important" : "");
+    if (from2 !== to) changes.push({ name, theme, from: from2, to });
+    if (value === "") {
+      for (const d of all) drop(d);
+      continue;
+    }
+    if (all.length) {
+      for (const { decl } of lastPerBlock(theme, name)) {
+        const kept = decl.raws.value?.raw.match(/\/\*[\s\S]*?\*\//g);
+        const next = value + (decl.value.match(/\s*$/)?.[0] ?? "");
+        decl.value = next;
+        if (kept) decl.raws.value = { value: next, raw: `${value} ${kept.join(" ")}` };
+        decl.important = important;
+      }
+      continue;
+    }
+    if (!parsed2.blocks[theme].length) {
+      const rule = postcss.rule({ selector: theme === "dark" ? ".dark" : ":root" });
+      parsed2.root.append(rule);
+      parsed2.blocks[theme].push(rule);
+    }
+    const firsts = /* @__PURE__ */ new Map();
+    for (const b of parsed2.blocks[theme]) {
+      const k = enclosing(b).media ?? "";
+      if (!firsts.has(k)) firsts.set(k, b);
+    }
+    for (const block of firsts.values()) {
+      const prev = [...block.nodes ?? []].reverse().find((n) => n.type === "decl");
+      const decl = postcss.decl({ prop: name, value, important });
+      if (prev) {
+        const tail = prev.value.match(/\s*$/)?.[0] ?? "";
+        if (tail) {
+          prev.value = prev.value.slice(0, -tail.length);
+          if (!block.raws.after) block.raws.after = tail;
+        }
+        decl.raws.before = prev.raws.before;
+        decl.raws.between = prev.raws.between;
+      }
+      block.raws.semicolon = true;
+      block.append(decl);
+      parsed2.decls.push({ decl, theme });
+    }
+  }
+  const out = parsed2.root.toString();
+  parse(out, from);
+  return { css: out, changes };
+}
+
+// src/server/files.ts
+var parsed = /* @__PURE__ */ new Map();
+function readSheet(file) {
+  const { mtimeMs, size } = statSync(file);
+  const hit = parsed.get(file);
+  if (hit && hit.mtime === mtimeMs && hit.size === size) return hit.sheet;
+  const sheet = readText(readFileSync(file, "utf8"), file);
+  parsed.set(file, { mtime: mtimeMs, size, sheet });
+  return sheet;
+}
+function writeAll(batches) {
+  const planned = [...batches].map(([file, edits]) => {
+    const before = readFileSync(file, "utf8");
+    return { file, before, ...writeText(before, edits, file) };
+  });
+  const done = [];
+  try {
+    for (const p of planned) {
+      writeFileSync(p.file, p.css);
+      done.push(p);
+    }
+  } catch (err) {
+    for (const p of done) {
+      try {
+        writeFileSync(p.file, p.before);
+      } catch {
+      }
+    }
+    throw new Error(`could not write ${planned[done.length]?.file ?? "a stylesheet"}, so nothing was saved: ${err instanceof Error ? err.message : err}`);
+  }
+  return planned.flatMap((p) => p.changes);
+}
+
+// src/server/project.ts
+var SOURCE = /\.(tsx?|jsx?|mjs|cjs|css|scss|vue|svelte|astro|html|mdx?)$/;
+function walk(dir, test, skip, acc = []) {
+  for (const f of readdirSync(dir)) {
+    if (f === "node_modules" || f.startsWith(".")) continue;
+    const p = join(dir, f);
+    if (skip.has(p)) continue;
+    let s;
+    try {
+      s = statSync2(p);
+    } catch {
+      continue;
+    }
+    if (s.isDirectory()) walk(p, test, skip, acc);
+    else if (test.test(f)) acc.push(p);
+  }
+  return acc;
+}
+var KINDS = "bg|text|border-[trblxyse]|border|ring-offset|ring|fill|stroke|from|via|to|outline|shadow|divide|placeholder|caret|decoration|accent";
+var PREFIX = String.raw`(?<![\w-])(?:[\w-]+(?:\[[^\]\s]*\])?:)*`;
+var UTIL = new RegExp(`${PREFIX}(?:${KINDS})-([a-z][\\w-]*?)(?:\\/[\\w.[\\]]+)?(?![\\w-])(?!\\s*:)`, "g");
+var UTIL_VAR = new RegExp(`${PREFIX}(?:${KINDS})-[([](--[\\w-]+)[)\\]]`, "g");
+var VAR = /var\(\s*(--[\w-]+)/g;
+var counted = /* @__PURE__ */ new Map();
+function countIn(path, trusted) {
+  const hit = counted.get(path);
+  if (trusted && hit) return hit.counts;
+  const mtime = statSync2(path).mtimeMs;
+  if (hit && hit.mtime === mtime) return hit.counts;
+  const text = readFileSync2(path, "utf8");
+  const counts = /* @__PURE__ */ new Map();
+  const add = (name) => counts.set(name, (counts.get(name) ?? 0) + 1);
+  const util = (name) => {
+    add(`--${name}`);
+    add(`--color-${name}`);
+  };
+  if (/\.s?css$/.test(path)) {
+    try {
+      postcss2.parse(text, { from: path }).walk((node) => {
+        if (node.type === "decl") {
+          let p = node.parent;
+          while (p && p.type !== "root") {
+            if (p.type === "atrule" && p.name === "theme") return;
+            p = p.parent;
+          }
+          for (const m of node.value.matchAll(VAR)) add(m[1]);
+        } else if (node.type === "atrule" && node.name === "apply") {
+          for (const m of node.params.matchAll(UTIL)) util(m[1]);
+        }
+      });
+    } catch (err) {
+      console.warn(`[swatch] could not count uses in ${path}: ${err}`);
+    }
+  } else {
+    for (const m of text.matchAll(VAR)) add(m[1]);
+    for (const m of text.matchAll(UTIL)) util(m[1]);
+    for (const m of text.matchAll(UTIL_VAR)) add(m[1]);
+  }
+  counted.set(path, { mtime, counts });
+  return counts;
+}
+var Project = class {
+  root;
+  options;
+  /** folders left out of every search, absolute */
+  skip;
+  // Under a dev server its file watcher says what changed, so a read walks
+  // no directories: the lists of stylesheets and sources are kept until a
+  // file is added or removed (or a stylesheet changes, which can give it
+  // tokens or take them away), and a file's use counts until it changes.
+  // Without a watcher (a test, the MCP server) every read looks at the disk.
+  watching = false;
+  sheets = null;
+  sources = null;
+  constructor(root, options = {}, skip = []) {
+    this.root = resolve(root);
+    this.options = options;
+    this.skip = new Set([...skip, "dist", "coverage", ...options.ignore ?? []].map((d) => resolve(this.root, d)));
+  }
+  get src() {
+    return join(this.root, this.options.src ?? "");
+  }
+  watch() {
+    this.watching = true;
+  }
+  /** A file changed (or was added or removed: `listChanged`). */
+  forget(path, listChanged) {
+    counted.delete(path);
+    if (listChanged) this.sources = null;
+    if (listChanged || path.endsWith(".css")) this.sheets = null;
+  }
+  /** The stylesheets that hold tokens: the ones named, or every one in the
+   *  project that declares a custom property on a theme. */
+  stylesheets() {
+    const named = this.options.css;
+    if (named) return [named].flat().map((f) => join(this.root, f)).filter((f) => existsSync(f));
+    if (this.watching && this.sheets) return this.sheets;
+    const found = walk(this.root, /\.css$/, this.skip).filter((f) => {
+      try {
+        return readSheet(f).tokens.size > 0;
+      } catch {
+        return false;
+      }
+    });
+    if (this.watching) this.sheets = found;
+    return found;
+  }
+  read() {
+    const files = this.stylesheets();
+    const tokens = /* @__PURE__ */ new Map();
+    const key = (d) => d ? `${d.media ?? ""}|${d.selector}` : "";
+    const darkOf = /* @__PURE__ */ new Map();
+    const votes = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      let sheet;
+      try {
+        sheet = readSheet(file);
+      } catch (err) {
+        console.warn(`[swatch] could not read ${file}: ${err}`);
+        continue;
+      }
+      for (const [name, v] of sheet.tokens) {
+        const t = tokens.get(name) ?? { name, file: relative(this.root, file), uses: [] };
+        if (v.light !== void 0) {
+          t.light = v.light;
+          t.file = relative(this.root, file);
+        }
+        if (v.dark !== void 0) {
+          t.dark = v.dark;
+          darkOf.set(name, sheet.dark);
+          if (sheet.dark) {
+            const k = key(sheet.dark);
+            votes.set(k, { dark: sheet.dark, n: (votes.get(k)?.n ?? 0) + 1 });
+          }
+        } else if (!darkOf.has(name)) darkOf.set(name, sheet.dark);
+        tokens.set(name, t);
+      }
+    }
+    const dark = [...votes.values()].sort((a, b) => b.n - a.n)[0]?.dark ?? [...darkOf.values()].find(Boolean) ?? null;
+    for (const t of tokens.values()) {
+      const own = darkOf.get(t.name);
+      if (own && key(own) !== key(dark)) t.darkAt = own;
+    }
+    const sources = this.watching && this.sources || walk(this.src, SOURCE, this.skip);
+    if (this.watching) this.sources = sources;
+    for (const path of sources) {
+      for (const [name, n] of countIn(path, this.watching)) tokens.get(name)?.uses.push({ file: relative(this.root, path), n });
+    }
+    const groups = this.options.groups ? Object.entries(this.options.groups).map(([title, re]) => [title, typeof re === "string" ? re : re.source]) : null;
+    return { files: files.map((f) => relative(this.root, f)), tokens: [...tokens.values()], dark, groups, agent: !!this.options.agent };
+  }
+  /** Sends each edit to the stylesheet that holds the token in that theme;
+   *  failing that, the one that holds it in the other theme; failing that
+   *  (a new token), the one with the most tokens. Every edit is checked,
+   *  and every file's new text worked out, before any file is touched. */
+  write(edits) {
+    if (!Array.isArray(edits)) throw new Error("expected a list of edits");
+    edits.forEach(check);
+    const files = this.stylesheets();
+    if (!files.length) throw new Error("no stylesheet with tokens was found: name one with the `css` option");
+    const sheets = files.map((file) => ({ file, tokens: readSheet(file).tokens }));
+    const biggest = [...sheets].sort((a, b) => b.tokens.size - a.tokens.size)[0].file;
+    const holds = (name, theme) => sheets.filter((s) => {
+      const t = s.tokens.get(name);
+      return t && (theme ? t[theme] !== void 0 : true);
+    }).map((s) => s.file);
+    const batches = /* @__PURE__ */ new Map();
+    for (const e of edits) {
+      const here = holds(e.name, e.theme);
+      const targets = here.length ? here : e.value.trim() === "" ? [] : [holds(e.name).at(-1) ?? biggest];
+      for (const f of targets) batches.set(f, [...batches.get(f) ?? [], e]);
+    }
+    const changes = writeAll(batches);
+    const seen = /* @__PURE__ */ new Set();
+    return changes.filter((c) => {
+      const k = `${c.name}|${c.theme}`;
+      if (seen.has(k)) return false;
+      seen.add(k);
+      return true;
+    });
+  }
+};
+
+// src/server/requests.ts
+import { appendFileSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, renameSync, rmSync, statSync as statSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var Queue = class {
+  dir;
+  incoming;
+  constructor(root) {
+    this.dir = join2(root, ".swatch");
+    this.incoming = join2(this.dir, "incoming.json");
+  }
+  /** The queue holds only what was checked field by field: nothing a
+   *  caller adds to the body, and no field of ours a caller can replace. */
+  add(r, files) {
+    let body;
+    if (r?.kind === "commit") {
+      if (!Array.isArray(r.changes) || !r.changes.length || r.changes.length > 2e3) throw new Error("nothing to commit");
+      const text = (v) => v === null || typeof v === "string" && v.length <= 2e3 && !/[\n\r]/.test(v);
+      body = { kind: "commit", changes: r.changes.map((c) => {
+        if (typeof c?.name !== "string" || !/^--[a-zA-Z0-9_-]+$/.test(c.name) || !THEMES.includes(c.theme) || !text(c.from) || !text(c.to)) throw new Error("bad change");
+        return { name: c.name, theme: c.theme, from: c.from, to: c.to };
+      }) };
+    } else if (r?.kind === "figma-sync") {
+      let host = "";
+      try {
+        if (typeof r.figma === "string" && r.figma.length <= 500 && !/\s/.test(r.figma)) {
+          const u = new URL(r.figma);
+          if (u.protocol === "https:") host = u.hostname;
+        }
+      } catch {
+      }
+      if (host !== "figma.com" && host !== "www.figma.com") throw new Error("not a figma.com link");
+      body = { kind: "figma-sync", figma: r.figma };
+    } else throw new Error("unknown request");
+    const id = Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+    const line = { ...body, id, at: (/* @__PURE__ */ new Date()).toISOString(), files };
+    mkdirSync(this.dir, { recursive: true });
+    appendFileSync(join2(this.dir, "requests.jsonl"), JSON.stringify(line) + "\n");
+    return { id: line.id };
+  }
+  /** What the agent left, or null (also while it is half written). */
+  take() {
+    if (!existsSync2(this.incoming)) return null;
+    try {
+      return JSON.parse(readFileSync3(this.incoming, "utf8"));
+    } catch {
+      return null;
+    }
+  }
+  clear() {
+    rmSync(this.incoming, { force: true });
+  }
+  get file() {
+    return join2(this.dir, "requests.jsonl");
+  }
+  // the parsed queue, kept while the file is unchanged: an agent waiting
+  // for a request asks twice a second, and almost always nothing is new
+  seen = null;
+  /** The requests no agent has dealt with yet, oldest first. A request that
+   *  has been dealt with is taken out of the file (below), so the file only
+   *  ever holds what is pending, and stays small. */
+  pending() {
+    if (!existsSync2(this.file)) return [];
+    const { mtimeMs, size } = statSync3(this.file);
+    if (this.seen && this.seen.mtime === mtimeMs && this.seen.size === size) return this.seen.requests;
+    const requests = readFileSync3(this.file, "utf8").split("\n").filter(Boolean).flatMap((l) => {
+      try {
+        return [JSON.parse(l)];
+      } catch {
+        return [];
+      }
+    }).filter((r) => r && typeof r.id === "string");
+    this.seen = { mtime: mtimeMs, size, requests };
+    return requests;
+  }
+  /** Takes a request out of the queue, as dealt with, and notes it (with
+   *  its note) in done.jsonl, which keeps the last hundred. The panel may
+   *  append a request while this rewrites the file: the file is read again
+   *  and the rewrite retried if it grew in between, so no request is lost. */
+  resolve(id, note) {
+    if (!this.pending().some((r) => r.id === id)) throw new Error(`no pending request "${id}"`);
+    for (let attempt = 0; attempt < 5; attempt++) {
+      const text = readFileSync3(this.file, "utf8");
+      const kept = text.split("\n").filter((l) => {
+        if (!l.trim()) return false;
+        try {
+          return JSON.parse(l).id !== id;
+        } catch {
+          return true;
+        }
+      });
+      const tmp = `${this.file}.tmp`;
+      writeFileSync2(tmp, kept.length ? kept.join("\n") + "\n" : "");
+      if (statSync3(this.file).size !== Buffer.byteLength(text)) continue;
+      renameSync(tmp, this.file);
+      this.seen = null;
+      const done = join2(this.dir, "done.jsonl");
+      const log = existsSync2(done) ? readFileSync3(done, "utf8").split("\n").filter(Boolean) : [];
+      log.push(JSON.stringify({ id, at: (/* @__PURE__ */ new Date()).toISOString(), ...note ? { note: String(note).slice(0, 500) } : {} }));
+      writeFileSync2(done, log.slice(-100).join("\n") + "\n");
+      return;
+    }
+    throw new Error("the queue kept changing while it was being updated; try again");
+  }
+  /** Leaves values for the panel to load as unsaved edits: every one
+   *  checked as a write would be, and the file put in place whole, so the
+   *  panel never reads half of it. Returns how many values. */
+  propose(edits, note) {
+    if (!edits || typeof edits !== "object" || Array.isArray(edits)) throw new Error("edits must be an object of token name to { light?, dark? }");
+    const clean = {};
+    let n = 0;
+    for (const [name, values] of Object.entries(edits)) {
+      if (!values || typeof values !== "object") throw new Error(`bad values for ${name}`);
+      for (const theme of THEMES) {
+        const value = values[theme];
+        if (value === void 0) continue;
+        check({ name, theme, value });
+        clean[name] = { ...clean[name], [theme]: value.trim() };
+        n++;
+      }
+    }
+    if (!n) throw new Error("no values to propose");
+    mkdirSync(this.dir, { recursive: true });
+    const tmp = `${this.incoming}.tmp`;
+    writeFileSync2(tmp, JSON.stringify({ edits: clean, ...note ? { note: String(note).slice(0, 300) } : {} }));
+    renameSync(tmp, this.incoming);
+    return n;
+  }
+};
+
+// src/mcp.ts
+var VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+var edit = {
+  type: "object",
+  properties: {
+    name: { type: "string", description: "The custom property, e.g. --card" },
+    theme: { type: "string", enum: ["light", "dark"] },
+    value: { type: "string", description: 'The CSS value, e.g. "#f4f4f6" or "var(--foreground)". An empty string removes the declaration (a dark value removed falls back to the light one).' }
+  },
+  required: ["name", "theme", "value"]
+};
+function tools(project, queue) {
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  return [
+    {
+      name: "swatch_list_tokens",
+      description: "List the project's CSS custom properties in its light and dark themes: each token's value per theme, the stylesheet it is declared in, and how many times it is used. Use this to see the current colours before proposing or writing changes.",
+      inputSchema: { type: "object", properties: {} },
+      run: () => {
+        const sheet = project.read();
+        return {
+          stylesheets: sheet.files,
+          dark: sheet.dark,
+          tokens: sheet.tokens.map((t) => ({ name: t.name, light: t.light ?? null, dark: t.dark ?? null, file: t.file, uses: t.uses.reduce((n, u) => n + u.n, 0) }))
+        };
+      }
+    },
+    {
+      name: "swatch_pending_requests",
+      description: 'List what the person using the Swatch panel has asked for and no agent has dealt with yet. A "commit" request lists stylesheet changes they saved and want committed (each with its token, theme, old and new value). A "figma-sync" request names a Figma file whose colour variables they want pulled in: read them, then call swatch_propose_edits. Call swatch_resolve_request once each is dealt with.',
+      inputSchema: { type: "object", properties: {} },
+      run: () => ({ requests: queue.pending() })
+    },
+    {
+      name: "swatch_wait_for_request",
+      description: "Wait until the person using the Swatch panel asks for something, then return the pending requests. Returns an empty list if nothing arrives within the timeout; call it again to keep waiting.",
+      inputSchema: { type: "object", properties: { timeout_seconds: { type: "number", description: "How long to wait, 1 to 300. Default 60." } } },
+      run: async (args2) => {
+        const limit = Math.min(Math.max(Number(args2.timeout_seconds) || 60, 1), 300) * 1e3;
+        const until = Date.now() + limit;
+        for (; ; ) {
+          const requests = queue.pending();
+          if (requests.length || Date.now() >= until) return { requests };
+          await sleep(500);
+        }
+      }
+    },
+    {
+      name: "swatch_resolve_request",
+      description: "Mark a request from swatch_pending_requests as dealt with, so it is not listed again.",
+      inputSchema: { type: "object", properties: { id: { type: "string" }, note: { type: "string", description: "What was done, in a few words." } }, required: ["id"] },
+      run: (args2) => {
+        queue.resolve(String(args2.id), args2.note === void 0 ? void 0 : String(args2.note));
+        return { resolved: args2.id };
+      }
+    },
+    {
+      name: "swatch_propose_edits",
+      description: "Show colour values in the Swatch panel as unsaved edits: the person sees them previewed live on the page and chooses whether to save. Nothing is written to a stylesheet. Use this to answer a figma-sync request, or to suggest colours. Prefer this over swatch_write_tokens unless you were asked to change the files directly. The dev server must be running for the panel to pick them up.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          edits: { type: "object", description: 'Token name to its values, e.g. { "--card": { "light": "#eeeeee", "dark": "#1d1d22" } }. Give only the themes that change.', additionalProperties: { type: "object", properties: { light: { type: "string" }, dark: { type: "string" } } } },
+          note: { type: "string", description: 'One line the panel shows with them, e.g. "12 values from Figma".' }
+        },
+        required: ["edits"]
+      },
+      run: (args2) => ({ proposed: queue.propose(args2.edits, args2.note === void 0 ? void 0 : String(args2.note)) })
+    },
+    {
+      name: "swatch_write_tokens",
+      description: "Write colour token values straight into the project's stylesheets, leaving every other byte of each file as it was. A value that would break the stylesheet is refused and nothing is written. Returns each change with the old and new value.",
+      inputSchema: { type: "object", properties: { edits: { type: "array", items: edit } }, required: ["edits"] },
+      run: (args2) => ({ changes: project.write(args2.edits) })
+    }
+  ];
+}
+async function handle(msg, all, version2) {
+  const reply = (result) => ({ jsonrpc: "2.0", id: msg.id, result });
+  const fail = (code, message) => ({ jsonrpc: "2.0", id: msg.id ?? null, error: { code, message } });
+  if (msg.id === void 0) return void 0;
+  switch (msg.method) {
+    case "initialize": {
+      const asked = String(msg.params?.protocolVersion ?? "");
+      return reply({
+        protocolVersion: VERSIONS.includes(asked) ? asked : VERSIONS[0],
+        capabilities: { tools: {} },
+        serverInfo: { name: "swatch", version: version2 },
+        instructions: "Swatch is a live colour-token editor in the project's dev server. Call swatch_pending_requests (or swatch_wait_for_request) to see what the person using its panel has asked for."
+      });
+    }
+    case "ping":
+      return reply({});
+    case "tools/list":
+      return reply({ tools: all.map(({ name, description, inputSchema }) => ({ name, description, inputSchema })) });
+    case "tools/call": {
+      const tool = all.find((t) => t.name === msg.params?.name);
+      if (!tool) return fail(-32602, `unknown tool "${msg.params?.name}"`);
+      try {
+        const out = await tool.run(msg.params?.arguments ?? {});
+        return reply({ content: [{ type: "text", text: JSON.stringify(out, null, 2) }] });
+      } catch (err) {
+        return reply({ content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }], isError: true });
+      }
+    }
+    default:
+      return fail(-32601, `method not found: ${msg.method}`);
+  }
+}
+function serve(root, options, version2) {
+  const all = tools(new Project(root, options), new Queue(root));
+  const out = (m) => process.stdout.write(JSON.stringify(m) + "\n");
+  createInterface({ input: process.stdin }).on("line", async (line) => {
+    if (!line.trim()) return;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return out({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } });
+    }
+    const answer = await handle(msg, all, version2);
+    if (answer) out(answer);
+  });
+}
+
+// src/cli.ts
+var args = process.argv.slice(2);
+var flag = (name) => {
+  const i = args.indexOf(`--${name}`);
+  return i >= 0 ? args[i + 1] : void 0;
+};
+var version = JSON.parse(readFileSync4(new URL("../package.json", import.meta.url), "utf8")).version;
+if (args[0] === "mcp") {
+  const css = flag("css")?.split(",").filter(Boolean);
+  serve(flag("root") ?? process.cwd(), { css, src: flag("src") }, version);
+} else if (args[0] === "--version" || args[0] === "-v") {
+  console.log(version);
+} else {
+  console.error(`swatch ${version}
+
+Usage:
+  npx swatch-token mcp [--root <dir>] [--css <file>[,<file>]] [--src <dir>]
+      Run the MCP server for a coding agent, from the project root.
+
+The panel itself is a Vite plugin: import swatch from "swatch-token/vite".`);
+  process.exit(args.length ? 1 : 0);
+}