@dadaki/mcp 1.0.0-beta.1 → 1.0.0-beta.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dadaki
+
+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

@@ -248,10 +248,25 @@ survive the feature being broken.
 ```bash
 pnpm test                                     # agent API unit tests
 pnpm --filter @dadaki/mcp smoke               # full MCP round-trip, every tool
+pnpm --filter @dadaki/mcp smoke:bundle        # the same, against the published bundle
 pnpm --filter @dadaki/mcp smoke:bridge        # bridge mode, incl. its security rules
 pnpm --filter @dadaki/mcp smoke:modes <dir>   # every mode; <dir> holds cert.pem/key.pem
+pnpm --filter @dadaki/mcp smoke:offline       # relay economics, against a stand-in backend
+pnpm --filter @dadaki/mcp smoke:relay         # relay against a real deployment
 ```
 
+**`smoke:bundle` matters more than it looks.** What npm ships is not these
+sources — it is one esbuild output with every dependency inlined and a
+`createRequire` shim. A test that only runs `src/` cannot see a bundling
+failure, and a bundling failure reaches users as a broken install. Every smoke
+test takes `DADAKI_MCP_TEST_BUNDLE=1` and runs against `dist/index.js` instead.
+
+**`smoke:offline` counts requests.** Against a real deployment you cannot tell
+whether a tool call cost one HTTP round-trip or two, and that difference is the
+whole latency of a drawing loop. A stand-in backend can also refuse a pairing
+code or vanish entirely on demand, which is how the failure messages get tested
+at all.
+
 The unit tests cover the agent API against the real WASM engine. The smoke tests
 cover what only exists assembled: the MCP handshake, each transport, CanvasKit
 booting, and rendering.

package/dist/index.js

@@ -14501,7 +14501,7 @@ function cleanParams(params, data) {
   const p2 = typeof p === "string" ? { message: p } : p;
   return p2;
 }
