@imenam/mcp-design 1.0.6 → 1.0.7

package/README.md

@@ -28,6 +28,18 @@ npx -y @imenam/mcp-design --claude-setup-mcp
 
 La commande crée (ou complète) le `.mcp.json` du répertoire courant avec une entrée `mcp-design` dont les variables sont pré-remplies. Ajoutez `--force` pour remplacer une entrée existante ; les autres serveurs sont préservés.
 
+Deux flags permettent de choisir directement comment la GUI sera exposée, sans éditer le JSON ensuite :
+
+```bash
+# GUI derrière le proxy central
+npx -y @imenam/mcp-design --claude-setup-mcp --proxy_url=http://localhost:3000
+
+# GUI en accès direct, sans proxy : http://localhost:4500
+npx -y @imenam/mcp-design --claude-setup-mcp --app_port=4500
+```
+
+Les deux flags sont exclusifs — la commande échoue si les deux sont passés.
+
 Exemple d'entrée générée :
 
 ```json
@@ -38,6 +50,7 @@ Exemple d'entrée générée :
       "args": ["-y", "@imenam/mcp-design"],
       "env": {
         "PROXY_URL": "http://localhost:3000",
+        "APP_PORT": "",
         "APP_GROUP": "Mon Projet",
         "APP_NAME": "Design Mon Projet",
         "APP_PATH": "/design-mon-projet",
@@ -53,13 +66,21 @@ Exemple d'entrée générée :
 
 | Variable | Rôle |
 |---|---|
-| `PROXY_URL` | URL du [proxy central](https://github.com/imenam/proxy-setup). **Sans elle, la GUI est simplement désactivée** — les outils MCP continuent de fonctionner. |
-| `APP_PATH` | Chemin de montage de la GUI derrière le proxy (défaut `/design-gui`). |
-| `APP_NAME` | Nom affiché dans le dashboard du proxy. |
+| `PROXY_URL` | URL du [proxy central](https://github.com/imenam/proxy-setup) : le proxy attribue le port et monte la GUI sous `APP_PATH`. |
+| `APP_PORT` | Port local utilisé **quand `PROXY_URL` est absent** : la GUI est servie directement sur `http://localhost:<port>`, à la racine. Permet d'utiliser l'interface sans le hub de centralisation. |
+| `APP_PATH` | Chemin de montage de la GUI derrière le proxy (défaut `/design-gui`). Ignoré en mode `APP_PORT`. `PROXY_APP_PATH` puis `GUI_PATH` sont acceptés en repli. |
+| `APP_NAME` | Nom affiché dans le dashboard du proxy. `PROXY_APP_NAME` puis `GUI_NAME` sont acceptés en repli. |
+| `APP_PATH_PREFIX` | Préfixe de namespace ajouté au chemin **par défaut** (ex. `/abc123` → `/abc123/design-gui`). Sert à isoler plusieurs instances sous un même proxy. |
 | `APP_GROUP` | Section repliable du dashboard du proxy (facultatif). |
 | `MCP_DESIGN_DATA_DIR` | Répertoire de stockage des designs. `MCP_DATA_DIR` est accepté en repli. Défaut : `<package>/.design-data`. |
 | `MCP_LOG_DIR` | Répertoire des logs. Défaut : `<data>/logs`. |
 
