@mylasertools/kerfscript-mcp 0.0.0-stage → 0.1.1

package/dist/chunk-O5LBJLFO.js

@@ -0,0 +1,23 @@
+// src/budget.ts
+var DAY = 864e5;
+var secondsToMidnight = (now = Date.now()) => Math.ceil((DAY - now % DAY) / 1e3);
+async function spend(storage, client, clientLimit, totalLimit, now = Date.now()) {
+  const day = new Date(now).toISOString().slice(0, 10);
+  const key = `client:${client}`;
+  const stored = await storage.get(["day", "total", key]);
+  if (stored.get("day") !== day) {
+    await storage.deleteAll();
+    stored.clear();
+  }
+  const total = Number(stored.get("total") ?? 0);
+  const used = Number(stored.get(key) ?? 0);
+  if (!(total < totalLimit)) return "total";
+  if (!(used < clientLimit)) return "client";
+  await storage.put({ day, total: total + 1, [key]: used + 1 });
+  return "ok";
+}
+
+export {
+  secondsToMidnight,
+  spend
+};

package/dist/chunk-T5JFV7HE.js

@@ -0,0 +1,154 @@
+// src/isolated.ts
+import { Worker } from "node:worker_threads";
+var failure = (message) => ({ ok: false, error: { message } });
+function createExecutorPool({
+  size = 2,
+  maxQueue = 16,
+  timeoutMs = 5e3,
+  queueTimeoutMs = 5e3,
+  startupTimeoutMs = 5e3,
+  workerUrl = new URL("./runner.js", import.meta.url)
+} = {}) {
+  for (const n of [size, maxQueue, timeoutMs, queueTimeoutMs, startupTimeoutMs])
+    if (!Number.isSafeInteger(n) || n < 1)
+      throw new Error("Pool limits must be positive integers.");
+  const slots = /* @__PURE__ */ new Set();
+  const queue = [];
+  const terminations = /* @__PURE__ */ new Set();
+  let closed = false;
+  function finish(item, result) {
+    clearTimeout(item.timer);
+    item.signal?.removeEventListener("abort", item.cancel);
+    item.resolve(result);
+  }
+  function retire(slot, message) {
+    if (slot.retiring) return;
+    slot.retiring = true;
+    clearTimeout(slot.startup);
+    if (slot.item) {
+      finish(slot.item, failure(message));
+      slot.item = void 0;
+    }
+    const done = () => {
+      slots.delete(slot);
+      terminations.delete(stopped);
+      pump();
+    };
+    const stopped = slot.worker.terminate().then(done, done);
+    terminations.add(stopped);
+  }
+  function start(slot) {
+    const item = slot.item;
+    if (!slot.ready || !item || slot.retiring) return;
+    clearTimeout(item.timer);
+    item.timer = setTimeout(
+      () => retire(
+        slot,
+        "Rendering exceeded its execution deadline. Reduce complexity or render locally."
+      ),
+      timeoutMs
+    );
+    try {
+      slot.worker.postMessage(item.job);
+    } catch {
+      retire(slot, "Unable to send the job to the renderer.");
+    }
+  }
+  function spawn() {
+    const worker = new Worker(workerUrl, {
+      resourceLimits: { maxOldGenerationSizeMb: 96, stackSizeMb: 4 }
+    });
+    const slot = { worker, ready: false, retiring: false };
+    slots.add(slot);
+    slot.startup = setTimeout(() => retire(slot, "Renderer startup timed out."), startupTimeoutMs);
+    worker.on("message", (result) => {
+      if (slot.retiring) return;
+      if (!slot.ready) {
+        if (result.ready !== true) {
+          retire(slot, "Invalid renderer startup response.");
+          return;
+        }
+        slot.ready = true;
+        clearTimeout(slot.startup);
+        start(slot);
+        return;
+      }
+      if (!slot.item) {
+        retire(slot, "Unexpected renderer response.");
+        return;
+      }
+      finish(slot.item, result);
+      slot.item = void 0;
+      worker.unref();
+      pump();
+    });
+    worker.on("error", () => retire(slot, "Renderer exceeded its resources or failed."));
+    worker.on("exit", () => retire(slot, "Renderer stopped before returning a result."));
+    return slot;
+  }
+  function pump() {
+    while (!closed && queue.length) {
+      let slot = [...slots].find((s) => !s.retiring && !s.item);
+      if (!slot && slots.size >= size) return;
+      const item = queue.shift();
+      try {
+        slot ??= spawn();
+      } catch {
+        finish(item, failure("Unable to start renderer."));
+        continue;
+      }
+      clearTimeout(item.timer);
+      slot.item = item;
+      slot.worker.ref();
+      start(slot);
+    }
+  }
+  const execute = (job, signal) => {
+    if (closed) return Promise.resolve(failure("Renderer pool is closed."));
+    if (signal?.aborted) return Promise.resolve(failure("Cancelled."));
+    if (queue.length >= maxQueue)
+      return Promise.resolve(failure("Renderer queue is full. Retry later."));
+    return new Promise((resolve) => {
+      const item = {
+        job,
+        resolve,
+        signal,
+        cancel: () => {
+          const index = queue.indexOf(item);
+          if (index >= 0) {
+            queue.splice(index, 1);
+            finish(item, failure("Cancelled."));
+          } else {
+            const slot = [...slots].find((s) => s.item === item);
+            if (slot) retire(slot, "Cancelled.");
+          }
+        }
+      };
+      item.timer = setTimeout(() => {
+        const index = queue.indexOf(item);
+        if (index >= 0) {
+          queue.splice(index, 1);
+          finish(item, failure("Renderer queue wait timed out. Retry later."));
+        }
+      }, queueTimeoutMs);
+      signal?.addEventListener("abort", item.cancel, { once: true });
+      queue.push(item);
+      pump();
+    });
+  };
+  return {
+    execute,
+    async close() {
+      closed = true;
+      for (const item of queue.splice(0)) finish(item, failure("Renderer pool is closed."));
+      for (const slot of slots) retire(slot, "Renderer pool is closed.");
+      await Promise.all(terminations);
+    }
+  };
+}
+var isolatedExecute = createExecutorPool().execute;
+
+export {
+  createExecutorPool,
+  isolatedExecute
+};

