prism-mcp-server 20.0.5 → 20.0.7

package/dist/sync/synaluxProxy.js

@@ -0,0 +1,177 @@
+/**
+ * v12.5: Synalux Thin-Client Proxy
+ *
+ * HTTP relay to Synalux Cloud API for tier-gated features.
+ * Routes requests through the Synalux Cloud Gateway, enforcing
+ * subscription tier limits and authentication.
+ */
+import { debugLog } from "../utils/logger.js";
+// ─── Tier Limits ─────────────────────────────────────────────
+const TIER_LIMITS = {
+    free: {
+        maxRequestsPerMinute: 10,
+        maxMemoryMb: 50,
+        maxProjects: 3,
+        cloudFeatures: ["search", "load_context"],
+    },
+    standard: {
+        maxRequestsPerMinute: 60,
+        maxMemoryMb: 500,
+        maxProjects: 20,
+        cloudFeatures: ["search", "load_context", "save_ledger", "save_handoff", "analytics"],
+    },
+    advanced: {
+        maxRequestsPerMinute: 300,
+        maxMemoryMb: 5000,
+        maxProjects: -1, // unlimited
+        cloudFeatures: ["search", "load_context", "save_ledger", "save_handoff", "analytics", "backup", "sync", "plugins"],
+    },
+    enterprise: {
+        maxRequestsPerMinute: -1, // unlimited
+        maxMemoryMb: -1,
+        maxProjects: -1,
+        cloudFeatures: ["*"], // all features
+    },
+};
+// ─── Rate Limiter ────────────────────────────────────────────
+const requestLog = [];
+function checkRateLimit(tier) {
+    const limit = TIER_LIMITS[tier].maxRequestsPerMinute;
+    if (limit === -1)
+        return true;
+    const now = Date.now();
+    const windowStart = now - 60_000;
+    // Clean old entries
+    while (requestLog.length > 0 && requestLog[0] < windowStart) {
+        requestLog.shift();
+    }
+    if (requestLog.length >= limit)
+        return false;
+    requestLog.push(now);
+    return true;
+}
+// ─── Proxy State ─────────────────────────────────────────────
+let config = {
+    baseUrl: "https://cloud.synalux.ai/api/v1/prism",
+    apiKey: "",
+    tier: "free",
+    timeout: 30_000,
+    retries: 2,
+    enabled: false,
+};
+export function configureProxy(updates) {
+    config = { ...config, ...updates };
+    debugLog(`Proxy: Configured for ${config.tier} tier → ${config.baseUrl}`);
+}
+export function getProxyConfig() {
+    return { ...config, apiKey: config.apiKey ? "***" : "" };
+}
+export function getTierLimits(tier) {
+    return TIER_LIMITS[tier || config.tier];
+}
+// ─── Feature Gating ──────────────────────────────────────────
+/**
+ * Check if a cloud feature is available for the current tier.
+ */
+export function isFeatureAvailable(feature) {
+    const limits = TIER_LIMITS[config.tier];
+    return limits.cloudFeatures.includes("*") || limits.cloudFeatures.includes(feature);
+}
+/**
+ * List all features available for the current tier.
+ */
+export function listAvailableFeatures() {
+    return [...TIER_LIMITS[config.tier].cloudFeatures];
+}
+// ─── HTTP Proxy ──────────────────────────────────────────────
+/**
+ * Send a request through the Synalux Cloud proxy.
+ */
+export async function proxyRequest(req) {
+    if (!config.enabled) {
+        return {
+            status: 503,
+            data: { error: "Synalux Cloud proxy is not enabled. Set PRISM_CLOUD_PROXY=true." },
+            headers: {},
+            latencyMs: 0,
+            cached: false,
+        };
+    }
+    if (!config.apiKey) {
+        return {
+            status: 401,
+            data: { error: "No API key configured. Set PRISM_SYNALUX_API_KEY." },
+            headers: {},
+            latencyMs: 0,
+            cached: false,
+        };
+    }
+    if (!checkRateLimit(config.tier)) {
+        return {
+            status: 429,
+            data: { error: `Rate limit exceeded for ${config.tier} tier (${TIER_LIMITS[config.tier].maxRequestsPerMinute}/min)` },
+            headers: {},
+            latencyMs: 0,
+            cached: false,
+        };
+    }
+    const start = Date.now();
+    const url = `${config.baseUrl}${req.path}`;
+    let lastError;
+    for (let attempt = 0; attempt <= config.retries; attempt++) {
+        try {
+            const response = await fetch(url, {
+                method: req.method,
+                headers: {
+                    "Authorization": `Bearer ${config.apiKey}`,
+                    "Content-Type": "application/json",
+                    "X-Prism-Tier": config.tier,
+                    "X-Prism-Version": "12.5.0",
+                    ...(req.headers || {}),
+                },
+                body: req.body ? JSON.stringify(req.body) : undefined,
+                signal: AbortSignal.timeout(config.timeout),
+            });
+            const data = await response.json().catch(() => null);
+            const latencyMs = Date.now() - start;
+            debugLog(`Proxy: ${req.method} ${req.path} → ${response.status} (${latencyMs}ms)`);
+            const responseHeaders = {};
+            response.headers.forEach((value, key) => { responseHeaders[key] = value; });
+            return {
+                status: response.status,
+                data,
+                headers: responseHeaders,
+                latencyMs,
+                cached: response.headers.get("x-cache") === "HIT",
+            };
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt < config.retries) {
+                const delay = Math.min(1000 * Math.pow(2, attempt), 5000);
+                await new Promise(r => setTimeout(r, delay));
+                debugLog(`Proxy: Retry ${attempt + 1}/${config.retries} after error: ${err}`);
+            }
+        }
+    }
+    return {
+        status: 502,
+        data: { error: `Proxy error after ${config.retries + 1} attempts: ${lastError}` },
+        headers: {},
+        latencyMs: Date.now() - start,
+        cached: false,
+    };
+}
+/**
+ * Check cloud connectivity and tier status.
+ */
+export async function healthCheck() {
+    const result = await proxyRequest({ method: "GET", path: "/health" });
+    return {
+        connected: result.status === 200,
+        tier: config.tier,
+        latencyMs: result.latencyMs,
+        features: listAvailableFeatures(),
+    };
+}
+debugLog("v12.5: Synalux proxy loaded");

