prism-mcp-server 19.2.6 → 19.2.8

package/dist/dashboard/server.js

@@ -558,7 +558,7 @@ return false;}
             // GET /api/skills → { skills: { dev: "...", qa: "..." } }
             if (url.pathname === "/api/skills" && req.method === "GET") {
                 const all = await getAllSettings();
-                const skills = {};
+                const skills = Object.create(null);
                 for (const [k, v] of Object.entries(all)) {
                     if (k.startsWith("skill:") && v) {
                         skills[k.replace("skill:", "")] = v;

package/dist/scholar/webScholar.js

@@ -3,7 +3,7 @@ import { getStorage } from "../storage/index.js";
 import { debugLog } from "../utils/logger.js";
 import { getLLMProvider } from "../utils/llm/factory.js";
 import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { performWebSearchRaw } from "../utils/braveApi.js";
@@ -115,20 +115,53 @@ function acquireFileLock() {
         const lockDir = dirname(LOCK_PATH);
         if (!existsSync(lockDir))
             mkdirSync(lockDir, { recursive: true });
-        if (existsSync(LOCK_PATH)) {
-            const stat = statSync(LOCK_PATH);
-            const ageMs = Date.now() - stat.mtimeMs;
-            if (ageMs < LOCK_STALE_MS)
+        const lockContent = `${process.pid}\n${new Date().toISOString()}`;
+        // Fast path: exclusive create — no lock exists.
+        try {
+            writeFileSync(LOCK_PATH, lockContent, { flag: "wx" });
+            return true;
+        }
+        catch (wxErr) {
+            if (wxErr?.code !== "EEXIST")
                 return false;
-            unlinkSync(LOCK_PATH);
         }
-        // wx = exclusive create — throws EEXIST if another process won the race
-        writeFileSync(LOCK_PATH, `${process.pid}\n${new Date().toISOString()}`, { flag: "wx" });
+        // Lock exists — check if stale.
+        let stat;
+        try {
+            stat = statSync(LOCK_PATH);
+        }
+        catch {
+            return false;
+        }
+        if (Date.now() - stat.mtimeMs < LOCK_STALE_MS)
+            return false;
+        // Stale lock — atomic takeover via rename.
+        // Write our identity to a temp file, then rename over the lock.
+        // rename() is atomic on POSIX; no window where the lock is absent.
+        const tmpLock = `${LOCK_PATH}.${process.pid}`;
+        try {
+            writeFileSync(tmpLock, lockContent, { flag: "wx" });
+            renameSync(tmpLock, LOCK_PATH);
+        }
+        catch {
+            try {
+                unlinkSync(tmpLock);
+            }
+            catch { /* cleanup */ }
+            return false;
+        }
+        // Verify we own the lock (another process may have renamed over us).
+        try {
+            const owner = readFileSync(LOCK_PATH, "utf-8").split("\n")[0];
+            if (owner !== String(process.pid))
+                return false;
+        }
+        catch {
+            return false;
+        }
         return true;
     }
-    catch (err) {
-        if (err?.code === "EEXIST")
-            return false;
+    catch {
         return false;
     }
 }

package/dist/server.js

@@ -76,6 +76,7 @@ import { verifyBehaviorHandler } from "./tools/behavioralVerifierHandler.js";
 import { getStorage } from "./storage/index.js";
 import { getSettingSync, initConfigStorage } from "./storage/configStorage.js";
 import { sanitizeMcpOutput } from "./utils/sanitizer.js";
+import { sanitizeForLog } from "./utils/logger.js";
 import { getTracer, initTelemetry } from "./utils/telemetry.js";
 import { context as otelContext, trace, SpanStatusCode } from "@opentelemetry/api";
 import { ddInfo, ddError as ddLogError } from "./utils/ddLogger.js";
@@ -1020,7 +1021,7 @@ export function createServer() {
             catch (error) {
                 const errMsg = error instanceof Error ? error.message : String(error);
                 const _ddErrDuration = Date.now() - _ddStart;
-                console.error(`Error in tool handler: ${errMsg}`);
+                console.error(`Error in tool handler: ${sanitizeForLog(errMsg)}`);
                 ddLogError("mcp.tool.error", error instanceof Error ? error : undefined, { tool: name, project: args?.project, durationMs: _ddErrDuration });
                 rootSpan.recordException(error instanceof Error ? error : new Error(errMsg));
                 rootSpan.setStatus({

package/dist/storage/configStorage.js

@@ -2,6 +2,7 @@ import { createClient } from "@libsql/client";
 import { resolve, dirname } from "path";
 import { homedir } from "os";
 import { existsSync, mkdirSync } from "fs";
+const PROTO_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 // We use a small, dedicated DB just for configuration settings.
 // This solves the chicken-and-egg problem: we need to know WHICH
 // storage backend to boot *before* we can use that backend.
@@ -22,7 +23,7 @@ let initialized = false;
 // (e.g. ReadResourceRequestSchema) can read settings synchronously
 // without opening an additional SQLite round-trip and stalling the
 // MCP stdio handshake (which causes a black-screen on startup).
-let settingsCache = null;
+let settingsCache = null; // assigned as Object.create(null) below
 function getClient() {
     if (!configClient) {
         // Ensure the directory exists before opening the DB.
@@ -52,9 +53,12 @@ export async function initConfigStorage() {
     `);
         // Preload all rows into the cache so subsequent reads are zero-cost.
         const rs = await client.execute("SELECT key, value FROM system_settings");
-        settingsCache = {};
+        settingsCache = Object.create(null);
+        const cache = settingsCache;
         for (const row of rs.rows) {
-            settingsCache[row.key] = row.value;
+            const k = row.key;
+            if (!PROTO_KEYS.has(k))
+                cache[k] = row.value;
         }
     }
     catch (err) {
@@ -63,7 +67,7 @@ export async function initConfigStorage() {
         // getSettingSync() will return defaults; getSetting()/setSetting()
         // will attempt to re-open the DB on first call.
         console.error(`[configStorage] Failed to initialize (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
-        settingsCache = {};
+        settingsCache = Object.create(null);
     }
     initialized = true;
 }
@@ -93,7 +97,7 @@ export async function getSetting(key, defaultValue = "") {
     if (rs.rows.length > 0) {
         const value = rs.rows[0].value;
         // Populate cache entry for future reads.
-        if (settingsCache)
+        if (settingsCache && !PROTO_KEYS.has(key))
             settingsCache[key] = value;
         return value;
     }
@@ -117,7 +121,7 @@ export async function setSetting(key, value) {
                 args: [key, value],
             });
             // Keep the cache in sync so getSettingSync() reflects the new value immediately.
-            if (settingsCache && typeof key === "string" && !["__proto__", "constructor", "prototype"].includes(key)) {
+            if (settingsCache && typeof key === "string" && !PROTO_KEYS.has(key)) {
                 settingsCache[key] = value;
             }
             return; // Success — exit
@@ -142,9 +146,11 @@ export async function getAllSettings() {
     }
     const client = getClient();
     const rs = await client.execute("SELECT key, value FROM system_settings");
-    const settings = {};
+    const settings = Object.create(null);
     for (const row of rs.rows) {
-        settings[row.key] = row.value;
+        const k = row.key;
+        if (!PROTO_KEYS.has(k))
+            settings[k] = row.value;
     }
     return settings;
 }

package/dist/tools/commonHelpers.js

@@ -46,7 +46,7 @@ export function applySentinelBlock(existingContent, rulesBlock) {
     return `${existingContent}${separator}${rulesBlock}\n`;
 }
 export function redactSettings(settings) {
-    const redacted = {};
+    const redacted = Object.create(null);
     for (const [k, v] of Object.entries(settings || {})) {
         if (typeof k !== "string" || k === "__proto__" || k === "constructor" || k === "prototype")
             continue;

package/dist/tools/ingestHandler.js

@@ -12,6 +12,7 @@
  * The handler is storage-agnostic — works with SQLite (local) or Supabase (remote).
  */
 import { readFileSync, existsSync } from "fs";
+import { resolve as resolvePath } from "path";
 import { basename } from "path";
 import { PRISM_USER_ID } from "../config.js";
 import { getStorage } from "../storage/index.js";
@@ -103,7 +104,7 @@ export async function ingestKnowledge(args) {
     const { project, source_label, chunk_size = 4000, } = args;
     let content = args.content || "";
     if (args.file_path) {
-        const resolved = require("path").resolve(args.file_path);
+        const resolved = resolvePath(args.file_path);
         const blocked = ["/etc", "/var", "/usr", "/sys", "/proc", "/dev", "/root",
             "/.ssh", "/.env", "/.git/config", "/private/etc"].some(p => resolved.startsWith(p) || resolved.includes("/."));
         if (blocked) {

package/dist/tools/ledgerHandlers.js

@@ -1581,7 +1581,8 @@ export async function sessionExportMemoryHandler(args) {
             // Serialize
             const ext = format === "markdown" ? "md" : format === "vault" ? "zip" : "json";
             const safeProject = project.replace(/[^a-zA-Z0-9_-]/g, "_");
-            const filename = `prism-export-${safeProject}-${dateSuffix}.${ext}`;
+            const token = randomUUID().slice(0, 8);
+            const filename = `prism-export-${safeProject}-${dateSuffix}-${token}.${ext}`;
             const outputPath = join(output_dir, filename);
             let content;
             if (format === "vault") {
@@ -1611,7 +1612,7 @@ export async function sessionExportMemoryHandler(args) {
                     const dot = filename.lastIndexOf(".");
                     const stem = dot > 0 ? filename.slice(0, dot) : filename;
                     const extPart = dot > 0 ? filename.slice(dot) : "";
-                    finalPath = join(output_dir, `${stem}-${Date.now()}${extPart}`);
+                    finalPath = join(output_dir, `${stem}-${randomUUID()}${extPart}`);
                     await writeFile(finalPath, content, { flag: "wx" });
                 }
                 else {

package/dist/utils/imageCaptioner.js

@@ -30,7 +30,7 @@ import * as fs from "fs";
 import * as nodePath from "path";
 import { getLLMProvider } from "./llm/factory.js";
 import { getStorage } from "../storage/index.js";
-import { debugLog } from "./logger.js";
+import { debugLog, sanitizeForLog } from "./logger.js";
 import { PRISM_USER_ID } from "../config.js";
 import { getTracer } from "./telemetry.js";
 import { SpanStatusCode, context as otelContext, trace } from "@opentelemetry/api";
@@ -93,7 +93,7 @@ export function fireCaptionAsync(project, imageId, vaultPath, userContext) {
                 code: SpanStatusCode.ERROR,
                 message: err instanceof Error ? err.message : String(err),
             });
-            console.error(`[ImageCaptioner] Failed for [${imageId}]: ${err instanceof Error ? err.message : String(err)}`);
+            console.error(`[ImageCaptioner] Failed for [${sanitizeForLog(imageId)}]: ${sanitizeForLog(err instanceof Error ? err.message : String(err))}`);
         })
             .finally(() => {
             // Always end the span — even on VLM failure — to flush the BatchSpanProcessor.
@@ -127,8 +127,8 @@ async function captionImageAsync(project, imageId, vaultPath, userContext) {
     if (fileSizeBytes > maxBytes) {
         const limitMB = (maxBytes / 1024 / 1024).toFixed(0);
         const actualMB = (fileSizeBytes / 1024 / 1024).toFixed(1);
-        console.warn(`[ImageCaptioner] Image [${imageId}] is ${actualMB}MB, exceeding ` +
-            `the ${textProvider} VLM limit (${limitMB}MB). Captioning skipped. ` +
+        console.warn(`[ImageCaptioner] Image [${sanitizeForLog(imageId)}] is ${sanitizeForLog(actualMB)}MB, exceeding ` +
+            `the ${sanitizeForLog(textProvider)} VLM limit (${limitMB}MB). Captioning skipped. ` +
             (textProvider === "anthropic"
                 ? "Switch Embedding Provider to Gemini/OpenAI to caption larger images."
                 : "Consider resizing the image."));
@@ -165,8 +165,8 @@ async function captionImageAsync(project, imageId, vaultPath, userContext) {
             // Don't poison the caption pipeline. The caption already succeeded;
             // OCR is additive value. Surface as warn (not error) so it's grep-able
             // but doesn't trip alerting on transient VLM blips.
-            console.warn(`[ImageCaptioner] OCR failed for [${imageId}] (non-fatal): ` +
-                `${ocrErr instanceof Error ? ocrErr.message : String(ocrErr)}`);
+            console.warn(`[ImageCaptioner] OCR failed for [${sanitizeForLog(imageId)}] (non-fatal): ` +
+                `${sanitizeForLog(ocrErr instanceof Error ? ocrErr.message : String(ocrErr))}`);
         }
     }
     // ── Step 4: Patch handoff visual_memory entry ─────────────────────────
@@ -282,6 +282,6 @@ async function updateHandoffCaption(project, imageId, caption, vaultPath, ocrTex
         // OCC conflict — retry once with fresh version
         debugLog(`[ImageCaptioner] OCC conflict patching [${imageId}], attempt ${attempt}. Retrying…`);
     }
-    console.warn(`[ImageCaptioner] Could not patch handoff for [${imageId}] after 2 attempts. ` +
+    console.warn(`[ImageCaptioner] Could not patch handoff for [${sanitizeForLog(imageId)}] after 2 attempts. ` +
         `Caption is still saved in the ledger and will surface via semantic search.`);
 }

package/dist/utils/llm/factory.js

@@ -47,6 +47,7 @@ import { VoyageAdapter } from "./adapters/voyage.js";
 import { LocalEmbeddingAdapter } from "./adapters/local.js";
 import { DisabledTextAdapter } from "./adapters/disabledText.js";
 import { TracingLLMProvider } from "./adapters/traced.js";
+import { sanitizeForLog } from "../logger.js";
 // Module-level singleton — one composed provider per MCP server process.
 let providerInstance = null;
 // ─── Adapter Builders ─────────────────────────────────────────────────────────
@@ -149,13 +150,13 @@ export function getLLMProvider() {
         // The text provider name is used as the primary span attribute label.
         providerInstance = new TracingLLMProvider(composed, textType);
         if (textType !== embedType) {
-            console.info(`[LLMFactory] Split provider: text=${textType}, embedding=${embedType}`);
+            console.info(`[LLMFactory] Split provider: text=${sanitizeForLog(textType)}, embedding=${sanitizeForLog(embedType)}`);
         }
     }
     catch (err) {
         // Init failure (e.g. missing API key) → fall back to full Gemini provider.
         // A crash here would silently kill the MCP server.
-        console.error(`[LLMFactory] Failed to initialise providers (text=${textType}, embed=${embedType}): ${err instanceof Error ? err.message : String(err)}. ` +
+        console.error(`[LLMFactory] Failed to initialise providers (text=${sanitizeForLog(textType)}, embed=${sanitizeForLog(embedType)}): ${sanitizeForLog(err instanceof Error ? err.message : String(err))}. ` +
             `Falling back to GeminiAdapter for both.`);
         const fallback = new GeminiAdapter();
         const fallbackComposed = {

package/dist/utils/logger.js

@@ -4,11 +4,11 @@ import { PRISM_DEBUG_LOGGING } from "../config.js";
  * newlines, and ANSI escape sequences that could be used for log
  * injection or terminal escape attacks.
  */
-function sanitizeForLog(msg) {
+export function sanitizeForLog(msg) {
     return msg
-        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "") // control chars (keep \n \r \t)
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g, "") // C0 + C1 control chars (keep \n \r \t)
         .replace(/\r?\n/g, " ⏎ ") // newlines → visible marker
-        .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, ""); // ANSI escape sequences
+        .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, ""); // CSI residue (defense-in-depth if first regex relaxed)
 }
 /**
  * Logs a message to stderr only if PRISM_DEBUG_LOGGING is true.

package/dist/utils/migration/utils.js

@@ -1,3 +1,4 @@
+import { openSync, readSync, closeSync } from "node:fs";
 /**
  * ═══════════════════════════════════════════════════════════════════
  * Migration Utilities — Shared Normalization Helpers
@@ -43,11 +44,10 @@
  *   OpenAI  → `"tool_calls":` or `"created_at":` (Unix epoch) or `"role":"system"`
  */
 export function sniffFormat(filePath) {
-    const fs = require('node:fs');
-    const fd = fs.openSync(filePath, 'r');
+    const fd = openSync(filePath, 'r');
     const buf = Buffer.alloc(4096);
-    const bytesRead = fs.readSync(fd, buf, 0, 4096, 0);
-    fs.closeSync(fd);
+    const bytesRead = readSync(fd, buf, 0, 4096, 0);
+    closeSync(fd);
     if (bytesRead === 0)
         return null;
     const head = buf.toString('utf8', 0, bytesRead);

package/dist/utils/telemetry.js

@@ -61,6 +61,7 @@ import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import { SEMRESATTRS_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 import { getSettingSync } from "../storage/configStorage.js";
+import { sanitizeForLog } from "./logger.js";
 // ─── Module-level singleton ───────────────────────────────────────────────────
 // Null when OTel is disabled or before initTelemetry() is called.
 let _provider = null;
@@ -175,11 +176,11 @@ export function initTelemetry() {
         });
         _provider.register();
         console.error(`[Telemetry] OpenTelemetry initialized. ` +
-            `Service: "${serviceName}", Endpoint: "${endpoint}"`);
+            `Service: "${sanitizeForLog(serviceName)}", Endpoint: "${sanitizeForLog(endpoint)}"`);
     }
     catch (err) {
         // OTel init errors must NEVER crash the server. Log and continue.
-        console.error(`[Telemetry] Failed to initialize OTel (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`[Telemetry] Failed to initialize OTel (non-fatal): ${sanitizeForLog(err instanceof Error ? err.message : String(err))}`);
         _provider = null; // Clean state so getTracer() returns no-op
     }
 }
@@ -226,6 +227,6 @@ export async function shutdownTelemetry() {
     }
     catch (err) {
         // Log but don't rethrow — shutdown errors must not prevent DB cleanup.
-        console.error(`[Telemetry] Error during shutdown (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`[Telemetry] Error during shutdown (non-fatal): ${sanitizeForLog(err instanceof Error ? err.message : String(err))}`);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "19.2.6",
+  "version": "19.2.8",
   "mcpName": "io.github.dcostenco/prism-coder",
   "description": "Prism Coder — Cognitive memory + tool-calling intelligence for AI agents. Mind Palace persistent memory (BFCL Gold Certified, 100% Tool-Call Accuracy, 114 Agent Skills, PHI Guard, Tier Enforcement, Prompt-Based Skill Routing, Zero-Search HDC/HRR retrieval, HRR Semantic Drift Detection across BCBA/Coding/AAC domains, HIPAA-hardened local-first storage, SLERP-optimized GRPO alignment) plus the prism-coder 1.7B–32B open-weights LLM fleet.",
   "module": "index.ts",