package/dist/chunk-Z46EXYJU.js

@@ -0,0 +1,32 @@
+import {
+  MAX_REPLY
+} from "./chunk-7I3ZJGJF.js";
+
+// src/replies.ts
+var envelope = (result) => ({
+  content: [{ type: "text", text: JSON.stringify(result) }],
+  structuredContent: result,
+  ...result.ok === false ? { isError: true } : {}
+});
+function reply(result) {
+  const response = envelope(result);
+  if (new TextEncoder().encode(JSON.stringify(response)).length <= MAX_REPLY) return response;
+  return envelope({
+    ok: false,
+    error: {
+      message: "Reply exceeds the MCP output limit. Reduce the design or render locally with the KerfScript package."
+    }
+  });
+}
+function page(text, offset, length = 12e3) {
+  const insidePair = (i) => i > 0 && /[\uD800-\uDBFF]/.test(text[i - 1] ?? "") && /[\uDC00-\uDFFF]/.test(text[i] ?? "");
+  const start = insidePair(offset) ? offset - 1 : offset;
+  let end = Math.min(start + length, text.length);
+  if (insidePair(end)) end--;
+  return { text: text.slice(start, end), nextOffset: end < text.length ? end : null };
+}
+
+export {
+  reply,
+  page
+};

package/dist/execute.js

@@ -0,0 +1,8 @@
+import {
+  execute
+} from "./chunk-6NSCAH6P.js";
+import "./chunk-7I3ZJGJF.js";
+import "./chunk-IY7POWTF.js";
+export {
+  execute
+};

package/dist/isolated.js

@@ -0,0 +1,9 @@
+import {
+  createExecutorPool,
+  isolatedExecute
+} from "./chunk-T5JFV7HE.js";
+import "./chunk-IY7POWTF.js";
+export {
+  createExecutorPool,
+  isolatedExecute
+};

package/dist/replies.js

@@ -0,0 +1,10 @@
+import {
+  page,
+  reply
+} from "./chunk-Z46EXYJU.js";
+import "./chunk-7I3ZJGJF.js";
+import "./chunk-IY7POWTF.js";
+export {
+  page,
+  reply
+};

package/dist/runner.js

@@ -0,0 +1,10 @@
+import {
+  execute
+} from "./chunk-6NSCAH6P.js";
+import "./chunk-7I3ZJGJF.js";
+import "./chunk-IY7POWTF.js";
+
+// src/runner.ts
+import { parentPort } from "node:worker_threads";
+parentPort.on("message", (job) => parentPort.postMessage(execute(job)));
+parentPort.postMessage({ ready: true });

package/dist/service.js