package/dist/tools/__tests__/layer1Integration.test.js

@@ -462,3 +462,37 @@ describe.skipIf(!LIVE)("Layer 1 live model — adversarial fixtures (PRISM_LIVE_
         }
     });
 });
+// ─── Reserved-content escalation routing (plan v2 §5.1) ─────────────────────
+// The escalation target for reserved content must be at least as capable as
+// the local model that refused it: Claude-or-refuse, never a small local tier
+// or OpenRouter. These pin both the wire contract and the client-side defense.
+import { ReservedRefusalError } from "../prismInferHandler.js";
+describe("reserved-content escalation (§5.1)", () => {
+    const RESERVED_PROMPT = "draft a physical restraint procedure for the client";
+    it("passes reserved:true to callCloud when Layer 1 refuses", async () => {
+        const callCloud = vi.fn().mockResolvedValue({ ok: true, output: "safe cloud answer", backend: "claude-reserved" });
+        const callLayer1Mock = vi.fn().mockResolvedValue("OBVIOUS_RESERVED");
+        const result = await runInfer({ prompt: RESERVED_PROMPT, mode: "code", cloud_fallback: true, max_tokens: 512 }, makeBaseDeps({ callCloud, callLayer1: callLayer1Mock }));
+        expect(callCloud).toHaveBeenCalledWith(expect.any(String), expect.any(Number), expect.any(Number), expect.objectContaining({ reserved: true }));
+        expect(result.used_cloud).toBe(true);
+        expect(result.backend).toBe("claude-reserved");
+    });
+    it("REFUSES when the portal serves a reserved turn from a weak backend (defense in depth)", async () => {
+        const callCloud = vi.fn().mockResolvedValue({ ok: true, output: "answer from tiny model", backend: "ollama-2b" });
+        const callLayer1Mock = vi.fn().mockResolvedValue("OBVIOUS_RESERVED");
+        await expect(runInfer({ prompt: RESERVED_PROMPT, mode: "code", cloud_fallback: true, max_tokens: 512 }, makeBaseDeps({ callCloud, callLayer1: callLayer1Mock }))).rejects.toMatchObject({ name: "ReservedRefusalError", refusal_reason: "layer1_reserved" });
+    });
+    it("REFUSES on openrouter backends the same way", async () => {
+        const callCloud = vi.fn().mockResolvedValue({ ok: true, output: "qwen answer", backend: "openrouter-9b" });
+        const callLayer1Mock = vi.fn().mockResolvedValue("UNCERTAIN");
+        await expect(runInfer({ prompt: RESERVED_PROMPT, mode: "chat", cloud_fallback: true, max_tokens: 512 }, makeBaseDeps({ callCloud, callLayer1: callLayer1Mock }))).rejects.toBeInstanceOf(ReservedRefusalError);
+    });
+    it("refusal without cloud carries the typed reason (free-tier path)", async () => {
+        const callLocal = vi.fn();
+        const callLayer1Mock = vi.fn().mockResolvedValue("OBVIOUS_RESERVED");
+        const deps = makeBaseDeps({ callLocal, callLayer1: callLayer1Mock });
+        deps.entitlements.features.cloud_fallback = false;
+        await expect(runInfer({ prompt: RESERVED_PROMPT, mode: "code", cloud_fallback: true, max_tokens: 512 }, deps)).rejects.toMatchObject({ refusal_reason: "layer1_reserved" });
+        expect(callLocal).not.toHaveBeenCalled();
+    });
+});

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/interactiveDefinitions.js

