prism-mcp-server 20.0.7 → 20.0.8

package/dist/scm/ciPipeline.js

@@ -1,220 +0,0 @@
-/**
- * v12.4: GitHub Actions CI/CD Pipeline Generator
- *
- * Generates GitHub Actions YAML workflows from Prism project configuration.
- * Supports test suite integration, automated deployments, and custom triggers.
- */
-import { debugLog } from "../utils/logger.js";
-// ─── Preset Templates ───────────────────────────────────────
-const PRESETS = {
-    "node-test": {
-        project: "",
-        triggers: [
-            { type: "push", branches: ["main"] },
-            { type: "pull_request", branches: ["main"] },
-        ],
-        jobs: [
-            {
-                name: "test",
-                runsOn: "ubuntu-latest",
-                steps: [
-                    { name: "Checkout", uses: "actions/checkout@v4" },
-                    { name: "Setup Node", uses: "actions/setup-node@v4", with: { "node-version": "20" } },
-                    { name: "Install", run: "npm ci" },
-                    { name: "Lint", run: "npm run lint --if-present" },
-                    { name: "Type Check", run: "npx tsc --noEmit" },
-                    { name: "Test", run: "npm test --if-present" },
-                ],
-            },
-        ],
-    },
-    "npm-publish": {
-        project: "",
-        triggers: [
-            { type: "release", tags: ["v*"] },
-        ],
-        jobs: [
-            {
-                name: "publish",
-                runsOn: "ubuntu-latest",
-                steps: [
-                    { name: "Checkout", uses: "actions/checkout@v4" },
-                    { name: "Setup Node", uses: "actions/setup-node@v4", with: { "node-version": "20", "registry-url": "https://registry.npmjs.org" } },
-                    { name: "Install", run: "npm ci" },
-                    { name: "Build", run: "npm run build" },
-                    { name: "Publish", run: "npm publish", env: { NODE_AUTH_TOKEN: "${{ secrets.NPM_TOKEN }}" } },
-                ],
-            },
-        ],
-    },
-    "python-test": {
-        project: "",
-        triggers: [
-            { type: "push", branches: ["main"] },
-            { type: "pull_request", branches: ["main"] },
-        ],
-        jobs: [
-            {
-                name: "test",
-                runsOn: "ubuntu-latest",
-                steps: [
-                    { name: "Checkout", uses: "actions/checkout@v4" },
-                    { name: "Setup Python", uses: "actions/setup-python@v5", with: { "python-version": "3.12" } },
-                    { name: "Install", run: "pip install -e '.[dev]'" },
-                    { name: "Lint", run: "ruff check ." },
-                    { name: "Test", run: "pytest -v" },
-                ],
-            },
-        ],
-    },
-};
-// ─── YAML Generator ──────────────────────────────────────────
-function indent(level) {
-    return "  ".repeat(level);
-}
-function renderTriggers(triggers) {
-    const lines = ["on:"];
-    for (const trigger of triggers) {
-        switch (trigger.type) {
-            case "push":
-                lines.push(`${indent(1)}push:`);
-                if (trigger.branches?.length) {
-                    lines.push(`${indent(2)}branches: [${trigger.branches.map(b => `"${b}"`).join(", ")}]`);
-                }
-                if (trigger.paths?.length) {
-                    lines.push(`${indent(2)}paths:`);
-                    for (const p of trigger.paths)
-                        lines.push(`${indent(3)}- "${p}"`);
-                }
-                break;
-            case "pull_request":
-                lines.push(`${indent(1)}pull_request:`);
-                if (trigger.branches?.length) {
-                    lines.push(`${indent(2)}branches: [${trigger.branches.map(b => `"${b}"`).join(", ")}]`);
-                }
-                break;
-            case "schedule":
-                lines.push(`${indent(1)}schedule:`);
-                lines.push(`${indent(2)}- cron: "${trigger.cron || "0 0 * * *"}"`);
-                break;
-            case "workflow_dispatch":
-                lines.push(`${indent(1)}workflow_dispatch:`);
-                break;
-            case "release":
-                lines.push(`${indent(1)}release:`);
-                lines.push(`${indent(2)}types: [published]`);
-                break;
-        }
-    }
-    return lines.join("\n");
-}
-function renderStep(step, level) {
-    const lines = [];
-    lines.push(`${indent(level)}- name: "${step.name}"`);
-    if (step.condition) {
-        lines.push(`${indent(level + 1)}if: ${step.condition}`);
-    }
-    if (step.uses) {
-        lines.push(`${indent(level + 1)}uses: ${step.uses}`);
-    }
-    if (step.run) {
-        if (step.run.includes("\n")) {
-            lines.push(`${indent(level + 1)}run: |`);
-            for (const line of step.run.split("\n")) {
-                lines.push(`${indent(level + 2)}${line}`);
-            }
-        }
-        else {
-            lines.push(`${indent(level + 1)}run: ${step.run}`);
-        }
-    }
-    if (step.with && Object.keys(step.with).length > 0) {
-        lines.push(`${indent(level + 1)}with:`);
-        for (const [k, v] of Object.entries(step.with)) {
-            lines.push(`${indent(level + 2)}${k}: "${v}"`);
-        }
-    }
-    if (step.env && Object.keys(step.env).length > 0) {
-        lines.push(`${indent(level + 1)}env:`);
-        for (const [k, v] of Object.entries(step.env)) {
-            lines.push(`${indent(level + 2)}${k}: ${v}`);
-        }
-    }
-    return lines.join("\n");
-}
-/**
- * Generate a GitHub Actions YAML workflow from a pipeline config.
- */
-export function generateWorkflow(config) {
-    const lines = [];
-    lines.push(`name: ${config.project || "CI"}`);
-    lines.push("");
-    lines.push(renderTriggers(config.triggers));
-    lines.push("");
-    if (config.env && Object.keys(config.env).length > 0) {
-        lines.push("env:");
-        for (const [k, v] of Object.entries(config.env)) {
-            lines.push(`${indent(1)}${k}: "${v}"`);
-        }
-        lines.push("");
-    }
-    if (config.concurrency) {
-        lines.push("concurrency:");
-        lines.push(`${indent(1)}group: ${config.concurrency.group}`);
-        lines.push(`${indent(1)}cancel-in-progress: ${config.concurrency.cancelInProgress}`);
-        lines.push("");
-    }
-    lines.push("jobs:");
-    for (const job of config.jobs) {
-        lines.push(`${indent(1)}${job.name.replace(/\s+/g, "-").toLowerCase()}:`);
-        lines.push(`${indent(2)}runs-on: ${job.runsOn}`);
-        if (job.timeout) {
-            lines.push(`${indent(2)}timeout-minutes: ${job.timeout}`);
-        }
-        if (job.needs?.length) {
-            lines.push(`${indent(2)}needs: [${job.needs.join(", ")}]`);
-        }
-        if (job.condition) {
-            lines.push(`${indent(2)}if: ${job.condition}`);
-        }
-        if (job.env && Object.keys(job.env).length > 0) {
-            lines.push(`${indent(2)}env:`);
-            for (const [k, v] of Object.entries(job.env)) {
-                lines.push(`${indent(3)}${k}: "${v}"`);
-            }
-        }
-        lines.push(`${indent(2)}steps:`);
-        for (const step of job.steps) {
-            lines.push(renderStep(step, 3));
-        }
-        lines.push("");
-    }
-    const yaml = lines.join("\n");
-    return {
-        filename: `.github/workflows/${config.project || "ci"}.yml`,
-        yaml,
-        description: `CI/CD workflow for ${config.project || "project"}`,
-    };
-}
-/**
- * Generate a workflow from a preset template.
- */
-export function generateFromPreset(preset, project) {
-    const config = PRESETS[preset];
-    if (!config) {
-        debugLog(`CI Pipeline: Unknown preset '${preset}'. Available: ${Object.keys(PRESETS).join(", ")}`);
-        return null;
-    }
-    return generateWorkflow({ ...config, project });
-}
-/**
- * List available preset templates.
- */
-export function listPresets() {
-    return [
-        { name: "node-test", description: "Node.js CI: lint, type-check, test" },
-        { name: "npm-publish", description: "npm publish on release tag" },
-        { name: "python-test", description: "Python CI: ruff lint, pytest" },
-    ];
-}
-debugLog("v12.4: CI pipeline generator loaded");