@@ -0,0 +1,39 @@
+import {
+  handleRequest,
+  worker_default
+} from "./chunk-43YRASDL.js";
+import {
+  spend
+} from "./chunk-O5LBJLFO.js";
+import "./chunk-JUDNQ5QA.js";
+import "./chunk-6NSCAH6P.js";
+import "./chunk-Z46EXYJU.js";
+import "./chunk-7I3ZJGJF.js";
+import "./chunk-IY7POWTF.js";
+
+// src/service.ts
+import { DurableObject, WorkerEntrypoint } from "cloudflare:workers";
+var KerfScriptService = class extends WorkerEntrypoint {
+  fetchForCaller(request, caller) {
+    if (typeof caller !== "string" || !caller.trim())
+      return new Response("A stable caller identity is required.", { status: 400 });
+    return handleRequest(request, this.env, caller);
+  }
+};
+var DailyBudget = class extends DurableObject {
+  spend(pool, client) {
+    return spend(
+      this.ctx.storage,
+      client,
+      Number(this.env.DAILY_CLIENT_LIMIT),
+      Number(
+        pool === "service" ? this.env.SERVICE_DAILY_REQUEST_LIMIT : this.env.DAILY_REQUEST_LIMIT
+      )
+    );
+  }
+};
+export {
+  DailyBudget,
+  KerfScriptService,
+  worker_default as default
+};

package/dist/stdio.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import {
+  createKerfScriptServer
+} from "./chunk-JUDNQ5QA.js";
+import {
+  isolatedExecute
+} from "./chunk-T5JFV7HE.js";
+import "./chunk-Z46EXYJU.js";
+import "./chunk-7I3ZJGJF.js";
+import "./chunk-IY7POWTF.js";
+
+// src/stdio.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+await createKerfScriptServer(isolatedExecute).connect(new StdioServerTransport());

package/dist/tools.js

@@ -0,0 +1,11 @@
+import {
+  createKerfScriptServer,
+  registerKerfScriptTools
+} from "./chunk-JUDNQ5QA.js";
+import "./chunk-Z46EXYJU.js";
+import "./chunk-7I3ZJGJF.js";
+import "./chunk-IY7POWTF.js";
+export {
+  createKerfScriptServer,
+  registerKerfScriptTools
+};

package/dist/types/src/budget.d.ts

@@ -0,0 +1,14 @@
+export type Pool = 'public' | 'service';
+export type Spend = 'ok' | 'client' | 'total';
+export interface BudgetStorage {
+    get<T>(keys: string[]): Promise<Map<string, T>>;
+    put<T>(entries: Record<string, T>): Promise<void>;
+    deleteAll(): Promise<void>;
+}
+export declare const secondsToMidnight: (now?: number) => number;
+/**
+ * Counts one request against a client's and the service's allowance for the UTC
+ * day. A Durable Object runs this one request at a time. Limits that are not
+ * numbers refuse every request, so a configuration mistake cannot remove the cap.
+ */
+export declare function spend(storage: BudgetStorage, client: string, clientLimit: number, totalLimit: number, now?: number): Promise<Spend>;

package/dist/types/src/execute.d.ts

@@ -0,0 +1,2 @@
+import { type Job, type Result } from './schema.js';
+export declare function execute(job: Job): Result;

package/dist/types/src/isolated.d.ts

@@ -0,0 +1,14 @@
+import type { Executor } from './schema.js';
+/** Create a pool per host or tenant. Idle workers do not keep Node running. */
+export declare function createExecutorPool({ size, maxQueue, timeoutMs, queueTimeoutMs, startupTimeoutMs, workerUrl, }?: {
+    size?: number | undefined;
+    maxQueue?: number | undefined;
+    timeoutMs?: number | undefined;
+    queueTimeoutMs?: number | undefined;
+    startupTimeoutMs?: number | undefined;
+    workerUrl?: URL | undefined;
+}): {
+    execute: Executor;
+    close(): Promise<void>;
+};
+export declare const isolatedExecute: Executor;

package/dist/types/src/replies.d.ts

@@ -0,0 +1,13 @@
+import { type Result } from './schema.js';
+export declare function reply(result: Result): {
+    isError?: boolean | undefined;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: Result;
+};
+export declare function page(text: string, offset: number, length?: number): {
+    text: string;
+    nextOffset: number | null;
+};

