@imenam/mcp-design 1.0.7 → 1.0.9

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

@@ -0,0 +1,27 @@
+export declare const RELAY_SHAPE_DESCRIPTIONS: {
+    readonly destination_path: "ABSOLUTE path of the destination DIRECTORY on the agent machine. It is created if missing, and the file keeps the name given in filename";
+    readonly filename: "Name of the file to create, extension included (e.g. 'design.html'). Must not contain path separators";
+    readonly destination_overwrite: "Replace the destination file if it already exists. Defaults to false";
+    readonly destination_relay: "Filled in by the mcp-http-gateway relay, never by the agent. Signals that the destination lives on another machine and that the file content must travel in the response";
+};
+export interface DeliveryTarget {
+    destination_path: string;
+    filename: string;
+    destination_overwrite?: boolean;
+    destination_relay?: boolean;
+}
+import type { ResourceBlock } from "./types.js";
+type ContentBlock = {
+    type: "text";
+    text: string;
+} | ResourceBlock;
+/**
+ * Livre un fichier produit par le MCP, du bon côté de la chaîne.
+ *
+ * Renvoie les blocs de contenu à faire figurer dans le résultat de l'outil : un bloc
+ * `resource` que le relais interceptera et retirera, ou une simple confirmation quand
+ * l'écriture a eu lieu ici. Toute impossibilité est une erreur franche : mieux vaut un
+ * fichier perdu qu'un fichier écrit sur la mauvaise machine.
+ */
+export declare function deliverFile(data: Buffer, mimeType: string, target: DeliveryTarget): ContentBlock[];
+export {};

package/dist/src/tools/relay.js

@@ -0,0 +1,67 @@
+import fs from "fs";
+import path from "path";
+// Un fichier produit par ce MCP n'a aucun moyen d'atteindre la machine de l'agent quand
+// le MCP tourne derrière mcp-http-gateway : le protocole n'offre au serveur aucune
+// primitive pour y écrire. La convention du relais règle ça — dès qu'un outil déclare la
+// paire `destination_path` / `destination_relay`, le relais retient la destination, pose
+// `destination_relay`, et écrit lui-même les octets qu'on lui renvoie.
+//
+// Ici, on ne sait pas si un relais est dans la chaîne : `destination_relay` le dit. Posé,
+// on renvoie le contenu ; absent, les deux machines n'en font qu'une et on écrit nous-même.
+/** Plafond de ce qui peut être encodé dans une réponse d'outil. Le relais applique sa
+ *  propre limite, configurable ; celle-ci n'existe que pour qu'un fichier démesuré
+ *  échoue proprement ici plutôt qu'en épuisant la mémoire pendant l'encodage base64. */
+const RELAY_MAX_BYTES = 32 * 1024 * 1024;
+export const RELAY_SHAPE_DESCRIPTIONS = {
+    destination_path: "ABSOLUTE path of the destination DIRECTORY on the agent machine. It is created if missing, and the file keeps the name given in filename",
+    filename: "Name of the file to create, extension included (e.g. 'design.html'). Must not contain path separators",
+    destination_overwrite: "Replace the destination file if it already exists. Defaults to false",
+    destination_relay: "Filled in by the mcp-http-gateway relay, never by the agent. Signals that the destination lives on another machine and that the file content must travel in the response",
+};
+/**
+ * Livre un fichier produit par le MCP, du bon côté de la chaîne.
+ *
+ * Renvoie les blocs de contenu à faire figurer dans le résultat de l'outil : un bloc
+ * `resource` que le relais interceptera et retirera, ou une simple confirmation quand
+ * l'écriture a eu lieu ici. Toute impossibilité est une erreur franche : mieux vaut un
+ * fichier perdu qu'un fichier écrit sur la mauvaise machine.
+ */
+export function deliverFile(data, mimeType, target) {
+    const name = path.basename(target.filename);
+    if (name !== target.filename || name === "." || name === "..") {
+        throw new Error(`filename must be a bare file name, without path separators: ${target.filename}`);
+    }
+    if (data.length > RELAY_MAX_BYTES) {
+        throw new Error(`File too large to transfer: ${data.length} bytes, the limit is ${RELAY_MAX_BYTES}.`);
+    }
+    // Le relais tourne sur la machine de l'agent et a retenu la destination : il attend les
+    // octets, qu'il écrira lui-même. Écrire ici viserait le mauvais disque.
+    if (target.destination_relay) {
+        return [
+            {
+                type: "resource",
+                resource: {
+                    uri: `file:///${name}`,
+                    name,
+                    mimeType,
+                    blob: data.toString("base64"),
+                },
+            },
+        ];
+    }
+    // Pas de relais : le MCP tourne à côté de l'agent, son disque est le bon.
+    if (!path.isAbsolute(target.destination_path)) {
+        throw new Error(`destination_path must be an absolute directory path: ${target.destination_path}`);
+    }
+    if (fs.existsSync(target.destination_path) &&
+        !fs.statSync(target.destination_path).isDirectory()) {
+        throw new Error(`destination_path must be a directory, but a file already exists there: ${target.destination_path}`);
+    }
+    const written = path.join(target.destination_path, name);
+    if (!target.destination_overwrite && fs.existsSync(written)) {
+        throw new Error(`Destination already exists: ${written}. Pass destination_overwrite to replace it.`);
+    }
+    fs.mkdirSync(target.destination_path, { recursive: true });
+    fs.writeFileSync(written, data);
+    return [{ type: "text", text: `File written to ${written} (${data.length} bytes).` }];
+}

