memtrace 0.4.2 → 0.4.3

package/installer/dist/transformers/claude.js

@@ -23,18 +23,54 @@ const MARKETPLACE_SETTING_CONTAINERS = [
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+/**
+ * Read the existing env block (if any) for the memtrace MCP entry in a Claude
+ * settings/mcp.json file. Returns an empty object if the file or entry is
+ * missing/malformed. Used to deep-merge user-set env keys
+ * (e.g. MEMTRACE_LICENSE_KEY) so they survive `memtrace install`
+ * re-registration. Mirrors the codex transformer's env-preservation contract.
+ */
+function readExistingMemtraceEnv(filePath, serverKey = 'mcpServers') {
+    if (!fs.existsSync(filePath))
+        return {};
+    const { value, corrupted } = safeReadJson(filePath);
+    if (corrupted || !value)
+        return {};
+    const servers = value[serverKey];
+    if (!isRecord(servers))
+        return {};
+    const entry = servers['memtrace'];
+    if (!isRecord(entry))
+        return {};
+    const env = entry.env;
+    if (!isRecord(env))
+        return {};
+    const out = {};
+    for (const [k, v] of Object.entries(env)) {
+        if (typeof v === 'string')
+            out[k] = v;
+    }
+    return out;
+}
 /**
  * Try to register the memtrace MCP server via `claude mcp add-json`.
  * Returns true on success, false on timeout/error/missing CLI.
  * 5-second timeout — we fall back to direct JSON merge fast.
+ *
+ * The env block deep-merges any user-set env keys discovered in the existing
+ * settings.json on top of MEMTRACE_MCP_ENV defaults so that a re-install never
+ * stomps user-added keys like MEMTRACE_LICENSE_KEY.
  */
 async function tryMcpAddJson(memtraceBinary) {
     if (!(await commandExists('claude')))
         return false;
+    const settingsFile = path.join(os.homedir(), '.claude', 'settings.json');
+    const existingEnv = readExistingMemtraceEnv(settingsFile);
+    const mergedEnv = { ...existingEnv, ...MEMTRACE_MCP_ENV };
     const config = JSON.stringify({
         command: memtraceBinary,
         args: ['mcp'],
-        env: MEMTRACE_MCP_ENV,
+        env: mergedEnv,
     });
     // Shell-quote the JSON. Use single quotes; escape any embedded single quote.
     const escaped = config.replace(/'/g, `'\\''`);
@@ -164,10 +200,18 @@ export function registerMcpInSettingsAt(settingsPath, memtraceBinary) {
     }
     const settings = (value ?? {});
     settings.mcpServers = settings.mcpServers ?? {};
+    // Deep-merge env so user-set keys (e.g. MEMTRACE_LICENSE_KEY) survive
+    // re-registration. memtrace-owned keys (MEMTRACE_MCP_ENV) override on
+    // conflict so installer-managed values stay authoritative.
+    const existing = settings.mcpServers['memtrace'];
+    const existingEnv = (isRecord(existing) && isRecord(existing.env))
+        ? existing.env
+        : {};
+    const mergedEnv = { ...existingEnv, ...MEMTRACE_MCP_ENV };
     settings.mcpServers['memtrace'] = {
         command: memtraceBinary,
         args: ['mcp'],
-        env: MEMTRACE_MCP_ENV,
+        env: mergedEnv,
     };
     writeJsonAtomic(settingsPath, settings);
     return { registered: true };
@@ -416,10 +460,16 @@ function writeClaudeLocalMcp(mcpPath, binary) {
     }
     const cfg = (value ?? {});
     cfg.mcpServers = cfg.mcpServers ?? {};
+    // Deep-merge env: preserve user-set keys, memtrace defaults win on conflict.
+    const existing = cfg.mcpServers['memtrace'];
+    const existingEnv = (isRecord(existing) && isRecord(existing.env))
+        ? existing.env
+        : {};
+    const mergedEnv = { ...existingEnv, ...MEMTRACE_MCP_ENV };
     cfg.mcpServers['memtrace'] = {
         command: binary,
         args: ['mcp'],
-        env: MEMTRACE_MCP_ENV,
+        env: mergedEnv,
     };
     writeJsonAtomic(mcpPath, cfg);
     return true;

package/installer/dist/transformers/codex.js

@@ -38,6 +38,20 @@ function isMemtraceMcpTable(tableName) {
         || tableName.startsWith(`mcp_servers.${MCP_SERVER_NAME}.`)
         || tableName.startsWith(`mcp_servers."${MCP_SERVER_NAME}".`);
 }
+/**
+ * Tables we want stripped on re-registration.
+ *
+ * PRESERVE [mcp_servers.memtrace.env] so user-set env vars
+ * (MEMTRACE_LICENSE_KEY, etc.) survive `memtrace install` re-registration.
+ * Only the top-level table + non-env sub-tables get stripped.
+ */
+function isMemtraceMcpTableToStrip(tableName) {
+    if (tableName === `mcp_servers.${MCP_SERVER_NAME}.env`)
+        return false;
+    if (tableName === `mcp_servers."${MCP_SERVER_NAME}".env`)
+        return false;
+    return isMemtraceMcpTable(tableName);
+}
 export function stripCodexMcpServer(raw) {
     const lines = raw.split(/\r?\n/);
     const kept = [];
@@ -45,7 +59,7 @@ export function stripCodexMcpServer(raw) {
     for (const line of lines) {
         const table = line.match(/^\s*\[([^\]]+)\]\s*$/);
         if (table) {
-            skipping = isMemtraceMcpTable(table[1].trim());
+            skipping = isMemtraceMcpTableToStrip(table[1].trim());
             if (skipping)
                 continue;
         }
@@ -54,16 +68,64 @@ export function stripCodexMcpServer(raw) {
     }
     return kept.join('\n').trimEnd();
 }
+/**
+ * Extracts the preserved `[mcp_servers.memtrace.env]` block (if any) and
+ * returns:
+ *   - rest: the input with the env block removed
+ *   - envBlock: the env block as a string (empty if absent)
+ *
+ * Used by `registerCodexMcpAt` so the env block can be reattached AFTER the
+ * freshly-written `[mcp_servers.memtrace]` parent for readable ordering.
+ */
+function extractMemtraceEnvBlock(raw) {
+    const lines = raw.split(/\r?\n/);
+    const rest = [];
+    const envLines = [];
+    let inEnv = false;
+    for (const line of lines) {
+        const table = line.match(/^\s*\[([^\]]+)\]\s*$/);
+        if (table) {
+            const name = table[1].trim();
+            const isEnv = name === `mcp_servers.${MCP_SERVER_NAME}.env`
+                || name === `mcp_servers."${MCP_SERVER_NAME}".env`;
+            if (isEnv) {
+                inEnv = true;
+                envLines.push(line);
+                continue;
+            }
+            // Any other table header closes the env capture.
+            inEnv = false;
+        }
+        if (inEnv) {
+            envLines.push(line);
+        }
+        else {
+            rest.push(line);
+        }
+    }
+    return {
+        rest: rest.join('\n').replace(/\n+$/, ''),
+        envBlock: envLines.join('\n').replace(/\n+$/, ''),
+    };
+}
 export function registerCodexMcpAt(configFile, binary) {
     const existing = fs.existsSync(configFile) ? fs.readFileSync(configFile, 'utf-8') : '';
-    const base = stripCodexMcpServer(existing);
+    // Strip leaves the env sub-table intact; split it out so we can reorder it
+    // after the freshly written parent block for readability.
+    const stripped = stripCodexMcpServer(existing);
+    const { rest, envBlock } = extractMemtraceEnvBlock(stripped);
     const block = [
         `[mcp_servers.${MCP_SERVER_NAME}]`,
         `command = ${tomlString(binary)}`,
         `args = [${tomlString('mcp')}]`,
-        '',
     ].join('\n');
-    const next = `${base}${base ? '\n\n' : ''}${block}`;
+    const parts = [];
+    if (rest)
+        parts.push(rest);
+    parts.push(block);
+    if (envBlock)
+        parts.push(envBlock);
+    const next = `${parts.join('\n\n')}\n`;
     writeTextAtomic(configFile, next);
     return { registered: true };
 }

package/installer/dist/transformers/cursor.js

@@ -20,6 +20,9 @@ function writeSkill(skill, rootDir) {
     const content = `---\nname: ${name}\ndescription: "${safeDesc}"\n---\n\n${skill.body}`;
     fs.writeFileSync(path.join(outDir, 'SKILL.md'), content);
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 export function registerCursorMcpAt(mcpFile, binary) {
     const { value, corrupted, backupPath } = safeReadJson(mcpFile);
     if (corrupted) {
@@ -28,10 +31,17 @@ export function registerCursorMcpAt(mcpFile, binary) {
     }
     const cfg = (value ?? {});
     cfg.mcpServers = cfg.mcpServers ?? {};
+    // Deep-merge env: preserve user-set keys (e.g. MEMTRACE_LICENSE_KEY) across
+    // re-registration; memtrace-owned defaults (MEMTRACE_MCP_ENV) win on conflict.
+    const existing = cfg.mcpServers['memtrace'];
+    const existingEnv = (isRecord(existing) && isRecord(existing.env))
+        ? existing.env
+        : {};
+    const mergedEnv = { ...existingEnv, ...MEMTRACE_MCP_ENV };
     cfg.mcpServers['memtrace'] = {
         command: binary,
         args: ['mcp'],
-        env: MEMTRACE_MCP_ENV,
+        env: mergedEnv,
     };
     writeJsonAtomic(mcpFile, cfg);
     return { registered: true };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memtrace",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Code intelligence graph — MCP server + AI agent skills + visualization UI",
   "keywords": [
     "mcp",
@@ -39,11 +39,11 @@
     "fs-extra": "^11.0.0"
   },
   "optionalDependencies": {
-    "@memtrace/darwin-arm64": "0.4.2",
-    "@memtrace/linux-x64": "0.4.2",
-    "@memtrace/win32-x64": "0.4.2",
-    "@memtrace/linux-x64-noavx2": "0.4.2",
-    "@memtrace/win32-x64-noavx2": "0.4.2"
+    "@memtrace/darwin-arm64": "0.4.3",
+    "@memtrace/linux-x64": "0.4.3",
+    "@memtrace/win32-x64": "0.4.3",
+    "@memtrace/linux-x64-noavx2": "0.4.3",
+    "@memtrace/win32-x64-noavx2": "0.4.3"
   },
   "engines": {
     "node": ">=18"