@drawpro/mcp 0.1.0 → 0.2.0

package/README.md

@@ -6,11 +6,18 @@ account from Claude Code, Claude Desktop, or any MCP client.
 ## Setup
 
 ```bash
-claude mcp add drawpro -e DRAWPRO_TOKEN="dp_live_..." -- npx -y @drawpro/mcp
+claude mcp add drawpro --scope user -e DRAWPRO_TOKEN="dp_live_..." -- npx -y @drawpro/mcp
 ```
 
 Mint the token in DrawPro under **Connect to Claude Code**.
 
+`--scope user` registers it for every project on your machine. The scope
+otherwise defaults to `local`, which loads the server only in the directory the
+command was run in — diagramming is not a property of one repo, so that default
+is almost never what you want here. Avoid `--scope project`: it writes
+`.mcp.json` into whichever repo you are standing in, token included, where it
+invites being committed.
+
 To read existing sheets, unlock the account once:
 
 ```bash
@@ -67,7 +74,24 @@ passcode itself.
 | `read_sheet` | yes | returns a readable outline, not raw scene JSON |
 | `validate_spec` | no | no side effects; check before writing |
 | `create_diagram` | no | returns a link to the new sheet |
-| `update_diagram` | no | replaces the sheet wholesale |
+| `update_diagram` | no | replaces the sheet wholesale — regenerates layout |
+| `edit_sheet_text` | yes | rewrites named text in place, preserving every other element |
+
+### Editing a sheet a person drew
+
+`update_diagram` builds the scene from a spec, so layout is derived and
+hand-placed content cannot survive it: text elements positioned by hand, region
+containers, and unbound annotation arrows all disappear, and the sheet comes
+back as an auto-laid-out graph. Correct content, different diagram.
+
+Use `edit_sheet_text` for those sheets. It reads the scene, rewrites only the
+strings you name, and writes every other element back byte for byte — so
+coordinates, groupings, and annotations are untouched. Edits apply
+all-or-nothing: if any `find` matches nothing, the sheet is left alone rather
+than half-updated.
+
+`update_diagram` remains the right tool for sheets this package generated, where
+regenerating the layout is the point.
 
 `read_sheet` deliberately returns shapes and edges rather than Excalidraw JSON.
 A real sheet's raw scene runs to tens of thousands of characters of coordinates,

package/dist/server.js

@@ -337,23 +337,51 @@ function forgetKey(email) {
 }
 
 // ../client/src/prompt.ts
-var import_node_readline = require("node:readline");
-var CLEAR_LINE = "\x1B[2K\x1B[200D";
 function askHidden(question) {
   return new Promise((resolve) => {
-    const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout, terminal: true });
+    const input = process.stdin;
     process.stdout.write(question);
-    const onData = () => {
-      const typed = rl.line ?? "";
-      process.stdout.write(CLEAR_LINE + question + "*".repeat(typed.length));
-    };
-    process.stdin.on("data", onData);
-    rl.question("", (answer) => {
-      process.stdin.removeListener("data", onData);
-      rl.close();
+    if (!input.isTTY) {
+      let buffered = "";
+      input.setEncoding("utf8");
+      input.on("data", (chunk) => {
+        buffered += chunk;
+      });
+      input.on("end", () => resolve(buffered.split("\n")[0].trim()));
+      return;
+    }
+    const wasRaw = input.isRaw;
+    input.setRawMode(true);
+    input.resume();
+    input.setEncoding("utf8");
+    let value = "";
+    const finish = (result) => {
+      input.removeListener("data", onData);
+      input.setRawMode(wasRaw);
+      input.pause();
       process.stdout.write("\n");
-      resolve(answer);
-    });
+      if (result === null) {
+        process.exit(130);
+      }
+      resolve(result);
+    };
+    const onData = (chunk) => {
+      for (const ch of chunk) {
+        if (ch === "\r" || ch === "\n") return finish(value);
+        if (ch === "") return finish(null);
+        if (ch === "\x7F" || ch === "\b") {
+          if (value.length > 0) {
+            value = value.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+          continue;
+        }
+        if (ch < " ") continue;
+        value += ch;
+        process.stdout.write("*");
+      }
+    };
+    input.on("data", onData);
   });
 }
 
@@ -1300,7 +1328,7 @@ function api() {
     const token = process.env.DRAWPRO_TOKEN;
     if (!token) {
       throw new ConfigError(
-        'DRAWPRO_TOKEN is not set. Create a token in DrawPro under "Connect to Claude Code", then:\n  claude mcp add drawpro -e DRAWPRO_TOKEN="dp_live_..." -- npx -y @drawpro/mcp'
+        'DRAWPRO_TOKEN is not set. Create a token in DrawPro under "Connect to Claude Code", then:\n  claude mcp add drawpro --scope user -e DRAWPRO_TOKEN="dp_live_..." -- npx -y @drawpro/mcp'
       );
     }
     clientInstance = new DrawProClient(BASE_URL, token);
@@ -1523,6 +1551,62 @@ async function login(forget) {
   console.log(`Unlocked ${user.email}. Key stored in the ${location}.`);
   console.log("Claude can now read your sheets. The passcode was not stored or sent anywhere.");
 }
+server.tool(
+  "edit_sheet_text",
+  "Correct the wording on an existing sheet without redrawing it. Use this for any sheet a person drew: update_diagram regenerates layout from a spec, so it discards hand-placed elements, region containers, and unbound annotations. This rewrites only the text you name and leaves every other element, and every coordinate, exactly as it was.",
+  {
+    workspace_id: import_zod.z.string(),
+    sheet_id: import_zod.z.string(),
+    edits: import_zod.z.array(
+      import_zod.z.object({
+        find: import_zod.z.string().describe("The element's exact current text, as read_sheet reports it"),
+        replace: import_zod.z.string()
+      })
+    ).describe("Applied all-or-nothing: if any find has no match, nothing is written.")
+  },
+  async ({ workspace_id, sheet_id, edits }) => {
+    const unlocked = await unlockedKey();
+    if ("error" in unlocked) return text(unlocked.error);
+    const scene = await api().readSheet(workspace_id, sheet_id, unlocked.key);
+    const elements = scene.elements;
+    const counts = /* @__PURE__ */ new Map();
+    for (const el of elements) {
+      if (el.type !== "text") continue;
+      const current = (el.originalText ?? el.text)?.trim();
+      if (current === void 0) continue;
+      const edit = edits.find((e) => e.find.trim() === current);
+      if (!edit) continue;
+      el.text = edit.replace;
+      el.originalText = edit.replace;
+      const metrics = measureText(edit.replace, el.fontSize ?? 20, 1e3);
+      el.width = metrics.width;
+      el.height = metrics.height;
+      el.version = (el.version ?? 1) + 1;
+      el.versionNonce = Math.floor(Math.random() * 2 ** 31);
+      el.updated = Date.now();
+      counts.set(edit.find, (counts.get(edit.find) ?? 0) + 1);
+    }
+    const missed = edits.filter((e) => !counts.has(e.find));
+    if (missed.length > 0) {
+      return text(
+        "Nothing was written. These strings matched no text element:\n" + missed.map((e) => `  ${JSON.stringify(e.find)}`).join("\n") + "\n\nRun read_sheet and copy the text exactly as it appears there."
+      );
+    }
+    const user = await currentUser();
+    await api().updateSheet(
+      workspace_id,
+      sheet_id,
+      { name: scene.name, elements, appState: scene.appState },
+      user.publicKey
+    );
+    const applied = [...counts.entries()].map(([find, n]) => `  ${JSON.stringify(find)} -> ${n} element${n === 1 ? "" : "s"}`).join("\n");
+    return text(
+      `Updated "${scene.name}". ${elements.length} elements preserved; only the text below changed.
+${applied}
+${sheetUrl(workspace_id, sheet_id)}`
+    );
+  }
+);
 async function main() {
   const command = process.argv[2];
   if (command === "login") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drawpro/mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "MCP server for DrawPro \u2014 read and create end-to-end encrypted Excalidraw diagrams from Claude",
   "license": "MIT",
   "repository": {