package/dist/src/tools/screenshot-design.js

@@ -1,6 +1,5 @@
-import fs from "fs";
-import path from "path";
 import { screenshotDesign } from "../core/screenshot.js";
+import { deliverFile } from "./relay.js";
 import { requireString } from "./types.js";
 /** Marge par défaut autour d'un noeud capturé : de l'air, sans noyer l'élément. */
 const NODE_PADDING = 16;
@@ -20,12 +19,19 @@ export function screenshotDesignTool(store, args) {
     const subject = node ? `${node.type} "${node.name}" (${node.id})` : `design "${design.name}"`;
     const geometry = `${Math.round(shot.sourceWidth)}x${Math.round(shot.sourceHeight)} design px ` +
         `rendered at ${shot.width}x${shot.height} px (scale ${Math.round(shot.scale * 100) / 100})`;
-    const outputPath = typeof args?.output_path === "string" ? args.output_path.trim() : "";
-    if (outputPath) {
-        const target = path.resolve(outputPath);
-        fs.mkdirSync(path.dirname(target), { recursive: true });
-        fs.writeFileSync(target, shot.png);
-        return { content: [{ type: "text", text: `Screenshot of ${subject} written to ${target} — ${geometry}.` }] };
+    const destination = typeof args?.destination_path === "string" ? args.destination_path.trim() : "";
+    if (destination) {
+        // Livrer le PNG et le montrer à la fois n'aurait pas de sens : le relais retire le
+        // contenu du résultat, et une image de plus dans le contexte coûte cher pour rien.
+        const blocks = deliverFile(shot.png, "image/png", {
+            destination_path: destination,
+            filename: requireString(args, "filename"),
+            destination_overwrite: args?.destination_overwrite === true,
+            destination_relay: args?.destination_relay === true,
+        });
+        return {
+            content: [{ type: "text", text: `Screenshot of ${subject} — ${geometry}.` }, ...blocks],
+        };
     }
     return {
         content: [

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

@@ -20,6 +20,25 @@ export interface ImageToolResult {
         type: "image";
         data: string;
         mimeType: string;
-    }>;
+    } | ResourceBlock>;
+    isError?: boolean;
+}
+/** Bloc qu'un outil renvoie pour un fichier que le relais du gateway écrira chez l'agent. */
+export interface ResourceBlock {
+    type: "resource";
+    resource: {
+        uri: string;
+        name: string;
+        mimeType: string;
+        blob: string;
+    };
+}
+/** Variante de ToolResult pour les outils qui peuvent livrer un fichier. */
+export interface FileToolResult {
+    [key: string]: unknown;
+    content: Array<{
+        type: "text";
+        text: string;
+    } | ResourceBlock>;
     isError?: boolean;
 }

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const APP_VERSION = "1.0.7";
+export declare const APP_VERSION = "1.0.9";

package/dist/src/version.js

@@ -1,2 +1,2 @@
 // Auto-generated version file - do not edit manually
-export const APP_VERSION = '1.0.7';
+export const APP_VERSION = '1.0.9';