memtrace 0.7.13 → 0.7.20

package/installer/dist/commands/enterprise-install.d.ts

@@ -0,0 +1,7 @@
+export interface EnterpriseInstallOptions {
+    seedPath: string;
+    scope?: 'global' | 'local';
+    binary?: string;
+    yes?: boolean;
+}
+export declare function runEnterpriseInstall(opts: EnterpriseInstallOptions): Promise<void>;

package/installer/dist/commands/enterprise-install.js

@@ -0,0 +1,129 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { safeReadJson, writeJsonAtomic } from '../fs-safe.js';
+import { resolveMemtraceBinary } from './install.js';
+import { registerCursorMcpAt } from '../transformers/cursor.js';
+function loadSeed(seedPath) {
+    const raw = fs.readFileSync(seedPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed.memdb?.database) {
+        throw new Error('seed JSON must include memdb.database');
+    }
+    return parsed;
+}
+function loadWriterToken(seedDir) {
+    const tokPath = path.join(seedDir, 'tokens.plaintext.json');
+    if (!fs.existsSync(tokPath)) {
+        throw new Error(`Missing ${tokPath} — generate bundle via enterprise admin first`);
+    }
+    const tokens = JSON.parse(fs.readFileSync(tokPath, 'utf8'));
+    if (!tokens.writer)
+        throw new Error('tokens.plaintext.json must include writer token');
+    return tokens.writer;
+}
+function resolveLicenseKey(seed, seedDir) {
+    if (seed.license?.key)
+        return seed.license.key;
+    const seedJson = path.join(seedDir, 'seed.json');
+    if (fs.existsSync(seedJson)) {
+        const full = JSON.parse(fs.readFileSync(seedJson, 'utf8'));
+        if (full.license?.key)
+            return full.license.key;
+    }
+    const env = process.env.MEMTRACE_LICENSE_KEY;
+    if (env)
+        return env;
+    throw new Error('License key not found in seed; set MEMTRACE_LICENSE_KEY or include license.key');
+}
+const DEFAULT_AUTH_URL = 'https://www.memtrace.io';
+async function verifySubscriptionWithApi(organizationId, licenseKey) {
+    const base = (process.env.MEMTRACE_AUTH_URL ?? DEFAULT_AUTH_URL).replace(/\/$/, '');
+    const resp = await fetch(`${base}/api/enterprise/install/verify`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ organizationId, licenseKey }),
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!resp.ok) {
+        const payload = await resp.json().catch(() => ({}));
+        throw new Error(payload.error ?? `Enterprise install blocked (${resp.status})`);
+    }
+    const payload = await resp.json();
+    if (!payload.ok) {
+        throw new Error('Enterprise subscription verification failed');
+    }
+}
+async function validateRemoteEndpoint(endpoint, token) {
+    const url = endpoint.replace(/\/$/, '');
+    // gRPC health is not available from Node without deps; ping via HTTP metrics if exposed.
+    const metricsUrl = url.replace(/:50051$/, ':9090');
+    try {
+        const resp = await fetch(`${metricsUrl}/metrics`, {
+            headers: token ? { Authorization: `Bearer ${token}` } : {},
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!resp.ok) {
+            console.warn(`  ⚠ MemDB metrics at ${metricsUrl} returned ${resp.status} (gRPC may still work)`);
+        }
+        else {
+            console.log(`  ✓ MemDB metrics reachable at ${metricsUrl}`);
+        }
+    }
+    catch (e) {
+        console.warn(`  ⚠ Could not reach MemDB at ${endpoint}: ${e.message}`);
+        console.warn('    Continuing — verify VPN/firewall if remote mode fails at runtime.');
+    }
+}
+function mcpPath(scope) {
+    const base = scope === 'global' ? os.homedir() : process.cwd();
+    return path.join(base, '.cursor', 'mcp.json');
+}
+export async function runEnterpriseInstall(opts) {
+    const seedPath = path.resolve(opts.seedPath);
+    const seedDir = path.dirname(seedPath);
+    const seed = loadSeed(seedPath);
+    const scope = opts.scope ?? 'global';
+    const endpoint = seed.memdb.endpoint ?? process.env.MEMTRACE_MEMDB_ENDPOINT;
+    if (!endpoint) {
+        throw new Error('memdb.endpoint required in seed or MEMTRACE_MEMDB_ENDPOINT env');
+    }
+    const writerToken = loadWriterToken(seedDir);
+    const licenseKey = resolveLicenseKey(seed, seedDir);
+    const binary = opts.binary ?? (await resolveMemtraceBinary()) ?? 'memtrace';
+    console.log('\n  Memtrace Enterprise Installer\n');
+    console.log(`  Org:      ${seed.orgId}`);
+    console.log(`  MemDB:    ${endpoint}`);
+    console.log(`  Database: ${seed.memdb.database}`);
+    console.log(`  Scope:    ${scope}\n`);
+    console.log('  Verifying enterprise subscription…');
+    await verifySubscriptionWithApi(seed.orgId, licenseKey);
+    console.log('  ✓ Subscription active');
+    await validateRemoteEndpoint(endpoint, writerToken);
+    const mcpFile = mcpPath(scope);
+    const { value, corrupted, backupPath } = safeReadJson(mcpFile);
+    if (corrupted) {
+        console.warn(`  ⚠ ${mcpFile} malformed; backed up to ${backupPath}`);
+    }
+    const cfg = (value ?? {});
+    cfg.mcpServers = cfg.mcpServers ?? {};
+    cfg.mcpServers.memtrace = {
+        command: binary,
+        args: ['mcp'],
+        env: {
+            MEMTRACE_LICENSE_KEY: licenseKey,
+            MEMTRACE_MEMDB_MODE: 'external',
+            MEMTRACE_MEMDB_ENDPOINT: endpoint,
+            MEMTRACE_MEMDB_AUTH_TOKEN: writerToken,
+            MEMTRACE_MEMDB_DB: seed.memdb.database,
+            MEMTRACE_WORKSPACE_ROOT: '${workspaceFolder}',
+        },
+    };
+    writeJsonAtomic(mcpFile, cfg);
+    console.log(`  ✓ Wrote enterprise MCP config → ${mcpFile}`);
+    // Also register via cursor helper when file is the standard cursor path
+    if (mcpFile.endsWith('.cursor/mcp.json')) {
+        registerCursorMcpAt(mcpFile, binary);
+    }
+    console.log('\n  Done. Restart Cursor and run `memtrace auth login` if needed.\n');
+}

package/installer/dist/index.js

@@ -3,6 +3,7 @@ import { Command } from 'commander';
 import { runInstall, runUninstall } from './commands/install.js';
 import { runDoctor } from './commands/doctor.js';
 import { runInstallRail, runUninstallRail } from './commands/rail-install.js';
+import { runEnterpriseInstall } from './commands/enterprise-install.js';
 const program = new Command();
 program
     .name('memtrace-skills')
@@ -46,6 +47,21 @@ program
         only: opts.only,
     });
 });