package/dist/sync/encryptedSync.js

@@ -1,172 +0,0 @@
-/**
- * v12.3: Encrypted Peer-to-Peer Session Syncing
- *
- * AES-256-GCM encryption for session data transmission between
- * Prism instances. Supports both stdio pipe and WebSocket transports.
- *
- * Architecture:
- *   1. Generate per-sync ephemeral key (ECDH key exchange)
- *   2. Encrypt session payloads with AES-256-GCM
- *   3. Transfer via stdio pipe (local) or WebSocket (remote)
- *   4. Verify integrity with HMAC-SHA256
- */
-import { debugLog } from "../utils/logger.js";
-import crypto from "node:crypto";
-const { createHash, randomBytes, createCipheriv, createDecipheriv } = crypto;
-// ─── Encryption / Decryption ─────────────────────────────────
-const ALGORITHM = "aes-256-gcm";
-const IV_LENGTH = 12;
-const KEY_LENGTH = 32;
-/**
- * Derive a symmetric key from a shared secret using SHA-256.
- */
-export function deriveKey(sharedSecret) {
-    return createHash("sha256").update(sharedSecret).digest();
-}
-/**
- * Generate a random encryption key.
- */
-export function generateKey() {
-    return randomBytes(KEY_LENGTH);
-}
-/**
- * Encrypt a payload with AES-256-GCM.
- */
-export function encrypt(plaintext, key) {
-    const iv = randomBytes(IV_LENGTH);
-    const cipher = createCipheriv(ALGORITHM, key, iv);
-    let encrypted = cipher.update(plaintext, "utf8", "hex");
-    encrypted += cipher.final("hex");
-    return {
-        iv: iv.toString("hex"),
-        data: encrypted,
-        tag: cipher.getAuthTag().toString("hex"),
-        algorithm: ALGORITHM,
-    };
-}
-/**
- * Decrypt an AES-256-GCM encrypted packet.
- */
-export function decrypt(packet, key) {
-    const decipher = createDecipheriv(ALGORITHM, key, Buffer.from(packet.iv, "hex"));
-    decipher.setAuthTag(Buffer.from(packet.tag, "hex"));
-    let decrypted = decipher.update(packet.data, "hex", "utf8");
-    decrypted += decipher.final("utf8");
-    return decrypted;
-}
-// ─── Sync Payload Construction ───────────────────────────────
-/**
- * Create a checksum for a sync payload (integrity verification).
- */
-export function computeChecksum(entries) {
-    const hash = createHash("sha256");
-    for (const entry of entries) {
-        hash.update(entry.id);
-        hash.update(entry.data);
-    }
-    return hash.digest("hex");
-}
-/**
- * Build a sync payload from session entries.
- */
-export function buildSyncPayload(sourceId, targetId, entries) {
-    return {
-        version: 1,
-        sourceId,
-        targetId,
-        timestamp: new Date().toISOString(),
-        entries,
-        checksum: computeChecksum(entries),
-    };
-}
-/**
- * Verify a received sync payload's integrity.
- */
-export function verifySyncPayload(payload) {
-    const computed = computeChecksum(payload.entries);
-    if (computed.length !== payload.checksum.length)
-        return false;
-    return crypto.timingSafeEqual(Buffer.from(computed), Buffer.from(payload.checksum));
-}
-// ─── Peer Management ─────────────────────────────────────────
-const peers = new Map();
-export function registerPeer(peer) {
-    peers.set(peer.id, peer);
-    debugLog(`Sync: Registered peer '${peer.name}' (${peer.transport})`);
-}
-export function removePeer(peerId) {
-    return peers.delete(peerId);
-}
-export function listPeers() {
-    return Array.from(peers.values());
-}
-export function getPeer(peerId) {
-    return peers.get(peerId);
-}
-// ─── Sync Execution ──────────────────────────────────────────
-/**
- * Execute an encrypted sync with a peer.
- * In this implementation, we prepare the encrypted payload — the actual
- * transport (stdio/WebSocket) is pluggable.
- */
-export async function prepareSyncPacket(sourceId, targetPeerId, entries, sharedSecret) {
-    const payload = buildSyncPayload(sourceId, targetPeerId, entries);
-    const key = deriveKey(sharedSecret);
-    const encrypted = encrypt(JSON.stringify(payload), key);
-    debugLog(`Sync: Prepared encrypted packet with ${entries.length} entries for peer '${targetPeerId}'`);
-    return {
-        encrypted,
-        metadata: {
-            entryCount: entries.length,
-            checksum: payload.checksum,
-        },
-    };
-}
-/**
- * Receive and decrypt a sync packet.
- */
-export function receiveSyncPacket(encrypted, sharedSecret) {
-    const key = deriveKey(sharedSecret);
-    const decrypted = decrypt(encrypted, key);
-    // 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");
-    }
-    debugLog(`Sync: Received and verified packet with ${payload.entries.length} entries from '${payload.sourceId}'`);
-    return payload;
-}
-/**
- * Resolve conflicts between local and remote entries (last-writer-wins).
- */
-export function resolveConflicts(local, remote) {
-    const localMap = new Map(local.map(e => [e.id, e]));
-    let conflictsResolved = 0;
-    for (const remoteEntry of remote) {
-        const localEntry = localMap.get(remoteEntry.id);
-        if (localEntry) {
-            // Last-writer-wins
-            if (new Date(remoteEntry.createdAt) > new Date(localEntry.createdAt)) {
-                localMap.set(remoteEntry.id, remoteEntry);
-                conflictsResolved++;
-            }
-        }
-        else {
-            localMap.set(remoteEntry.id, remoteEntry);
-        }
-    }
-    return {
-        merged: Array.from(localMap.values()),
-        conflictsResolved,
-    };
-}
-debugLog("v12.3: Encrypted sync module loaded");

package/dist/sync/synaluxProxy.js

@@ -1,177 +0,0 @@
-/**
- * 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");