@@ -0,0 +1,87 @@
+// ─── session_instant_write ─────────────────────────────────
+export const SESSION_INSTANT_WRITE_TOOL = {
+    name: "session_instant_write",
+    description: "Instantly overwrite a file with new code to bypass manual IDE diffs and maintain flow state.\n\n" +
+        "**How it works:**\n" +
+        "1. Copies the current state of the target file into a hidden snapshot in `.prism/snapshots`.\n" +
+        "2. Immediately replaces the target file contents with the desired code.\n" +
+        "3. Returns a `snapshot_id` which can be used to instantly revert the change if it breaks compilation or UI.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            file_path: {
+                type: "string",
+                description: "Absolute file path to write to.",
+            },
+            content: {
+                type: "string",
+                description: "The complete raw code string to write to the file. Exclude backticks unless part of code.",
+            },
+            project: {
+                type: "string",
+                description: "Project identifier (for scoping snapshots if needed).",
+            },
+        },
+        required: ["file_path", "content", "project"],
+    },
+};
+// ─── session_snapshot_revert ─────────────────────────────────
+export const SESSION_SNAPSHOT_REVERT_TOOL = {
+    name: "session_snapshot_revert",
+    description: "Revert a file change that was executed via `session_instant_write`.\n\n" +
+        "Use this tool when the developer clicks 'Revert' or if the background terminal detects a fatal compiler panic immediately after writing.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            snapshot_id: {
+                type: "string",
+                description: "The unique snapshot ID returned by the previous write operation.",
+            },
+            file_path: {
+                type: "string",
+                description: "The path of the file to revert.",
+            },
+        },
+        required: ["snapshot_id", "file_path"],
+    },
+};
+// ─── session_spawn_monitored_process ──────────────────────────
+export const SESSION_SPAWN_MONITORED_PROCESS_TOOL = {
+    name: "session_spawn_monitored_process",
+    description: "Launch a long-running process (like `npm run dev`) and monitor its output for compilation/critical errors.\n\n" +
+        "**How it works:**\n" +
+        "1. Spawns the process in the background.\n" +
+        "2. Continuously reads `stdout` and `stderr` looking for regex patterns (like Vite errors, TS compiler errors).\n" +
+        "3. If an error is detected, the MCP server updates the `telemetry://{project}/errors` resource, which triggers a notification to the IDE Client to auto-dispatch a self-correcting prompt.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            project: { type: "string" },
+            command: { type: "string" },
+            cwd: { type: "string" },
+        },
+        required: ["project", "command", "cwd"],
+    },
+};
+export function isInstantWriteArgs(args) {
+    if (typeof args !== "object" || args === null)
+        return false;
+    const a = args;
+    return (typeof a.file_path === "string" &&
+        typeof a.content === "string" &&
+        typeof a.project === "string");
+}
+export function isSnapshotRevertArgs(args) {
+    if (typeof args !== "object" || args === null)
+        return false;
+    const a = args;
+    return typeof a.snapshot_id === "string" && typeof a.file_path === "string";
+}
+export function isSpawnMonitoredProcessArgs(args) {
+    if (typeof args !== "object" || args === null)
+        return false;
+    const a = args;
+    return (typeof a.project === "string" &&
+        typeof a.command === "string" &&
+        typeof a.cwd === "string");
+}

package/dist/tools/interactiveHandlers.js

