prism-mcp-server 12.5.7 → 13.0.0

package/dist/scholar/freeSearch.js

@@ -47,16 +47,26 @@ export async function searchYahooFree(query, limit = 5) {
  * and converts it to Markdown using Turndown.
  */
 export async function scrapeArticleLocal(url) {
-    // SSRF protection: reject private/internal URLs
+    // SSRF protection: reject private/internal URLs.
+    // Set PRISM_DEV_MODE=1 to allow loopback/private hosts during local dev
+    // (testing against a local docs server, internal wiki, etc.). The flag
+    // is intentionally OFF in production deploys.
+    const devMode = process.env.PRISM_DEV_MODE === '1' || process.env.NODE_ENV === 'development';
     try {
         const parsed = new URL(url);
         if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:')
             throw new Error('Invalid protocol');
         const host = parsed.hostname.toLowerCase();
-        if (host === 'localhost' || host === '127.0.0.1' || host === '::1' ||
-            host.startsWith('10.') || host.startsWith('192.168.') || host.startsWith('169.254.') ||
-            /^172\.(1[6-9]|2\d|3[01])\./.test(host) || host.endsWith('.internal') || host.endsWith('.local')) {
-            throw new Error('Internal URLs not allowed');
+        const isLoopback = host === 'localhost' || host === '127.0.0.1' || host === '::1';
+        const isPrivate = host.startsWith('10.') || host.startsWith('192.168.') || host.startsWith('169.254.') ||
+            /^172\.(1[6-9]|2\d|3[01])\./.test(host) || host.endsWith('.internal') || host.endsWith('.local');
+        if (isLoopback && !devMode) {
+            throw new Error('Loopback URLs not allowed in production (set PRISM_DEV_MODE=1 to allow)');
+        }
+        if (isPrivate) {
+            // Private RFC1918 ranges are never allowed — even in dev mode they
+            // can cross into other tenants' machines on a shared LAN.
+            throw new Error('Private network URLs not allowed');
         }
     }
     catch (e) {

package/dist/sync/encryptedSync.js

@@ -128,7 +128,17 @@ export async function prepareSyncPacket(sourceId, targetPeerId, entries, sharedS
 export function receiveSyncPacket(encrypted, sharedSecret) {
     const key = deriveKey(sharedSecret);
     const decrypted = decrypt(encrypted, key);
-    const payload = JSON.parse(decrypted);
+    // Wrap JSON.parse so a malformed payload from a misbehaving peer doesn't
+    // crash the receiver with an unhandled SyntaxError. We re-throw with a
+    // typed message so callers can distinguish corruption from auth failures.
+    let payload;
+    try {
+        payload = JSON.parse(decrypted);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Sync payload corrupted: invalid JSON (${msg})`);
+    }
     if (!verifySyncPayload(payload)) {
         throw new Error("Sync payload integrity check failed — checksum mismatch");
     }

package/dist/tools/adaptiveDefinitions.js

@@ -0,0 +1,148 @@
+export const ADAPTIVE_GET_PROFILE_TOOL = {
+    name: "adaptive_get_profile",
+    description: "Get the user's current adaptive profile and a compact signals snapshot. " +
+        "Use this when you need the user's dominant mood, motor rhythm, noise " +
+        "environment, or vocabulary preferences — typically before generating a " +
+        "response that should match their state. Returns the full profile plus a " +
+        "small `signals` block that is safe to embed in a prompt.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            user_id: {
+                type: "string",
+                description: "Optional. User identifier. If omitted, the server uses the authenticated user from context.",
+            },
+            include_history: {
+                type: "boolean",
+                description: "If true, include the toneHistory and full timeOfDayPatterns. Defaults to false (signals + summary only) to keep payload small.",
+            },
+        },
+    },
+};
+export const ADAPTIVE_SET_PROFILE_TOOL = {
+    name: "adaptive_set_profile",
+    description: "Replace the user's adaptive profile in full. Intended for caregivers " +
+        "syncing across devices, restoring from backup, or admin migration. " +
+        "Schema must match version 2 of the AdaptiveProfile (see " +
+        "src/shared/adaptiveEngine.ts).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            user_id: {
+                type: "string",
+                description: "Optional. User identifier (defaults to authenticated user).",
+            },
+            profile: {
+                type: "object",
+                description: "Full AdaptiveProfile object. Must include version: 2.",
+            },
+        },
+        required: ["profile"],
+    },
+};
+export const ADAPTIVE_RECORD_EVENT_TOOL = {
+    name: "adaptive_record_event",
+    description: "Record a single behavioral event into the adaptive profile. " +
+        "Use this from any surface that observes user behavior (voice agents, " +
+        "AAC dwell triggers, message logs). Events are written incrementally — " +
+        "no need to fetch+modify+save the whole profile. " +
+        "Event types: " +
+        "tone (text → AdaptiveTone, also records to toneHistory), " +
+        "dwell (dwellMs sample for motor rhythm), " +
+        "move_speed (px/sec sample for cursor smoothing), " +
+        "noise (rmsDb sample for environment), " +
+        "message (text + optional categoryId for vocab + frequency tracking), " +
+        "mispronunciation (heard → intended; emergency words always pass through).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            user_id: { type: "string", description: "Optional user id." },
+            event: {
+                type: "string",
+                enum: ["tone", "dwell", "move_speed", "noise", "message", "mispronunciation"],
+                description: "Event type.",
+            },
+            text: {
+                type: "string",
+                description: "For tone/message: the utterance text. For mispronunciation: the heard form.",
+            },
+            intended: {
+                type: "string",
+                description: "For mispronunciation: the corrected form.",
+            },
+            value: {
+                type: "number",
+                description: "For dwell/move_speed/noise: the numeric sample.",
+            },
+            category_id: {
+                type: "string",
+                description: "For message: optional category id (e.g. 'food', 'feelings').",
+            },
+        },
+        required: ["event"],
+    },
+};
+export const ADAPTIVE_DETECT_TONE_TOOL = {
+    name: "adaptive_detect_tone",
+    description: "Detect emotional tone from a piece of text WITHOUT recording it. " +
+        "Pure function — useful when you want to route a response (e.g. choose " +
+        "a TTS voice style or shape an LLM system prompt) but don't want to " +
+        "perturb the user's profile. Returns one of: " +
+        "neutral | friendly | excited | empathetic | serious. Emergency words " +
+        "(help/hurt/scared/911/etc) always map to 'serious'.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            text: { type: "string", description: "Text to analyze." },
+        },
+        required: ["text"],
+    },
+};
+export const ADAPTIVE_RESET_TOOL = {
+    name: "adaptive_reset",
+    description: "Wipe the user's adaptive profile. Caregiver-initiated reset only — " +
+        "resets all learned dwell, motor speed, vocabulary, mispronunciation " +
+        "corrections, tone history, and noise calibration. Returns the fresh " +
+        "default profile.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            user_id: { type: "string", description: "Optional user id." },
+            confirm: {
+                type: "boolean",
+                description: "Must be true. Defends against accidental reset.",
+            },
+        },
+        required: ["confirm"],
+    },
+};
+// ─── Type guards (mirror the patterns used elsewhere in this repo) ───
+export function isAdaptiveGetProfileArgs(args) {
+    return typeof args === "object" && args !== null;
+}
+export function isAdaptiveSetProfileArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "profile" in args &&
+        typeof args.profile === "object" &&
+        args.profile !== null);
+}
+export function isAdaptiveRecordEventArgs(args) {
+    if (typeof args !== "object" || args === null)
+        return false;
+    const a = args;
+    return (typeof a.event === "string" &&
+        ["tone", "dwell", "move_speed", "noise", "message", "mispronunciation"].includes(a.event));
+}
+export function isAdaptiveDetectToneArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "text" in args &&
+        typeof args.text === "string");
+}
+export function isAdaptiveResetArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "confirm" in args &&
+        args.confirm === true);
+}

package/dist/tools/ledgerHandlers.js

@@ -787,21 +787,65 @@ export async function sessionLoadContextHandler(args) {
     // agent loads its rules/conventions automatically at session start.
     let skillBlock = "";
     let skillLoaded = false;
+    const loadedSkills = [];
     if (effectiveRole) {
         const skillContent = await getSetting(`skill:${effectiveRole}`, "");
         if (skillContent && skillContent.trim()) {
             skillBlock = `\n\n[📜 ROLE SKILL: ${effectiveRole}]\n${skillContent.trim()}`;
             skillLoaded = true;
+            loadedSkills.push(effectiveRole);
             debugLog(`[session_load_context] Injecting skill for role="${effectiveRole}" (${skillContent.length} chars)`);
         }
     }
+    // ─── Project-Aware Skill Injection ──────────────────────────
+    // Skill routing (which skills load for which project) is the SINGLE
+    // SOURCE OF TRUTH at synalux: /api/v1/skills/routing. We pull the
+    // canonical table on every session and resolve locally. Skill CONTENT
+    // continues to be stored in this server's settings under skill:<name>
+    // — synalux owns the WHICH, this server owns the WHAT, no duplication
+    // of the routing config in three repos.
+    const { resolveSkillsForProject } = await import("./skillRouting.js");
+    const skillsToLoad = await resolveSkillsForProject(project);
+    for (const skillName of skillsToLoad) {
+        if (loadedSkills.includes(skillName))
+            continue;
+        const content = await getSetting(`skill:${skillName}`, "");
+        if (content && content.trim()) {
+            skillBlock += `\n\n[📜 SKILL: ${skillName}]\n${content.trim()}`;
+            loadedSkills.push(skillName);
+            skillLoaded = true;
+            debugLog(`[session_load_context] Skill "${skillName}" loaded for project="${project}"`);
+        }
+    }
+    // ─── Memory-Based Skill Discovery ──────────────────────────
+    // If recent handoff/ledger mentions a skill name, auto-load it.
+    // This lets the agent's own memory drive skill activation.
+    if (formattedContext.length > 0) {
+        const contextText = formattedContext.toLowerCase();
+        const allSkillKeys = await storage.getAllSettings?.() || {};
+        for (const [k, v] of Object.entries(allSkillKeys)) {
+            if (!k.startsWith("skill:") || !v)
+                continue;
+            const skillName = k.replace("skill:", "");
+            if (loadedSkills.includes(skillName))
+                continue;
+            // Only load if the skill name appears in recent context
+            if (contextText.includes(skillName.replace(/-/g, " ")) || contextText.includes(skillName)) {
+                skillBlock += `\n\n[📜 CONTEXT SKILL: ${skillName}]\n${v}`;
+                loadedSkills.push(skillName);
+                debugLog(`[session_load_context] Context-triggered skill "${skillName}"`);
+            }
+        }
+    }
     // ─── Agent Greeting Block ────────────────────────────────────
     // Shows agent identity (name + role) and skill status after briefing.
     let greetingBlock = "";
     if (agentName || effectiveRole) {
         const namePart = agentName ? `👋 **${agentName}**` : `👋 **Agent**`;
         const rolePart = effectiveRole ? ` · Role: \`${effectiveRole}\`` : "";
-        const skillPart = skillLoaded ? ` · 📜 \`${effectiveRole}\` skill loaded` : (effectiveRole ? " · 📜 No skill configured" : "");
+        const skillPart = loadedSkills.length > 0
+            ? ` · 📜 Skills: ${loadedSkills.map(s => `\`${s}\``).join(", ")}`
+            : (effectiveRole ? " · 📜 No skill configured" : "");
         greetingBlock = `\n\n[👤 AGENT IDENTITY]\n${namePart}${rolePart}${skillPart}`;
     }
     // ─── SDM Intuitive Recall (v5.5) ───
@@ -984,7 +1028,8 @@ export async function sessionSaveImageHandler(args) {
     const resolvedPath = nodePath.resolve(file_path);
     const home = os.homedir();
     const cwd = process.cwd();
-    if (!resolvedPath.startsWith(home) && !resolvedPath.startsWith(cwd) && !resolvedPath.startsWith('/tmp')) {
+    const tmpDir = os.tmpdir();
+    if (!resolvedPath.startsWith(home) && !resolvedPath.startsWith(cwd) && !resolvedPath.startsWith('/tmp') && !resolvedPath.startsWith(tmpDir)) {
         return {
             content: [{ type: "text", text: "Error: file_path must be within your home directory, project directory, or /tmp." }],
             isError: true,

package/dist/tools/skillRouting.js

@@ -0,0 +1,86 @@
+/**
+ * Skill routing client — fetches the canonical routing table from synalux.
+ *
+ * Single source of truth lives in synalux at /api/v1/skills/routing.
+ * This module:
+ *   1. Caches the response in-memory for 5 minutes (matches synalux's
+ *      Cache-Control s-maxage).
+ *   2. Falls back to a tiny offline default if synalux is unreachable, so
+ *      free-tier / disconnected installations still get the BCBA universal
+ *      skill loaded.
+ *
+ * To change the routing for production, edit
+ *   synalux-private/portal/src/app/api/v1/skills/routing/route.ts
+ * and deploy synalux. prism-mcp picks up the new config within 5 minutes.
+ *
+ * Do NOT add hardcoded skill names here outside the OFFLINE_FALLBACK block
+ * — that defeats the single-source-of-truth design.
+ */
+// Minimal fallback when synalux is unreachable. Only the universal BCBA
+// skill — project-specific mappings need synalux to resolve.
+const OFFLINE_FALLBACK = {
+    version: 1,
+    universal: ['bcba_ai_assistant'],
+    projects: {},
+};
+const SYNALUX_BASE = process.env.SYNALUX_BASE_URL || 'https://synalux.ai';
+const CACHE_TTL_MS = 5 * 60 * 1000;
+let cached = null;
+let inflight = null;
+async function fetchOnce() {
+    try {
+        const res = await fetch(`${SYNALUX_BASE}/api/v1/skills/routing`, {
+            headers: { Accept: 'application/json' },
+            // Routing is on every session_load_context, must not block long.
+            signal: AbortSignal.timeout(2_500),
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const body = (await res.json());
+        if (typeof body !== 'object' ||
+            body == null ||
+            typeof body.version !== 'number' ||
+            !Array.isArray(body.universal) ||
+            typeof body.projects !== 'object') {
+            throw new Error('malformed routing table');
+        }
+        return body;
+    }
+    catch {
+        return OFFLINE_FALLBACK;
+    }
+}
+/**
+ * Resolve the skill list for a given project (case-insensitive substring
+ * match against the routing table). Always returns at least the universal
+ * skills.
+ */
+export async function resolveSkillsForProject(project) {
+    const now = Date.now();
+    if (!cached || now - cached.fetchedAt > CACHE_TTL_MS) {
+        if (!inflight) {
+            inflight = fetchOnce().then((table) => {
+                cached = { table, fetchedAt: Date.now() };
+                return table;
+            }).finally(() => { inflight = null; });
+        }
+        await inflight;
+    }
+    const table = cached.table;
+    const out = new Set(table.universal);
+    const projectLower = project.toLowerCase();
+    for (const [pattern, skills] of Object.entries(table.projects)) {
+        if (projectLower.includes(pattern)) {
+            for (const s of skills)
+                out.add(s);
+        }
+    }
+    return Array.from(out);
+}
+/** Force a re-fetch on the next call. Exposed for tests + admin tooling. */
+export function _invalidateRoutingCache() {
+    cached = null;
+    inflight = null;
+}
+/** Test/debug only — read the OFFLINE_FALLBACK constant. */
+export const _OFFLINE_FALLBACK = OFFLINE_FALLBACK;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "12.5.7",
+  "version": "13.0.0",
   "mcpName": "io.github.dcostenco/prism-coder",
   "description": "Prism-Coder v12.5: The world's first O(1) Cognitive Memory Architecture for AI Agents. 100% Tool-Call Accuracy (BFCL Gold Certified), 54 Agent Skills, Zero-Search Retrieval (HDC/HRR), HIPAA-hardened local-first storage, and SLERP-optimized GRPO alignment.",
   "module": "index.ts",