+`PROXY_URL` et `APP_PORT` s'excluent : `PROXY_URL` prime si les deux sont renseignés. **Si aucune des deux n'est définie, la GUI est simplement désactivée** — les outils MCP continuent de fonctionner.
+
+`APP_PATH` / `APP_NAME` sont les noms canoniques ; `PROXY_APP_*` puis `GUI_*` restent acceptés, dans cet ordre de priorité décroissante. La règle de `APP_PATH_PREFIX` est simple : **il ne préfixe que le chemin par défaut**. Dès que `APP_PATH` (ou l'un de ses replis) est renseigné, cette valeur est prise telle quelle, sans préfixe — la saisie manuelle l'emporte toujours. Les chemins sont normalisés (un seul `/` de séparation, pas de `/` final) et le préfixage est idempotent. Le `<base href>` de l'interface suit le chemin réellement enregistré, assets compris.
+
+La résolution est assurée par le paquet partagé [`@imenam/mcp-gui-interface`](https://www.npmjs.com/package/@imenam/mcp-gui-interface), qui documente la règle en détail.
+
 Un design est un simple fichier JSON dans `<data>/designs/<id>.json` — lisible, diffable, versionnable.
 
 ---

package/dist/src/cli/setup-mcp.d.ts

@@ -1,5 +1,24 @@
+/**
+ * Comment la GUI sera exposée. `undefined` des deux côtés = rien n'a été passé
+ * en ligne de commande : on retombe sur le placeholder PROXY_URL à compléter.
+ */
+export interface GuiExposure {
+    proxyUrl?: string;
+    appPort?: number;
+}
+/**
+ * Traduit `--proxy_url=` / `--app_port=` en mode d'exposition de la GUI.
+ * Les deux ensemble sont refusés : au runtime PROXY_URL primerait toujours,
+ * donc un fichier portant les deux serait silencieusement trompeur.
+ */
+export declare function parseGuiExposure(argv: string[]): {
+    exposure: GuiExposure;
+} | {
+    error: string;
+};
 export interface SetupMcpOptions {
     cwd: string;
     force: boolean;
+    exposure?: GuiExposure;
 }
-export declare function runSetupMcp({ cwd, force }: SetupMcpOptions): number;
+export declare function runSetupMcp({ cwd, force, exposure }: SetupMcpOptions): number;

package/dist/src/cli/setup-mcp.js

@@ -16,16 +16,20 @@ function toDisplayName(folder) {
 }
 /**
  * Valeurs volontairement vides : chaque variable est inactive tant qu'elle n'est
- * pas remplie (PROXY_URL vide = GUI désactivée), donc le fichier généré est
- * utilisable tel quel, jamais à moitié cassé.
+ * pas remplie (PROXY_URL et APP_PORT vides = GUI désactivée), donc le fichier
+ * généré est utilisable tel quel, jamais à moitié cassé.
  */
-function buildServerEntry(codeRoot) {
+function buildServerEntry(codeRoot, exposure) {
     const folder = path.basename(codeRoot) || "design";
+    // Un port explicite désactive le placeholder proxy : les deux variables ne
+    // doivent jamais être renseignées ensemble, PROXY_URL primant au runtime.
+    const proxyUrl = exposure.appPort !== undefined ? "" : exposure.proxyUrl ?? "http://localhost:";
     return {
         command: "npx",
         args: ["-y", PACKAGE_NAME],
         env: {
-            PROXY_URL: "http://localhost:",
+            PROXY_URL: proxyUrl,
+            APP_PORT: exposure.appPort !== undefined ? String(exposure.appPort) : "",
             APP_GROUP: capitalize(folder),
             APP_NAME: `Design ${toDisplayName(folder)}`,
             APP_PATH: `/design-${folder}`,
@@ -36,13 +40,60 @@ function buildServerEntry(codeRoot) {
 }
 const GENERATED_VARS = [
     ["PROXY_URL", "URL du proxy pour exposer la GUI (compléter le port)"],
+    ["APP_PORT", "port local si aucun proxy — la GUI est servie sur http://localhost:<port>"],
     ["APP_GROUP", "groupe d'affichage dans le dashboard du proxy"],
     ["APP_NAME", "nom affiché de la GUI dans le dashboard du proxy"],
     ["APP_PATH", "chemin de montage de la GUI derrière le proxy"],
     ["MCP_DESIGN_DATA_DIR", "répertoire de stockage des designs (pré-rempli)"],
     ["MCP_LOG_DIR", "répertoire des logs (défaut : <data>/logs)"],
 ];
-export function runSetupMcp({ cwd, force }) {
+/** Lit `--flag=valeur` (tirets ou underscores acceptés). */
+function readFlag(argv, name) {
+    const prefixes = [`--${name}=`, `--${name.replace(/_/g, "-")}=`];
+    for (const arg of argv) {
+        const prefix = prefixes.find((p) => arg.startsWith(p));
+        if (prefix)
+            return arg.slice(prefix.length).trim();
+    }
+    return undefined;
+}
+/**
+ * Traduit `--proxy_url=` / `--app_port=` en mode d'exposition de la GUI.
+ * Les deux ensemble sont refusés : au runtime PROXY_URL primerait toujours,
+ * donc un fichier portant les deux serait silencieusement trompeur.
+ */
+export function parseGuiExposure(argv) {
+    const rawProxyUrl = readFlag(argv, "proxy_url");
+    const rawAppPort = readFlag(argv, "app_port");
+    if (rawProxyUrl !== undefined && rawAppPort !== undefined) {
+        return { error: "--proxy_url et --app_port sont exclusifs : la GUI passe par le proxy, ou écoute sur un port local." };
+    }
+    if (rawProxyUrl !== undefined) {
+        if (rawProxyUrl === "")
+            return { error: "--proxy_url attend une URL, ex : --proxy_url=http://localhost:3000" };
+        let parsed;
+        try {
+            parsed = new URL(rawProxyUrl);
+        }
+        catch {
+            return { error: `--proxy_url invalide : "${rawProxyUrl}" n'est pas une URL absolue (ex : http://localhost:3000).` };
+        }
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            return { error: `--proxy_url invalide : protocole "${parsed.protocol}" non supporté (http ou https attendu).` };
+        }
+        // Une barre finale casserait la concaténation PROXY_URL + APP_PATH.
+        return { exposure: { proxyUrl: rawProxyUrl.replace(/\/+$/, "") } };
+    }
+    if (rawAppPort !== undefined) {
+        const port = Number(rawAppPort);
+        if (!Number.isInteger(port) || port < 1 || port > 65535) {
+            return { error: `--app_port invalide : "${rawAppPort}" n'est pas un entier entre 1 et 65535.` };
+        }
+        return { exposure: { appPort: port } };
+    }
+    return { exposure: {} };
+}
+export function runSetupMcp({ cwd, force, exposure = {} }) {
     const target = path.join(cwd, ".mcp.json");
     let config = {};
     const exists = fs.existsSync(target);
@@ -72,16 +123,23 @@ export function runSetupMcp({ cwd, force }) {
         console.error("Relancez avec --force pour écraser cette entrée (les autres serveurs sont préservés).");
         return 1;
     }
-    config.mcpServers[SERVER_NAME] = buildServerEntry(cwd);
+    config.mcpServers[SERVER_NAME] = buildServerEntry(cwd, exposure);
     fs.writeFileSync(target, JSON.stringify(config, null, 2) + "\n", "utf-8");
     const action = alreadyPresent ? "remplacée" : exists ? "ajoutée" : "créée";
     console.log(`Configuration ${SERVER_NAME} ${action} dans ${target}`);
     console.log("");
+    if (exposure.appPort !== undefined) {
+        console.log(`GUI en accès direct : http://localhost:${exposure.appPort} (sans proxy).`);
+    }
+    else if (exposure.proxyUrl !== undefined) {
+        console.log(`GUI exposée via le proxy ${exposure.proxyUrl}.`);
+    }
     console.log('À compléter dans le champ "env" :');
     for (const [name, description] of GENERATED_VARS) {
         console.log(`  ${name.padEnd(24)} ${description}`);
     }
     console.log("");
     console.log("Une variable laissée vide est simplement inactive.");
+    console.log("PROXY_URL et APP_PORT s'excluent : PROXY_URL prime si les deux sont renseignés.");
     return 0;
 }

package/dist/src/gui-worker.js

@@ -21,6 +21,29 @@ function findProjectRoot(startDir) {
 const rootDir = findProjectRoot(__dirname);
 const absoluteStaticRoot = path.resolve(path.join(rootDir, "gui/dist"));
 const configuredAppPath = process.env.APP_PATH || "/design-gui";
+/**
+ * Chemin réellement monté par le proxy. Il peut différer de `configuredAppPath`
+ * quand `APP_PATH_PREFIX` est défini : le client partagé préfixe alors le chemin
+ * naturel et renvoie le chemin final dans `result.path`. Le `<base href>` doit
+ * suivre ce chemin, sinon les assets de la SPA sont demandés au mauvais endroit.
+ */
+let effectiveAppPath = configuredAppPath;
+function resolveGuiMode() {
+    const proxyUrl = process.env.PROXY_URL?.trim();
+    if (proxyUrl)
+        return { kind: "proxy", proxyUrl };
+    const rawPort = process.env.APP_PORT?.trim();
+    if (!rawPort) {
+        return { kind: "disabled", reason: "PROXY_URL et APP_PORT non définis" };
+    }
+    const port = Number(rawPort);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        return { kind: "disabled", reason: `APP_PORT invalide (${rawPort}) — attendu : entier entre 1 et 65535` };
+    }
+    return { kind: "standalone", port };
+}
+const guiMode = resolveGuiMode();
+const isStandalone = guiMode.kind === "standalone";
 setupLogging({ processLabel: "mcp-design:GUI", logDir: resolveLogDir(rootDir) });
 const logger = createLogger("mcp-design:GUI");
 process.on("uncaughtException", (err) => {
@@ -136,7 +159,7 @@ app.get("/proxy/health", (c) => {
     const memory = process.memoryUsage();
     return c.json({
         status: "ok",
-        proxy: proxyClient ? proxyClient.getStatus() : process.env.PROXY_URL ? "error" : "standalone",
+        proxy: proxyClient ? proxyClient.getStatus() : isStandalone ? "standalone" : "error",
         uptime: process.uptime(),
         memory: { rss: memory.rss, heapUsed: memory.heapUsed },
         ipc: process.connected ? "connected" : "disconnected",
@@ -262,7 +285,8 @@ app.get("/*", (c, next) => {
         if (fs.existsSync(indexPath)) {
             // ?__direct=1 : accès au worker sur son port local, sans passer par le
             // proxy — le préfixe de montage ne doit alors pas préfixer les assets.
-            const baseHref = c.req.query("__direct") === "1" ? "/" : getHtmlBaseHref(configuredAppPath);
+            // En mode standalone la GUI est déjà servie à la racine : même règle.
+            const baseHref = isStandalone || c.req.query("__direct") === "1" ? "/" : getHtmlBaseHref(effectiveAppPath);
             const html = fs.readFileSync(indexPath, "utf8").replace("<head>", `<head>\n    <base href="${baseHref}" />`);
             return c.html(html);
         }
@@ -272,12 +296,51 @@ app.get("/*", (c, next) => {
         return next();
     }
 });
+/**
+ * Lance Hono sur `port` et prévient le master. `publicUrl` est l'URL que
+ * l'utilisateur doit ouvrir : via le proxy, ou directement en localhost.
+ */
+function listen(port, publicUrl, isProxied) {
+    const serverInstance = serve({ fetch: app.fetch, port, hostname: "0.0.0.0" }, (info) => {
+        logger.info(`Design canvas server listening on port ${info.port}`);
+        safeSend(IPCMessageSchema.parse({
+            type: "READY",
+            data: { port: info.port, isProxied, url: publicUrl },
+            timestamp: new Date().toISOString(),
+        }));
+    });
+    serverInstance.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+            // Sortie propre (code 0) : le master ne doit pas relancer un worker de plus.
+            logger.error(`Port ${port} already in use — another GUI instance is running.`);
+            safeSend(IPCMessageSchema.parse({
+                type: "ALREADY_RUNNING",
+                data: { url: publicUrl },
+                timestamp: new Date().toISOString(),
+            }));
+            process.exit(0);
+        }
+        logger.error(`Server error: ${err.message}`);
+        process.exit(1);
+    });
+}
+/** Sans proxy : la GUI écoute sur APP_PORT et est servie à la racine. */
+function startStandalone(port) {
+    const publicUrl = `http://localhost:${port}`;
+    logger.info(`Standalone mode (no PROXY_URL): serving GUI on ${publicUrl}`);
+    setupIpcErrorHandlers();
+    listen(port, publicUrl, false);
+}
 async function startServer() {
-    if (!process.env.PROXY_URL) {
-        process.stderr.write("[GUI] PROXY_URL non défini — arrêt.\n");
+    if (guiMode.kind === "disabled") {
+        process.stderr.write(`[GUI] ${guiMode.reason} — arrêt.\n`);
         process.exit(0);
     }
-    const proxyUrl = process.env.PROXY_URL;
+    if (guiMode.kind === "standalone") {
+        startStandalone(guiMode.port);
+        return;
+    }
+    const proxyUrl = guiMode.proxyUrl;
     const appPath = configuredAppPath;
     const appName = process.env.APP_NAME || "MCP Design";
     logger.info(`Starting server with proxyUrl=${proxyUrl}`);
@@ -311,7 +374,8 @@ async function startServer() {
         return;
     }
     const finalPort = result.port;
-    const publicUrl = result.url || `${proxyUrl}${appPath}`;
+    effectiveAppPath = result.path ?? appPath;
+    const publicUrl = result.url || `${proxyUrl}${effectiveAppPath}`;
     logger.info(`Registered with proxy. Public URL: ${publicUrl}, Local Port: ${finalPort}`);
     const cleanupProxy = async () => {
         if (proxyClient)
@@ -321,23 +385,7 @@ async function startServer() {
     process.on("SIGTERM", cleanupProxy);
     process.on("SIGINT", cleanupProxy);
     setupIpcErrorHandlers();
-    const serverInstance = serve({ fetch: app.fetch, port: finalPort, hostname: "0.0.0.0" }, (info) => {
-        logger.info(`Design canvas server listening on port ${info.port}`);
-        safeSend(IPCMessageSchema.parse({
-            type: "READY",
-            data: { port: info.port, isProxied: true, url: publicUrl },
-            timestamp: new Date().toISOString(),
-        }));
-    });
-    serverInstance.on("error", (err) => {
-        if (err.code === "EADDRINUSE") {
-            // Sortie propre (code 0) : le master ne doit pas relancer un worker de plus.
-            logger.error(`Port ${finalPort} already in use — another GUI instance is running.`);
-            process.exit(0);
-        }
-        logger.error(`Server error: ${err.message}`);
-        process.exit(1);
-    });
+    listen(finalPort, publicUrl, true);
 }
 startServer().catch((err) => {
     logger.error(`Failed to start GUI Worker: ${err.message}`);

package/dist/src/index.js

@@ -41,8 +41,14 @@ const __dirname = path.dirname(__filename);
 // Les flags CLI sont traités avant toute initialisation : ils s'exécutent dans le
 // répertoire de l'utilisateur, pas dans un serveur MCP.
 if (process.argv.slice(2).includes("--claude-setup-mcp")) {
-    const { runSetupMcp } = await import("./cli/setup-mcp.js");
-    process.exit(runSetupMcp({ cwd: process.cwd(), force: process.argv.slice(2).includes("--force") }));
+    const argv = process.argv.slice(2);
+    const { runSetupMcp, parseGuiExposure } = await import("./cli/setup-mcp.js");
+    const parsed = parseGuiExposure(argv);
+    if ("error" in parsed) {
+        console.error(`Erreur : ${parsed.error}`);
+        process.exit(1);
+    }
+    process.exit(runSetupMcp({ cwd: process.cwd(), force: argv.includes("--force"), exposure: parsed.exposure }));
 }
 function findProjectRoot(startDir) {
     let current = startDir;
@@ -62,7 +68,7 @@ const logger = createLogger("mcp-design");
 function getConfig() {
     if (fs.existsSync(packageEnvPath))
         dotenv.config({ path: packageEnvPath, override: true });
-    return { proxyUrl: process.env.PROXY_URL, version: APP_VERSION };
+    return { proxyUrl: process.env.PROXY_URL, appPort: process.env.APP_PORT, version: APP_VERSION };
 }
 getConfig();
 const store = new DesignStore(rootDir);
@@ -224,9 +230,13 @@ guiLauncher = new GuiLauncher({
     maxRestarts: 0,
     onMessage: handleIPCMessage,
 });
+/** La GUI a besoin soit d'un proxy, soit d'un port local (mode standalone). */
+function guiIsConfigured() {
+    return !!(process.env.PROXY_URL?.trim() || process.env.APP_PORT?.trim());
+}
 function launchGUI() {
-    if (!process.env.PROXY_URL) {
-        logger.info("[MASTER] PROXY_URL non défini — GUI désactivée.");
+    if (!guiIsConfigured()) {
+        logger.info("[MASTER] Ni PROXY_URL ni APP_PORT défini — GUI désactivée.");
         guiStatus = "disabled";
         return;
     }
@@ -234,13 +244,13 @@ function launchGUI() {
     startGuiWorker();
 }
 async function reconnectGui(args) {
-    getConfig(); // relit le .env au cas où PROXY_URL aurait été ajouté après le démarrage
-    if (!process.env.PROXY_URL) {
+    getConfig(); // relit le .env au cas où PROXY_URL/APP_PORT aurait été ajouté après le démarrage
+    if (!guiIsConfigured()) {
         return {
             content: [
                 {
                     type: "text",
-                    text: "Error: PROXY_URL is not set — the GUI is disabled. Add PROXY_URL to the .env file, then call reconnect_gui again.",
+                    text: "Error: neither PROXY_URL nor APP_PORT is set — the GUI is disabled. Add PROXY_URL (to expose the GUI through the proxy) or APP_PORT (to serve it directly on localhost) to the .env file, then call reconnect_gui again.",
                 },
             ],
             isError: true,
@@ -253,13 +263,13 @@ async function reconnectGui(args) {
         if (guiStatus === "starting") {
             return {
                 content: [
-                    { type: "text", text: "GUI worker is already starting (proxy registration in progress). Wait a few seconds, then call reconnect_gui again if needed." },
+                    { type: "text", text: "GUI worker is already starting. Wait a few seconds, then call reconnect_gui again if needed." },
                 ],
             };
         }
         return {
             content: [
-                { type: "text", text: `GUI is already registered with the proxy${guiUrl ? ` at ${guiUrl}` : ""}. Nothing to do (use force=true to restart it anyway).` },
+                { type: "text", text: `GUI is already running${guiUrl ? ` at ${guiUrl}` : ""}. Nothing to do (use force=true to restart it anyway).` },
             ],
         };
     }
@@ -285,23 +295,25 @@ async function reconnectGui(args) {
         };
         newChild.on("exit", onExit);
     });
+    const proxyUrl = process.env.PROXY_URL?.trim();
     if (result.outcome === "ready") {
-        return { content: [{ type: "text", text: `GUI reconnected and registered with the proxy. URL: ${result.url}` }] };
+        return { content: [{ type: "text", text: `GUI reconnected. URL: ${result.url}` }] };
     }
     if (result.outcome === "already_running") {
-        return { content: [{ type: "text", text: `GUI is already registered by another MCP instance. URL: ${result.url ?? "unknown"}` }] };
+        return { content: [{ type: "text", text: `GUI is already served by another MCP instance. URL: ${result.url ?? "unknown"}` }] };
     }
     if (result.outcome === "exited") {
+        const hint = proxyUrl
+            ? `The proxy server is probably still unreachable at ${proxyUrl}. Start the proxy server, then call reconnect_gui again.`
+            : `Port ${process.env.APP_PORT} is probably already taken by another process. Free it or set another APP_PORT, then call reconnect_gui again.`;
         return {
-            content: [
-                { type: "text", text: `GUI worker exited before completing registration (code=${result.code}). The proxy server is probably still unreachable at ${process.env.PROXY_URL}. Start the proxy server, then call reconnect_gui again.` },
-            ],
+            content: [{ type: "text", text: `GUI worker exited before it was ready (code=${result.code}). ${hint}` }],
             isError: true,
         };
     }
     return {
         content: [
-            { type: "text", text: `GUI worker started but did not confirm proxy registration within 15s. Check the logs (${resolveLogDir(rootDir)}), then retry.` },
+            { type: "text", text: `GUI worker started but did not confirm it was ready within 15s. Check the logs (${resolveLogDir(rootDir)}), then retry.` },
         ],
         isError: true,
     };

package/dist/src/version.d.ts

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

package/dist/src/version.js

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

package/package.json

@@ -1,60 +1,60 @@
-{
-  "name": "@imenam/mcp-design",
-  "version": "1.0.6",
-  "main": "dist/src/index.js",
-  "directories": {
-    "test": "test"
-  },
-  "scripts": {
-    "generate-version": "node scripts/generate-version.js",
-    "build:backend": "npm run generate-version && tsc",
-    "build:gui": "cd gui && npm install && npm run build",
-    "build": "npm run build:backend && npm run build:gui",
-    "start": "node dist/src/index.js",
-    "test": "node --test \"dist/test/*.test.js\"",
-    "prepublishOnly": "npm run build",
-    "release": "npm version patch && npm publish && git push --follow-tags",
-    "generate-icons": "node scripts/generate-icons.js"
-  },
-  "keywords": [
-    "mcp",
-    "model-context-protocol",
-    "design",
-    "canvas",
-    "ui",
-    "mockup",
-    "ai",
-    "agent"
-  ],
-  "author": "Imena",
-  "license": "ISC",
-  "description": "MCP server providing a simple design canvas: the agent creates shapes and text, the user refines them in a GUI, and the agent picks the edits back up.",
-  "type": "module",
-  "bin": {
-    "mcp-design": "dist/src/index.js"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "files": [
-    "dist/src",
-    "dist/shared",
-    "gui/dist",
-    "README.md",
-    "scripts"
-  ],
-  "dependencies": {
-    "@hono/node-server": "^2.1.1",
-    "@imenam/mcp-gui-interface": "^1.0.11",
-    "@modelcontextprotocol/sdk": "^1.30.0",
-    "@resvg/resvg-js": "^2.6.2",
-    "dotenv": "^17.4.2",
-    "hono": "^4.13.4",
-    "zod": "^4.4.3"
-  },
-  "devDependencies": {
-    "@types/node": "^26.3.0",
-    "lucide-static": "^1.38.0",
-    "typescript": "^7.0.2"
-  }
-}
+{
+  "name": "@imenam/mcp-design",
+  "version": "1.0.7",
+  "main": "dist/src/index.js",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "generate-version": "node scripts/generate-version.js",
+    "build:backend": "npm run generate-version && tsc",
+    "build:gui": "cd gui && npm install && npm run build",
+    "build": "npm run build:backend && npm run build:gui",
+    "start": "node dist/src/index.js",
+    "test": "node --test \"dist/test/*.test.js\"",
+    "prepublishOnly": "npm run build",
+    "release": "npm version patch && npm publish && git push --follow-tags",
+    "generate-icons": "node scripts/generate-icons.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "design",
+    "canvas",
+    "ui",
+    "mockup",
+    "ai",
+    "agent"
+  ],
+  "author": "Imena",
+  "license": "ISC",
+  "description": "MCP server providing a simple design canvas: the agent creates shapes and text, the user refines them in a GUI, and the agent picks the edits back up.",
+  "type": "module",
+  "bin": {
+    "mcp-design": "dist/src/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/src",
+    "dist/shared",
+    "gui/dist",
+    "README.md",
+    "scripts"
+  ],
+  "dependencies": {
+    "@hono/node-server": "^2.1.1",
+    "@imenam/mcp-gui-interface": "^1.0.12",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@resvg/resvg-js": "^2.6.2",
+    "dotenv": "^17.4.2",
+    "hono": "^4.13.4",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^26.3.0",
+    "lucide-static": "^1.38.0",
+    "typescript": "^7.0.2"
+  }
+}

package/scripts/generate-icons.js

@@ -1,85 +1,85 @@
-#!/usr/bin/env node
-/**
- * Fige la bibliotheque d'icones dans `shared/icons/` a partir de `lucide-static`.
- *
- * Les fichiers produits sont commites : ni le serveur MCP publie, ni le bundle
- * de la GUI ne dependent de lucide a l'execution, et la geometrie d'un design
- * ne peut pas changer sous les pieds de l'utilisateur au gre d'un `npm install`.
- * Relancer `npm run generate-icons` apres une mise a jour de lucide-static.
- */
-import fs from 'fs';
-import path from 'path';
-import { createRequire } from 'module';
-import { fileURLToPath } from 'url';
-
-const require = createRequire(import.meta.url);
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const rootDir = path.join(__dirname, '..');
-const outDir = path.join(rootDir, 'shared', 'icons');
-
-const iconNodes = require('lucide-static/icon-nodes.json');
-const tags = require('lucide-static/tags.json');
-const { version } = require('lucide-static/package.json');
-
-/** Attributs de presentation portes par le noeud du design, jamais par l'icone elle-meme. */
-const DROPPED_ATTRS = new Set(['stroke', 'stroke-width', 'stroke-linecap', 'stroke-linejoin', 'class', 'key']);
-
-const names = Object.keys(iconNodes).sort();
-
-const geometry = {};
-for (const name of names) {
-  geometry[name] = iconNodes[name].map(([tag, attrs]) => {
-    const kept = {};
-    for (const [attr, value] of Object.entries(attrs ?? {})) {
-      if (!DROPPED_ATTRS.has(attr)) kept[attr] = String(value);
-    }
-    return [tag, kept];
-  });
-}
-
-/** Mots-cles de recherche : le nom eclate en segments, plus les synonymes de lucide. */
-const keywords = {};
-for (const name of names) {
-  const fromName = name.split('-');
-  const merged = [...new Set([...fromName, ...(tags[name] ?? [])])].filter((word) => word.length > 1);
-  if (merged.length > 0) keywords[name] = merged;
-}
-
-/**
- * Les donnees sont embarquees comme une chaine JSON parsee au premier acces
- * plutot que comme un litteral d'objet : un objet de 1800 entrees coute cher a
- * analyser au demarrage, et le module est charge par le serveur stdio comme par
- * le navigateur.
- */
-function moduleSource(header, exports) {
-  const body = exports
-    .map(([name, value]) => `export const ${name} = ${JSON.stringify(JSON.stringify(value))};`)
-    .join('\n\n');
-  return `${header}\n${body}\n`;
-}
-
-const banner = (what) =>
-  `// Auto-generated by scripts/generate-icons.js - do not edit manually.\n` +
-  `// ${what}\n` +
-  `// Source: lucide-static ${version}, ISC licence (https://lucide.dev).\n`;
-
-fs.mkdirSync(outDir, { recursive: true });
-fs.writeFileSync(
-  path.join(outDir, 'icon-data.ts'),
-  moduleSource(banner('Geometry of every icon, in the 24x24 grid.'), [
-    ['LUCIDE_VERSION', version],
-    ['ICON_DATA_JSON', geometry],
-  ]),
-  'utf8'
-);
-fs.writeFileSync(
-  path.join(outDir, 'icon-keywords.ts'),
-  moduleSource(banner('Search keywords per icon. Loaded on demand, never by the renderer.'), [
-    ['ICON_KEYWORDS_JSON', keywords],
-  ]),
-  'utf8'
-);
-
-console.log(`Generated ${names.length} icons from lucide-static ${version}`);
-console.log(`  ${path.join(outDir, 'icon-data.ts')}`);
-console.log(`  ${path.join(outDir, 'icon-keywords.ts')}`);
+#!/usr/bin/env node
+/**
+ * Fige la bibliotheque d'icones dans `shared/icons/` a partir de `lucide-static`.
+ *
+ * Les fichiers produits sont commites : ni le serveur MCP publie, ni le bundle
+ * de la GUI ne dependent de lucide a l'execution, et la geometrie d'un design
+ * ne peut pas changer sous les pieds de l'utilisateur au gre d'un `npm install`.
+ * Relancer `npm run generate-icons` apres une mise a jour de lucide-static.
+ */
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+
+const require = createRequire(import.meta.url);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.join(__dirname, '..');
+const outDir = path.join(rootDir, 'shared', 'icons');
+
+const iconNodes = require('lucide-static/icon-nodes.json');
+const tags = require('lucide-static/tags.json');
+const { version } = require('lucide-static/package.json');
+
+/** Attributs de presentation portes par le noeud du design, jamais par l'icone elle-meme. */
+const DROPPED_ATTRS = new Set(['stroke', 'stroke-width', 'stroke-linecap', 'stroke-linejoin', 'class', 'key']);
+
+const names = Object.keys(iconNodes).sort();
+
+const geometry = {};
+for (const name of names) {
+  geometry[name] = iconNodes[name].map(([tag, attrs]) => {
+    const kept = {};
+    for (const [attr, value] of Object.entries(attrs ?? {})) {
+      if (!DROPPED_ATTRS.has(attr)) kept[attr] = String(value);
+    }
+    return [tag, kept];
+  });
+}
+
+/** Mots-cles de recherche : le nom eclate en segments, plus les synonymes de lucide. */
+const keywords = {};
+for (const name of names) {
+  const fromName = name.split('-');
+  const merged = [...new Set([...fromName, ...(tags[name] ?? [])])].filter((word) => word.length > 1);
+  if (merged.length > 0) keywords[name] = merged;
+}
+
+/**
+ * Les donnees sont embarquees comme une chaine JSON parsee au premier acces
+ * plutot que comme un litteral d'objet : un objet de 1800 entrees coute cher a
+ * analyser au demarrage, et le module est charge par le serveur stdio comme par
+ * le navigateur.
+ */
+function moduleSource(header, exports) {
+  const body = exports
+    .map(([name, value]) => `export const ${name} = ${JSON.stringify(JSON.stringify(value))};`)
+    .join('\n\n');
+  return `${header}\n${body}\n`;
+}
+
+const banner = (what) =>
+  `// Auto-generated by scripts/generate-icons.js - do not edit manually.\n` +
+  `// ${what}\n` +
+  `// Source: lucide-static ${version}, ISC licence (https://lucide.dev).\n`;
+
+fs.mkdirSync(outDir, { recursive: true });
+fs.writeFileSync(
+  path.join(outDir, 'icon-data.ts'),
+  moduleSource(banner('Geometry of every icon, in the 24x24 grid.'), [
+    ['LUCIDE_VERSION', version],
+    ['ICON_DATA_JSON', geometry],
+  ]),
+  'utf8'
+);
+fs.writeFileSync(
+  path.join(outDir, 'icon-keywords.ts'),
+  moduleSource(banner('Search keywords per icon. Loaded on demand, never by the renderer.'), [
+    ['ICON_KEYWORDS_JSON', keywords],
+  ]),
+  'utf8'
+);
+
+console.log(`Generated ${names.length} icons from lucide-static ${version}`);
+console.log(`  ${path.join(outDir, 'icon-data.ts')}`);
+console.log(`  ${path.join(outDir, 'icon-keywords.ts')}`);