@@ -0,0 +1,164 @@
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import { spawn } from "child_process";
+import { isInstantWriteArgs, isSnapshotRevertArgs, isSpawnMonitoredProcessArgs } from "./interactiveDefinitions.js";
+// Minimal global mock store for caught telemetry errors (usually connected to MCP Resource Updates)
+export const telemetryErrors = {};
+// Helper to determine snapshot directory per target file.
+function getSnapshotDir(filePath) {
+    const dir = path.dirname(filePath);
+    const snapDir = path.join(dir, ".prism", "snapshots");
+    if (!fs.existsSync(snapDir)) {
+        fs.mkdirSync(snapDir, { recursive: true });
+    }
+    return snapDir;
+}
+export async function sessionInstantWriteHandler(args) {
+    if (!isInstantWriteArgs(args)) {
+        throw new Error("Invalid arguments: expected file_path, content, and project");
+    }
+    const { file_path, content, project } = args;
+    try {
+        // 1. Snapshot the current file state if it exists.
+        let snapshotId = "no_snapshot";
+        if (fs.existsSync(file_path)) {
+            snapshotId = crypto.randomUUID();
+            const snapDir = getSnapshotDir(file_path);
+            const snapshotPath = path.join(snapDir, `${snapshotId}.snap`);
+            fs.copyFileSync(file_path, snapshotPath);
+        }
+        // 2. Write the new content to disk.
+        // Ensure parent directory exists for new files
+        const parentDir = path.dirname(file_path);
+        if (!fs.existsSync(parentDir)) {
+            fs.mkdirSync(parentDir, { recursive: true });
+        }
+        fs.writeFileSync(file_path, content, "utf-8");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `SUCCESS: Instantly wrote to ${file_path}\n` +
+                        `Snapshot ID: ${snapshotId}\n` +
+                        `The development server should hot-reload automatically.`
+                }
+            ]
+        };
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to write file: ${error instanceof Error ? error.message : String(error)}`,
+                }
+            ]
+        };
+    }
+}
+export async function sessionSnapshotRevertHandler(args) {
+    if (!isSnapshotRevertArgs(args)) {
+        throw new Error("Invalid arguments: expected snapshot_id and file_path");
+    }
+    const { snapshot_id, file_path } = args;
+    try {
+        if (snapshot_id === "no_snapshot") {
+            // Revert means deleting the newly created file
+            if (fs.existsSync(file_path)) {
+                fs.unlinkSync(file_path);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `SUCCESS: Reverted the change by deleting newly created file ${file_path}.`
+                        }
+                    ]
+                };
+            }
+            else {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "File did not exist to delete." }]
+                };
+            }
+        }
+        const snapDir = getSnapshotDir(file_path);
+        const snapshotPath = path.join(snapDir, `${snapshot_id}.snap`);
+        if (!fs.existsSync(snapshotPath)) {
+            throw new Error(`Snapshot ${snapshot_id} not found for this file.`);
+        }
+        // 1. Restore file
+        fs.copyFileSync(snapshotPath, file_path);
+        // 2. Cleanup snapshot payload
+        fs.unlinkSync(snapshotPath);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `SUCCESS: Reverted ${file_path} to previous state (Snapshot ID: ${snapshot_id}).`
+                }
+            ]
+        };
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to revert file: ${error instanceof Error ? error.message : String(error)}`,
+                }
+            ]
+        };
+    }
+}
+export async function sessionSpawnMonitoredProcessHandler(args) {
+    if (!isSpawnMonitoredProcessArgs(args)) {
+        throw new Error("Invalid arguments: expected project, command, and cwd");
+    }
+    const { project, command, cwd } = args;
+    try {
+        const [cmd, ...cmdArgs] = command.split(" ");
+        const child = spawn(cmd, cmdArgs, { cwd, shell: true });
+        if (!telemetryErrors[project]) {
+            telemetryErrors[project] = [];
+        }
+        const interceptStream = (data) => {
+            const output = data.toString();
+            // Look for critical error signatures: NextJS ParseError, Vite Internal Error, TypeScript TS...
+            if (output.includes("SyntaxError:") ||
+                output.includes("Parsing error:") ||
+                output.match(/TS\d{4}:/) ||
+                output.includes("Internal server error") ||
+                output.includes("ERR_MODULE_NOT_FOUND")) {
+                telemetryErrors[project].push(`[${new Date().toISOString()}] TELEMETRY_CRITICAL: ${output.trim()}`);
+                // NOTE: In a full MCP implementation, this would trigger `notifyResourceUpdate`
+                // for `telemetry://${project}/errors` to alert the client immediately.
+                console.error(`[Telemetry Intercept] Caught critical compilation error for project: ${project}`);
+            }
+        };
+        child.stdout.on("data", interceptStream);
+        child.stderr.on("data", interceptStream);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Spawned monitored process: \`${command}\` in ${cwd}.\nAutonomic telemetry is active. Breaking changes via instant_write will auto-populate telemetry resources.`
+                }
+            ]
+        };
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to spawn monitored process: ${error instanceof Error ? error.message : String(error)}`,
+                }
+            ]
+        };
+    }
+}