package/dist/types/src/runner.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/schema.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const MAX_SOURCE = 64000;
+export declare const MAX_REPLY = 1000000;
+export declare const sourceSchema: z.ZodString;
+export declare const renderSchema: z.ZodObject<{
+    source: z.ZodString;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean, z.ZodArray<z.ZodNumber>]>>>;
+    libraries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    format: z.ZodDefault<z.ZodEnum<{
+        svg: "svg";
+        dxf: "dxf";
+    }>>;
+    sheet: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    kerf: z.ZodOptional<z.ZodNumber>;
+    gap: z.ZodOptional<z.ZodNumber>;
+    margin: z.ZodOptional<z.ZodNumber>;
+    layout: z.ZodDefault<z.ZodEnum<{
+        pack: "pack";
+        none: "none";
+    }>>;
+}, z.core.$strict>;
+export type RenderInput = z.infer<typeof renderSchema>;
+export type Job = {
+    operation: 'render';
+    input: RenderInput;
+} | {
+    operation: 'parameters';
+    source: string;
+};
+export type Result = {
+    [key: string]: unknown;
+};
+export type Executor = (job: Job, signal?: AbortSignal) => Promise<Result>;

package/dist/types/src/service.d.ts

@@ -0,0 +1,9 @@
+import { DurableObject, WorkerEntrypoint } from 'cloudflare:workers';
+import { type Pool } from './budget.js';
+export { default } from './worker.js';
+export declare class KerfScriptService extends WorkerEntrypoint<Env> {
+    fetchForCaller(request: Request, caller: string): Response | Promise<Response>;
+}
+export declare class DailyBudget extends DurableObject<Env> {
+    spend(pool: Pool, client: string): Promise<import("./budget.js").Spend>;
+}

package/dist/types/src/stdio.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/tools.d.ts

@@ -0,0 +1,5 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type Executor } from './schema.js';
+/** Register on an existing MyLaserTools McpServer. The host supplies isolated execution. */
+export declare function registerKerfScriptTools(server: McpServer, execute: Executor): void;
+export declare function createKerfScriptServer(execute: Executor): McpServer;

package/dist/types/src/worker.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The address a public client is limited by. One IPv6 subscriber usually holds a
+ * whole /64, so its addresses share one allowance. An IPv4 address written as
+ * IPv6 counts as that IPv4 address.
+ */
+export declare function clientAddress(ip: string): string;
+export declare function handleRequest(request: Request, env: Env, caller?: string): Promise<Response>;
+declare const _default: {
+    fetch: (request: Request<unknown, IncomingRequestCfProperties<unknown>>, env: Env) => Promise<Response>;
+};
+export default _default;

package/dist/worker.js

@@ -0,0 +1,16 @@
+import {
+  clientAddress,
+  handleRequest,
+  worker_default
+} from "./chunk-43YRASDL.js";
+import "./chunk-O5LBJLFO.js";
+import "./chunk-JUDNQ5QA.js";
+import "./chunk-6NSCAH6P.js";
+import "./chunk-Z46EXYJU.js";
+import "./chunk-7I3ZJGJF.js";
+import "./chunk-IY7POWTF.js";
+export {
+  clientAddress,
+  worker_default as default,
+  handleRequest
+};

package/package.json

@@ -1,6 +1,77 @@
 {
   "name": "@mylasertools/kerfscript-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "KerfScript tools for building parametric laser-cutting generators: documentation, examples, parameters and SVG/DXF rendering.",
+  "mcpName": "com.mylasertools/kerfscript",
+  "type": "module",
+  "license": "AGPL-3.0-only",
+  "author": "MyLaserTools",
+  "homepage": "https://kerfscript.mylasertools.com/docs/mcp/",
+  "bugs": "https://github.com/mylasertools/kerfscript/issues",
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "kerfscript",
+    "laser-cutting",
+    "parametric",
+    "svg",
+    "dxf",
+    "generator"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mylasertools/kerfscript.git",
+    "directory": "mcp"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/src/tools.d.ts",
+      "default": "./dist/tools.js"
+    },
+    "./node": {
+      "types": "./dist/types/src/isolated.d.ts",
+      "default": "./dist/isolated.js"
+    },
+    "./execute": {
+      "types": "./dist/types/src/execute.d.ts",
+      "default": "./dist/execute.js"
+    }
+  },
+  "bin": {
+    "kerfscript-mcp": "dist/stdio.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "THIRD-PARTY-NOTICES.md",
+    "OFL.txt"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "test": "node --test test/*.test.mjs",
+    "check": "npm run build && npm run types && tsc --declaration --emitDeclarationOnly --noEmit false --outDir dist/types && npm test",
+    "dev": "wrangler dev",
+    "types": "wrangler types",
+    "deploy:check": "wrangler deploy --dry-run",
+    "prepack": "npm run check"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.32.2",
+    "zod": "4.6.7"
+  },
+  "devDependencies": {
+    "@types/node": "20.19.43",
+    "esbuild": "0.25.12",
+    "typescript": "5.9.3",
+    "wrangler": "4.156.0"
+  }
+}