+program
+    .command('install-enterprise')
+    .description('Configure Memtrace MCP for self-hosted enterprise MemDB (remote mode)')
+    .requiredOption('--seed <path>', 'path to enterprise seed.json from your admin bundle')
+    .option('--local', 'write MCP config to the current project', false)
+    .option('--binary <path>', 'memtrace executable (default: on PATH)')
+    .option('-y, --yes', 'non-interactive')
+    .action(async (opts) => {
+    await runEnterpriseInstall({
+        seedPath: opts.seed,
+        scope: opts.local ? 'local' : 'global',
+        binary: opts.binary,
+        yes: opts.yes,
+    });
+});
 program
     .command('install-rail')
     .description('Wire Memtrace Rail discovery hooks for Claude, Cursor, Codex, Gemini, OpenCode')

package/installer/dist/transformers/claude.js

@@ -224,6 +224,10 @@ const RAIL_HOOK_MATCHER = 'Grep|Glob|Bash';
 /** Substring that identifies a memtrace-owned Rail hook entry (for idempotent
  * re-register + clean removal). */
 const RAIL_HOOK_MARKER = 'route --hook';
+const LEGACY_HOOK_SCRIPT_BASENAMES = [
+    'userprompt-claude.sh',
+    'posttool-mcp-telemetry.sh',
+];
 /**
  * Register the Memtrace Rail PreToolUse hook in a Claude settings.json.
  *
@@ -245,12 +249,13 @@ export function registerRailHookInSettingsAt(settingsPath, memtraceBinary) {
         return { registered: false, backupPath };
     }
     const settings = (value ?? {});
-    settings.hooks = settings.hooks ?? {};
+    settings.hooks = isRecord(settings.hooks) ? settings.hooks : {};
+    pruneMemtraceOwnedHookEntries(settings.hooks);
     const existing = Array.isArray(settings.hooks.PreToolUse)
         ? settings.hooks.PreToolUse
         : [];
     // Drop any prior memtrace Rail entry so re-install doesn't duplicate it.
-    const preserved = existing.filter((entry) => !isRailHookEntry(entry));
+    const preserved = existing.filter((entry) => !isMemtraceOwnedHookEntry(entry));
     preserved.push({
         matcher: RAIL_HOOK_MATCHER,
         hooks: [
@@ -266,9 +271,46 @@ export function registerRailHookInSettingsAt(settingsPath, memtraceBinary) {
 }
 /** True when a PreToolUse entry is a memtrace-owned Rail hook. */
 function isRailHookEntry(entry) {
-    if (!isRecord(entry) || !Array.isArray(entry.hooks))
-        return false;
-    return entry.hooks.some((h) => isRecord(h) && typeof h.command === 'string' && h.command.includes(RAIL_HOOK_MARKER));
+    return hookCommands(entry).some((command) => command.includes(RAIL_HOOK_MARKER));
+}
+function isLegacyMemtraceHookEntry(entry) {
+    return hookCommands(entry).some((command) => (LEGACY_HOOK_SCRIPT_BASENAMES.some((basename) => command.includes(basename))));
+}
+function isMemtraceOwnedHookEntry(entry) {
+    return isRailHookEntry(entry) || isLegacyMemtraceHookEntry(entry);
+}
+function hookCommands(entry) {
+    if (!isRecord(entry))
+        return [];
+    const commands = [];
+    if (typeof entry.command === 'string') {
+        commands.push(entry.command);
+    }
+    if (Array.isArray(entry.hooks)) {
+        for (const hook of entry.hooks) {
+            if (isRecord(hook) && typeof hook.command === 'string') {
+                commands.push(hook.command);
+            }
+        }
+    }
+    return commands;
+}
+function pruneMemtraceOwnedHookEntries(hooks) {
+    let changed = false;
+    for (const key of Object.keys(hooks)) {
+        const entries = hooks[key];
+        if (!Array.isArray(entries))
+            continue;
+        const preserved = entries.filter((entry) => !isMemtraceOwnedHookEntry(entry));
+        if (preserved.length === entries.length)
+            continue;
+        changed = true;
+        hooks[key] = preserved.length === 0 ? undefined : preserved;
+    }
+    return changed;
+}
+function hasHookSettings(hooks) {
+    return Object.values(hooks).some((entries) => (entries !== undefined && (!Array.isArray(entries) || entries.length > 0)));
 }
 /**
  * Remove the Memtrace Rail PreToolUse hook from a Claude settings.json.
@@ -361,21 +403,11 @@ export function removeClaudeSettingsEntriesAt(settingsPath) {
         if (Object.keys(mcpServers).length === 0)
             delete settings.mcpServers;
     }
-    // ─── memtrace-rail ─── Remove the Rail PreToolUse hook on uninstall.
-    if (isRecord(settings.hooks) && Array.isArray(settings.hooks.PreToolUse)) {
-        const pre = settings.hooks.PreToolUse;
-        const after = pre.filter((entry) => !isRailHookEntry(entry));
-        if (after.length !== pre.length) {
-            changed = true;
-            if (after.length === 0) {
-                delete settings.hooks.PreToolUse;
-            }
-            else {
-                settings.hooks.PreToolUse = after;
-            }
-            if (Object.keys(settings.hooks).length === 0)
-                delete settings.hooks;
-        }
+    // ─── memtrace-rail ─── Remove current Rail and legacy telemetry hooks on uninstall.
+    if (isRecord(settings.hooks)) {
+        changed = pruneMemtraceOwnedHookEntries(settings.hooks) || changed;
+        if (!hasHookSettings(settings.hooks))
+            settings.hooks = undefined;
     }
     for (const containerName of MARKETPLACE_SETTING_CONTAINERS) {
         const container = settings[containerName];

package/installer/package.json

@@ -1,10 +1,10 @@
 {
   "name": "memtrace-skills",
-  "version": "0.1.0",
+  "version": "0.7.20",
   "description": "Memtrace skills for AI coding agents — codebase exploration, temporal evolution, impact analysis, and more.",
   "type": "module",
   "bin": {
-    "memtrace-skills": "./dist/index.js"
+    "memtrace-skills": "dist/index.js"
   },
   "files": [
     "dist/",
@@ -37,7 +37,7 @@
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
-    "url": "https://github.com/syncable-dev/memtrace"
+    "url": "git+https://github.com/syncable-dev/memtrace.git"
   },
   "keywords": [
     "memtrace",

package/lib/claude-integration.js

@@ -87,6 +87,72 @@ const CLAUDE_MD_BREADCRUMB = CLAUDE_MD_BREADCRUMB_LINES.join("\n");
 
 const HOOK_MANAGED_TAG = "memtrace";
 
+// ── Pure functions: hook command string (cross-platform) ──────────────
+
+/**
+ * Build the `command` string Claude Code runs for one of our hook
+ * scripts. Pure — the platform is injected so the win32 branch is
+ * unit-testable on any host.
+ *
+ * Claude Code executes hook commands through Git Bash on Windows. Two
+ * things break a bare `path.join(hooksDir, script)` value there
+ * (issue #34):
+ *
+ *   1. A bare `.sh` path is not directly executable on Windows — it has
+ *      to be handed to `bash`.
+ *   2. `path.join` yields backslashes (`C:\Users\…`), and bash eats
+ *      backslashes as escape sequences, mangling the path into a
+ *      "No such file or directory" on every UserPromptSubmit and every
+ *      `mcp__memtrace__*` PostToolUse.
+ *
+ * The form that works under Git Bash is:
+ *   bash "C:/Users/…/userprompt-claude.sh"
+ * (forward slashes, double-quoted, `bash ` prefix).
+ *
+ * On non-win32 (mac/linux) we keep the existing bare absolute path —
+ * those scripts are executable via their shebang and existing installs
+ * must not regress.
+ *
+ * @param {string} hooksDir   absolute directory containing the hook scripts
+ * @param {string} scriptName e.g. `"userprompt-claude.sh"`
+ * @param {string} [platform] defaults to `process.platform`; pass
+ *                            `"win32"` to exercise the Windows branch in
+ *                            tests without running on Windows
+ * @returns {string}
+ */
+function hookCommandString(hooksDir, scriptName, platform = process.platform) {
+    if (platform === "win32") {
+        // Join with the win32 semantics so a test on POSIX still produces
+        // a Windows-shaped path, then normalise every separator to '/'.
+        const joined = path.win32.join(hooksDir, scriptName).replace(/\\/g, "/");
+        return `bash "${joined}"`;
+    }
+    return path.join(hooksDir, scriptName);
+}
+
+/**
+ * Pull the hook script basename out of a `command` string, robust to
+ * BOTH a bare path AND a `bash "<path>"`-wrapped command, with either
+ * '/' or '\\' separators and surrounding/embedded quotes (issue #34).
+ *
+ * `path.basename` alone is not enough once we emit `bash "C:/…/x.sh"`:
+ * its basename is `x.sh"` (trailing quote) on POSIX, and it doesn't
+ * understand backslash separators off-Windows. Both break the dedup
+ * that keeps installs idempotent. We strip quotes, normalise '\\'→'/',
+ * and take the final segment so the bare and wrapped forms collapse to
+ * the same basename.
+ *
+ * @param {string} command
+ * @returns {string|null}
+ */
+function hookScriptBasename(command) {
+    if (typeof command !== "string") return null;
+    const cleaned = command.replace(/["']/g, "").replace(/\\/g, "/").trim();
+    const segments = cleaned.split("/");
+    const last = segments[segments.length - 1];
+    return last || null;
+}
+
 // ── Pure functions: MEMTRACE.md content ───────────────────────────────
 
 /**
@@ -184,13 +250,13 @@ function applySettingsHooks(settings, hooksDir) {
 
     const userPromptHook = {
         type: "command",
-        command: path.join(hooksDir, "userprompt-claude.sh"),
+        command: hookCommandString(hooksDir, "userprompt-claude.sh"),
         _managed_by: HOOK_MANAGED_TAG,
         _hook_kind: "userprompt-advisory",
     };
     const postToolHook = {
         type: "command",
-        command: path.join(hooksDir, "posttool-mcp-telemetry.sh"),
+        command: hookCommandString(hooksDir, "posttool-mcp-telemetry.sh"),
         _managed_by: HOOK_MANAGED_TAG,
         _hook_kind: "posttool-mcp-telemetry",
     };
@@ -269,15 +335,19 @@ function applySettingsHooks(settings, hooksDir) {
  * @returns {Array}
  */
 function mergeHookList(existing, ourEntry, ourHook) {
-    const ourBasename =
-        typeof ourHook.command === "string" ? path.basename(ourHook.command) : null;
+    // Use the quote/separator-robust extractor (not raw path.basename) so
+    // a `bash "C:/…/x.sh"`-wrapped Windows command (issue #34) collapses to
+    // the same basename as the bare POSIX form — otherwise path.basename
+    // would yield `x.sh"` (trailing quote) and the dedup would stop
+    // recognising the working Windows form, re-injecting a duplicate.
+    const ourBasename = hookScriptBasename(ourHook.command);
     const isOurs = (h) =>
         !!h && (
             (h._managed_by === HOOK_MANAGED_TAG && h._hook_kind === ourHook._hook_kind) ||
             (typeof h.command === "string" && h.command === ourHook.command) ||
             (ourBasename !== null &&
                 typeof h.command === "string" &&
-                path.basename(h.command) === ourBasename)
+                hookScriptBasename(h.command) === ourBasename)
         );
 
     // Phase 1: walk every block, strip every "ours" hook, drop blocks
@@ -499,6 +569,8 @@ module.exports = {
     CLAUDE_MD_BREADCRUMB,
 
     // Pure functions
+    hookCommandString,
+    hookScriptBasename,
     buildMemtraceMdContent,
     applyClaudeMdBreadcrumb,
     removeClaudeMdBreadcrumb,

package/package.json

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

package/uninstall.js

@@ -131,7 +131,12 @@ function isMemtraceHook(h) {
   if (typeof h.command === "string") {
     if (h.command.includes(MT_RAIL_HOOK_MARKER)) return true;
     for (const script of MT_HOOK_SCRIPTS) {
-      if (h.command.endsWith(script)) return true;
+      // `.includes`, not `.endsWith`: the Windows form is wrapped as
+      // `bash "C:/…/userprompt-claude.sh"` (issue #34), so the command
+      // ends in a double-quote, not the bare script name. `.includes`
+      // recognises both the bare POSIX path and the bash-wrapped Windows
+      // command so uninstall removes either form.
+      if (h.command.includes(script)) return true;
     }
   }
   return false;