-function custom(check2, _params = {}, fatal) {
+function custom(check2, _params = {}, fatal2) {
   if (check2)
     return ZodAny.create().superRefine((data, ctx) => {
       const r = check2(data);
@@ -14509,14 +14509,14 @@ function custom(check2, _params = {}, fatal) {
         return r.then((r2) => {
           if (!r2) {
             const params = cleanParams(_params, data);
-            const _fatal = params.fatal ?? fatal ?? true;
+            const _fatal = params.fatal ?? fatal2 ?? true;
             ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
           }
         });
       }
       if (!r) {
         const params = cleanParams(_params, data);
-        const _fatal = params.fatal ?? fatal ?? true;
+        const _fatal = params.fatal ?? fatal2 ?? true;
         ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
       }
       return;
@@ -15146,10 +15146,10 @@ function prefixIssues(path, issues) {
 function unwrapMessage(message) {
   return typeof message === "string" ? message : message?.message;
 }
-function finalizeIssue(iss, ctx, config3) {
+function finalizeIssue(iss, ctx, config2) {
   const full = { ...iss, path: iss.path ?? [] };
   if (!iss.message) {
-    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config3.customError?.(iss)) ?? unwrapMessage(config3.localeError?.(iss)) ?? "Invalid input";
+    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
     full.message = message;
   }
   delete full.inst;
@@ -23894,13 +23894,13 @@ var ExperimentalMcpServerTasks = class {
   constructor(_mcpServer) {
     this._mcpServer = _mcpServer;
   }
-  registerToolTask(name, config3, handler) {
-    const execution = { taskSupport: "required", ...config3.execution };
+  registerToolTask(name, config2, handler) {
+    const execution = { taskSupport: "required", ...config2.execution };
     if (execution.taskSupport === "forbidden") {
       throw new Error(`Cannot register task-based tool '${name}' with taskSupport 'forbidden'. Use registerTool() instead.`);
     }
     const mcpServerInternal = this._mcpServer;
-    return mcpServerInternal._createRegisteredTool(name, config3.title, config3.description, config3.inputSchema, config3.outputSchema, config3.annotations, execution, config3._meta, handler);
+    return mcpServerInternal._createRegisteredTool(name, config2.title, config2.description, config2.inputSchema, config2.outputSchema, config2.annotations, execution, config2._meta, handler);
   }
 };
 
@@ -24329,12 +24329,12 @@ var McpServer = class {
       return registeredResourceTemplate;
     }
   }
-  registerResource(name, uriOrTemplate, config3, readCallback) {
+  registerResource(name, uriOrTemplate, config2, readCallback) {
     if (typeof uriOrTemplate === "string") {
       if (this._registeredResources[uriOrTemplate]) {
         throw new Error(`Resource ${uriOrTemplate} is already registered`);
       }
-      const registeredResource = this._createRegisteredResource(name, config3.title, uriOrTemplate, config3, readCallback);
+      const registeredResource = this._createRegisteredResource(name, config2.title, uriOrTemplate, config2, readCallback);
       this.setResourceRequestHandlers();
       this.sendResourceListChanged();
       return registeredResource;
@@ -24342,7 +24342,7 @@ var McpServer = class {
       if (this._registeredResourceTemplates[name]) {
         throw new Error(`Resource template ${name} is already registered`);
       }
-      const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, config3.title, uriOrTemplate, config3, readCallback);
+      const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, config2.title, uriOrTemplate, config2, readCallback);
       this.setResourceRequestHandlers();
       this.sendResourceListChanged();
       return registeredResourceTemplate;
@@ -24540,11 +24540,11 @@ var McpServer = class {
   /**
    * Registers a tool with a config object and callback.
    */
-  registerTool(name, config3, cb) {
+  registerTool(name, config2, cb) {
     if (this._registeredTools[name]) {
       throw new Error(`Tool ${name} is already registered`);
     }
-    const { title, description, inputSchema, outputSchema, annotations, _meta } = config3;
+    const { title, description, inputSchema, outputSchema, annotations, _meta } = config2;
     return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, _meta, cb);
   }
   prompt(name, ...rest) {
@@ -24568,11 +24568,11 @@ var McpServer = class {
   /**
    * Registers a prompt with a config object and callback.
    */
-  registerPrompt(name, config3, cb) {
+  registerPrompt(name, config2, cb) {
     if (this._registeredPrompts[name]) {
       throw new Error(`Prompt ${name} is already registered`);
     }
-    const { title, description, argsSchema } = config3;
+    const { title, description, argsSchema } = config2;
     const registeredPrompt = this._createRegisteredPrompt(name, title, description, argsSchema, cb);
     this.setPromptRequestHandlers();
     this.sendPromptListChanged();
@@ -24832,6 +24832,8 @@ var BridgeTransport = class {
   opts;
   /** Resolves when an editor attaches; replaced after each disconnect. */
   attached;
+  /** Has an editor ever held this bridge? Decides how patient `call` is. */
+  seenEditor = false;
   markAttached;
   constructor(opts) {
     this.opts = opts;
@@ -24890,6 +24892,7 @@ var BridgeTransport = class {
         return;
       }
       this.socket = ws;
+      this.seenEditor = true;
       this.markAttached();
       console.error("[dadaki-mcp] editor attached");
       ws.on("message", (raw) => {
@@ -24924,7 +24927,7 @@ var BridgeTransport = class {
   async call(method, args = []) {
     await this.listen();
     if (!this.socket || this.socket.readyState !== this.socket.OPEN) {
-      const wait = this.opts.attachTimeoutMs ?? 12e4;
+      const wait = this.opts.attachTimeoutMs ?? (this.seenEditor ? 45e3 : 4e3);
       const timedOut = /* @__PURE__ */ Symbol("timeout");
       let timer;
       const race = await Promise.race([
@@ -25049,11 +25052,10 @@ var RelayTransport = class {
       await new Promise((r) => setTimeout(r, 1e3));
     }
   }
-  async call(method, args = []) {
-    if (!await this.attached()) await this.waitForEditor();
-    let res;
+  /** One call attempt. Network failures are the transport's own error. */
+  async post(method, args) {
     try {
-      res = await fetch(`${this.base}/call`, {
+      return await fetch(`${this.base}/call`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ token: this.opts.token, method, args }),
@@ -25064,12 +25066,20 @@ var RelayTransport = class {
         `could not reach the relay at ${this.base} (${err.message})`
       );
     }
+  }
+  async call(method, args = []) {
+    let res = await this.post(method, args);
+    if (res.status === 409) {
+      await this.waitForEditor();
+      res = await this.post(method, args);
+    }
     if (res.status === 409) {
       throw new AgentCallError("no editor is attached to this session");
     }
     if (!res.ok) {
       throw new AgentCallError(`relay returned ${res.status} for ${method}`);
     }
+    this.seenEditor = true;
     return unwrap(await res.json());
   }
   async close() {
@@ -25201,8 +25211,13 @@ async function createTransport(cfg) {
 }
 
 // src/index.ts
-var config2 = readConfig();
-var { transport: session, notice } = await createTransport(config2);
+function fatal(err) {
+  console.error(err?.message ?? String(err));
+  process.exit(1);
+}
+var { transport: session, notice } = await (async () => createTransport(readConfig()))().catch(
+  fatal
+);
 console.error(notice);
 var INSTRUCTIONS = `Dadaki is a real vector editor. You are drawing actual
 vector geometry \u2014 paths, gradients, live text \u2014 not describing an image for
@@ -25660,4 +25675,7 @@ var shutdown = async () => {
 };
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
-await server.connect(new StdioServerTransport());
+var stdio = new StdioServerTransport();
+stdio.onclose = shutdown;
+process.stdin.on("end", shutdown);
+await server.connect(stdio);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dadaki/mcp",
-    "version": "1.0.0-beta.1",
+    "version": "1.0.0-beta.2",
     "description": "MCP server that lets an agent author vector artwork in Dadaki — intent-level drawing verbs plus render-back so the agent can see its own work.",
     "license": "MIT",
     "type": "module",
@@ -27,6 +27,7 @@
     },
     "files": [
         "dist",
+        "LICENSE",
         "README.md"
     ],
     "engines": {
@@ -43,7 +44,9 @@
         "smoke": "node --experimental-strip-types smoke.ts",
         "smoke:bridge": "node --experimental-strip-types smoke_bridge.ts",
         "smoke:modes": "node --experimental-strip-types smoke_modes.ts",
-        "smoke:relay": "node smoke_relay.mjs"
+        "smoke:relay": "node smoke_relay.mjs",
+        "smoke:offline": "node --experimental-strip-types smoke_relay_offline.ts",
+        "smoke:bundle": "node build.mjs && DADAKI_MCP_TEST_BUNDLE=1 node --experimental-strip-types smoke.ts"
     },
     "devDependencies": {
         "@modelcontextprotocol/sdk": "^1.22.0",