prism-mcp-server 20.0.6 → 20.0.7

package/dist/auth.js

@@ -0,0 +1,218 @@
+/**
+ * Prism Cloud — Authentication Module (v2.0)
+ * =============================================
+ *
+ * Handles OAuth login flow for Prism CLI:
+ *   1. `prism login` → starts local HTTP server on random port
+ *   2. Opens browser → Synalux OAuth page with redirect back to localhost
+ *   3. Receives auth code → exchanges for JWT + refresh token
+ *   4. Stores tokens in prism-config.db via configStorage
+ *
+ * Token management:
+ *   - Auto-refresh expired JWTs using stored refresh token
+ *   - `prism logout` → clears stored tokens
+ *   - `prism status` → shows current auth state
+ */
+import { createServer } from 'http';
+import { URL } from 'url';
+import { setSetting, getSetting } from './storage/configStorage.js';
+import { clearCloudCache } from './prism-cloud.js';
+// ─── Config ───────────────────────────────────────────────────────
+const SYNALUX_BASE = process.env.SYNALUX_API_BASE || 'https://synalux.ai';
+const AUTH_CALLBACK_PATH = '/auth/callback';
+// Config keys in prism-config.db
+const KEY_AUTH_TOKEN = 'prism_auth_token';
+const KEY_REFRESH_TOKEN = 'prism_refresh_token';
+const KEY_AUTH_EMAIL = 'prism_auth_email';
+const KEY_AUTH_NAME = 'prism_auth_name';
+const KEY_AUTH_PLAN = 'prism_auth_plan';
+const KEY_AUTH_EXPIRES = 'prism_auth_expires';
+/**
+ * Start the OAuth login flow.
+ * Opens default browser to Synalux login page, waits for callback.
+ */
+export async function login() {
+    return new Promise((resolve) => {
+        // Start local server on random port
+        const server = createServer(async (req, res) => {
+            const url = new URL(req.url || '/', `http://localhost`);
+            if (url.pathname !== AUTH_CALLBACK_PATH) {
+                res.writeHead(404);
+                res.end('Not found');
+                return;
+            }
+            const code = url.searchParams.get('code');
+            const error = url.searchParams.get('error');
+            if (error) {
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(renderHtml('Login Failed', `Error: ${error}. You can close this window.`));
+                server.close();
+                resolve({ success: false, error });
+                return;
+            }
+            if (!code) {
+                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.end(renderHtml('Login Failed', 'No authorization code received. You can close this window.'));
+                server.close();
+                resolve({ success: false, error: 'No authorization code' });
+                return;
+            }
+            try {
+                // Exchange code for JWT
+                const tokenResult = await exchangeCode(code);
+                // Store tokens
+                await setSetting(KEY_AUTH_TOKEN, tokenResult.access_token);
+                if (tokenResult.refresh_token) {
+                    await setSetting(KEY_REFRESH_TOKEN, tokenResult.refresh_token);
+                }
+                if (tokenResult.email) {
+                    await setSetting(KEY_AUTH_EMAIL, tokenResult.email);
+                }
+                if (tokenResult.plan) {
+                    await setSetting(KEY_AUTH_PLAN, tokenResult.plan);
+                }
+                if (tokenResult.expires_at) {
+                    await setSetting(KEY_AUTH_EXPIRES, String(tokenResult.expires_at));
+                }
+                // Clear cached cloud limits so next verify call uses new token
+                clearCloudCache();
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(renderHtml('✅ Prism Login Successful', `Authenticated as <strong>${tokenResult.email}</strong> (${tokenResult.plan} plan). You can close this window.`));
+                server.close();
+                resolve({
+                    success: true,
+                    email: tokenResult.email,
+                    plan: tokenResult.plan,
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(renderHtml('Login Failed', `Error: ${message}. You can close this window.`));
+                server.close();
+                resolve({ success: false, error: message });
+            }
+        });
+        server.listen(0, '127.0.0.1', () => {
+            const addr = server.address();
+            if (!addr || typeof addr === 'string') {
+                resolve({ success: false, error: 'Failed to start local server' });
+                return;
+            }
+            const port = addr.port;
+            const callbackUrl = `http://127.0.0.1:${port}${AUTH_CALLBACK_PATH}`;
+            const loginUrl = `${SYNALUX_BASE}/auth/prism-login?redirect_uri=${encodeURIComponent(callbackUrl)}`;
+            console.log(`\n🔐 Opening browser for Synalux login...`);
+            console.log(`   If the browser doesn't open, visit:\n   ${loginUrl}\n`);
+            // Open browser (platform-agnostic)
+            openBrowser(loginUrl);
+            // Timeout after 5 minutes
+            setTimeout(() => {
+                server.close();
+                resolve({ success: false, error: 'Login timed out (5 minutes)' });
+            }, 5 * 60 * 1000);
+        });
+    });
+}
+async function exchangeCode(code) {
+    const response = await fetch(`${SYNALUX_BASE}/api/v1/auth/code-exchange`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ code, client: 'prism-cli' }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Token exchange failed (${response.status}): ${text}`);
+    }
+    return response.json();
+}
+// ─── Token Refresh ────────────────────────────────────────────────
+/**
+ * Get a valid auth token, refreshing if expired.
+ * Returns empty string if not logged in.
+ */
+export async function getAuthToken() {
+    const token = await getSetting(KEY_AUTH_TOKEN);
+    if (!token)
+        return '';
+    // Check expiry
+    const expiresStr = await getSetting(KEY_AUTH_EXPIRES);
+    if (expiresStr) {
+        const expiresAt = parseInt(expiresStr, 10);
+        const now = Math.floor(Date.now() / 1000);
+        if (now < expiresAt - 60) {
+            // Token still valid (with 60s buffer)
+            return token;
+        }
+        // Try to refresh
+        const refreshToken = await getSetting(KEY_REFRESH_TOKEN);
+        if (refreshToken) {
+            try {
+                const refreshed = await refreshAuthToken(refreshToken);
+                await setSetting(KEY_AUTH_TOKEN, refreshed.access_token);
+                if (refreshed.expires_at) {
+                    await setSetting(KEY_AUTH_EXPIRES, String(refreshed.expires_at));
+                }
+                clearCloudCache();
+                return refreshed.access_token;
+            }
+            catch {
+                console.warn('[Prism Auth] Token refresh failed. Run `prism login` to re-authenticate.');
+                return '';
+            }
+        }
+    }
+    return token;
+}
+async function refreshAuthToken(refreshToken) {
+    const response = await fetch(`${SYNALUX_BASE}/api/v1/auth/jwt`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ refresh_token: refreshToken, client: 'prism-cli' }),
+    });
+    if (!response.ok) {
+        throw new Error(`Token refresh failed (${response.status})`);
+    }
+    return response.json();
+}
+// ─── Logout ───────────────────────────────────────────────────────
+export async function logout() {
+    await setSetting(KEY_AUTH_TOKEN, '');
+    await setSetting(KEY_REFRESH_TOKEN, '');
+    await setSetting(KEY_AUTH_EMAIL, '');
+    await setSetting(KEY_AUTH_PLAN, '');
+    await setSetting(KEY_AUTH_EXPIRES, '');
+    clearCloudCache();
+}
+export async function getAuthStatus() {
+    const token = await getSetting(KEY_AUTH_TOKEN);
+    if (!token)
+        return { loggedIn: false };
+    const email = await getSetting(KEY_AUTH_EMAIL);
+    const name = await getSetting(KEY_AUTH_NAME);
+    const plan = await getSetting(KEY_AUTH_PLAN);
+    const expiresStr = await getSetting(KEY_AUTH_EXPIRES);
+    return {
+        loggedIn: true,
+        email: email || undefined,
+        name: name || undefined,
+        plan: plan || undefined,
+        expiresAt: expiresStr ? new Date(parseInt(expiresStr, 10) * 1000) : undefined,
+    };
+}
+// ─── Helpers ──────────────────────────────────────────────────────
+function renderHtml(title, body) {
+    return `<!DOCTYPE html>
+<html><head><title>${title}</title>
+<style>body{font-family:system-ui,-apple-system,sans-serif;display:flex;justify-content:center;align-items:center;min-height:100vh;margin:0;background:#0a0a1a;color:#e0e0e0}
+.card{background:#1a1a2e;border-radius:16px;padding:48px;max-width:480px;text-align:center;box-shadow:0 8px 32px rgba(0,0,0,.4)}
+h1{font-size:24px;margin-bottom:16px}p{color:#a0a0b0;line-height:1.6}</style>
+</head><body><div class="card"><h1>${title}</h1><p>${body}</p></div></body></html>`;
+}
+function openBrowser(url) {
+    const { exec } = require('child_process');
+    const cmd = process.platform === 'darwin' ? 'open'
+        : process.platform === 'win32' ? 'start'
+            : 'xdg-open';
+    exec(`${cmd} "${url}"`);
+}

package/dist/darkfactory/cloudDelegate.js

@@ -0,0 +1,173 @@
+/**
+ * v12.5: Cloud-Delegated Dark Factory Pipelines
+ *
+ * Remote agent execution with Prism memory injection over HTTP.
+ * Delegates compute-intensive tasks to cloud agents while
+ * maintaining full memory context.
+ */
+import { debugLog } from "../utils/logger.js";
+// ─── State ───────────────────────────────────────────────────
+let config = {
+    endpoint: "https://cloud.synalux.ai/api/v1/darkfactory",
+    apiKey: "",
+    maxConcurrent: 5,
+    timeout: 300_000, // 5 minutes
+    enabled: false,
+};
+const activeTasks = new Map();
+const taskHistory = [];
+export function configureDelegate(updates) {
+    if (updates.endpoint && !updates.endpoint.startsWith('https://') && !updates.endpoint.includes('localhost')) {
+        throw new Error('Cloud delegate endpoint must use HTTPS');
+    }
+    config = { ...config, ...updates };
+    debugLog(`Cloud Delegate: Configured → ${config.endpoint}`);
+}
+export function getDelegateConfig() {
+    return { ...config, apiKey: config.apiKey ? "***" : "" };
+}
+// ─── Task Management ─────────────────────────────────────────
+function generateTaskId() {
+    return `dt_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+ * Create a new delegate task.
+ */
+export function createTask(type, project, payload, memoryContext, priority = "normal") {
+    const task = {
+        id: generateTaskId(),
+        type,
+        project,
+        payload,
+        memoryContext,
+        priority,
+        createdAt: new Date().toISOString(),
+        status: "queued",
+    };
+    activeTasks.set(task.id, task);
+    debugLog(`Cloud Delegate: Created task ${task.id} (${type}) for project '${project}'`);
+    return task;
+}
+/**
+ * Dispatch a task to the cloud endpoint.
+ */
+export async function dispatchTask(taskId) {
+    const task = activeTasks.get(taskId);
+    if (!task)
+        throw new Error(`Task '${taskId}' not found`);
+    if (!config.enabled) {
+        task.status = "failed";
+        task.result = { success: false, output: "", durationMs: 0, error: "Cloud delegate is not enabled" };
+        return task;
+    }
+    // Check concurrency limit
+    const running = Array.from(activeTasks.values()).filter(t => t.status === "running");
+    if (running.length >= config.maxConcurrent) {
+        debugLog(`Cloud Delegate: Concurrency limit reached (${running.length}/${config.maxConcurrent}), task ${taskId} stays queued`);
+        return task;
+    }
+    task.status = "dispatched";
+    try {
+        const start = Date.now();
+        const response = await fetch(`${config.endpoint}/tasks`, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${config.apiKey}`,
+                "Content-Type": "application/json",
+                "X-Prism-Version": "12.5.0",
+            },
+            body: JSON.stringify({
+                id: task.id,
+                type: task.type,
+                project: task.project,
+                payload: task.payload,
+                memoryContext: task.memoryContext,
+                priority: task.priority,
+            }),
+            signal: AbortSignal.timeout(config.timeout),
+        });
+        const data = await response.json();
+        const durationMs = Date.now() - start;
+        if (response.ok) {
+            task.status = "completed";
+            task.result = {
+                success: true,
+                output: data.output || "",
+                artifacts: data.artifacts,
+                memoryUpdates: data.memoryUpdates,
+                durationMs,
+            };
+        }
+        else {
+            task.status = "failed";
+            task.result = {
+                success: false,
+                output: "",
+                durationMs,
+                error: data.error || `HTTP ${response.status}`,
+            };
+        }
+    }
+    catch (err) {
+        task.status = "failed";
+        task.result = {
+            success: false,
+            output: "",
+            durationMs: 0,
+            error: `Dispatch error: ${err}`,
+        };
+    }
+    // Move to history
+    taskHistory.push({ ...task });
+    if (taskHistory.length > 1000)
+        taskHistory.splice(0, taskHistory.length - 1000);
+    activeTasks.delete(taskId);
+    debugLog(`Cloud Delegate: Task ${taskId} → ${task.status}`);
+    return task;
+}
+/**
+ * Cancel an active task.
+ */
+export function cancelTask(taskId) {
+    const task = activeTasks.get(taskId);
+    if (!task)
+        return false;
+    task.status = "cancelled";
+    taskHistory.push({ ...task });
+    if (taskHistory.length > 1000)
+        taskHistory.splice(0, taskHistory.length - 1000);
+    activeTasks.delete(taskId);
+    debugLog(`Cloud Delegate: Cancelled task ${taskId}`);
+    return true;
+}
+/**
+ * Get task status.
+ */
+export function getTaskStatus(taskId) {
+    return activeTasks.get(taskId) || taskHistory.find(t => t.id === taskId);
+}
+/**
+ * List all active tasks.
+ */
+export function listActiveTasks() {
+    return Array.from(activeTasks.values());
+}
+/**
+ * Get task history (last N tasks).
+ */
+export function getTaskHistory(limit = 20) {
+    return taskHistory.slice(-limit);
+}
+/**
+ * Get delegate status summary.
+ */
+export function getStatus() {
+    return {
+        enabled: config.enabled,
+        activeTasks: activeTasks.size,
+        maxConcurrent: config.maxConcurrent,
+        totalCompleted: taskHistory.filter(t => t.status === "completed").length,
+        totalFailed: taskHistory.filter(t => t.status === "failed").length,
+    };
+}
+debugLog("v12.5: Cloud delegate loaded");

package/dist/plugins/pluginManager.js

@@ -0,0 +1,199 @@
+/**
+ * v12.5: Plugin/Extension API for IDE Marketplace
+ *
+ * Load/unload `.prism-plugin.json` extensions with lifecycle hooks.
+ * Plugins can register custom tools, add storage backends,
+ * or extend the dashboard.
+ */
+import { debugLog } from "../utils/logger.js";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+// ─── Plugin Manager ──────────────────────────────────────────
+const plugins = new Map();
+function getPluginsDir() {
+    return join(process.env.PRISM_DATA_DIR || join(homedir(), ".prism"), "plugins");
+}
+/**
+ * Discover plugins in the plugins directory.
+ */
+export function discoverPlugins() {
+    const dir = getPluginsDir();
+    if (!existsSync(dir))
+        return [];
+    const manifests = [];
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const manifestPath = join(dir, entry.name, "prism-plugin.json");
+            if (!existsSync(manifestPath))
+                continue;
+            try {
+                const raw = readFileSync(manifestPath, "utf-8");
+                const manifest = JSON.parse(raw);
+                manifests.push(manifest);
+            }
+            catch (err) {
+                debugLog(`Plugin: Failed to parse manifest for ${entry.name}: ${err}`);
+            }
+        }
+    }
+    catch (err) {
+        debugLog(`Plugin: Failed to scan plugins directory: ${err}`);
+    }
+    return manifests;
+}
+/**
+ * Load a plugin by name.
+ */
+export async function loadPlugin(pluginName) {
+    const dir = join(getPluginsDir(), pluginName);
+    const manifestPath = join(dir, "prism-plugin.json");
+    if (!existsSync(manifestPath)) {
+        const loaded = {
+            manifest: { name: pluginName, version: "0.0.0", description: "", author: "", license: "", main: "", prismVersion: "", capabilities: [] },
+            path: dir,
+            status: "error",
+            loadedAt: new Date().toISOString(),
+            error: `Plugin '${pluginName}' not found at ${dir}`,
+        };
+        plugins.set(pluginName, loaded);
+        return loaded;
+    }
+    try {
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+        const entryPath = resolve(dir, manifest.main);
+        let instance;
+        if (existsSync(entryPath)) {
+            try {
+                const mod = await import(entryPath);
+                instance = mod.default || mod;
+                if (instance?.onLoad) {
+                    await instance.onLoad();
+                }
+            }
+            catch (err) {
+                debugLog(`Plugin: Failed to load entry point for ${pluginName}: ${err}`);
+            }
+        }
+        const loaded = {
+            manifest,
+            path: dir,
+            status: instance ? "active" : "loaded",
+            loadedAt: new Date().toISOString(),
+            instance,
+        };
+        plugins.set(pluginName, loaded);
+        debugLog(`Plugin: Loaded '${pluginName}' v${manifest.version} [${manifest.capabilities.join(", ")}]`);
+        return loaded;
+    }
+    catch (err) {
+        const loaded = {
+            manifest: { name: pluginName, version: "0.0.0", description: "", author: "", license: "", main: "", prismVersion: "", capabilities: [] },
+            path: dir,
+            status: "error",
+            loadedAt: new Date().toISOString(),
+            error: `Failed to load plugin: ${err}`,
+        };
+        plugins.set(pluginName, loaded);
+        return loaded;
+    }
+}
+/**
+ * Unload a plugin by name.
+ */
+export async function unloadPlugin(pluginName) {
+    const plugin = plugins.get(pluginName);
+    if (!plugin)
+        return false;
+    try {
+        if (plugin.instance?.onUnload) {
+            await plugin.instance.onUnload();
+        }
+    }
+    catch (err) {
+        debugLog(`Plugin: Error during unload of '${pluginName}': ${err}`);
+    }
+    plugins.delete(pluginName);
+    debugLog(`Plugin: Unloaded '${pluginName}'`);
+    return true;
+}
+/**
+ * List all loaded plugins.
+ */
+export function listPlugins() {
+    return Array.from(plugins.values());
+}
+/**
+ * Get a specific loaded plugin.
+ */
+export function getPlugin(name) {
+    return plugins.get(name);
+}
+/**
+ * Get all custom tools registered by plugins.
+ */
+export function getPluginTools() {
+    const result = [];
+    for (const [name, plugin] of plugins) {
+        if (plugin.status === "active" && plugin.instance?.getTools) {
+            try {
+                const tools = plugin.instance.getTools();
+                result.push({ pluginName: name, tools });
+            }
+            catch (err) {
+                debugLog(`Plugin: Error getting tools from '${name}': ${err}`);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Dispatch a tool call to the appropriate plugin.
+ */
+export async function dispatchPluginToolCall(toolName, args) {
+    for (const [, plugin] of plugins) {
+        if (plugin.status === "active" && plugin.instance?.onToolCall) {
+            try {
+                const result = await plugin.instance.onToolCall(toolName, args);
+                if (result !== undefined) {
+                    return { handled: true, result };
+                }
+            }
+            catch (err) {
+                debugLog(`Plugin: Error dispatching tool '${toolName}': ${err}`);
+            }
+        }
+    }
+    return { handled: false };
+}
+// ─── Plugin Schema Validation ────────────────────────────────
+/**
+ * Validate a plugin manifest against the schema.
+ */
+export function validateManifest(manifest) {
+    const errors = [];
+    const m = manifest;
+    if (!m.name || typeof m.name !== "string")
+        errors.push("Missing or invalid 'name'");
+    if (!m.version || typeof m.version !== "string")
+        errors.push("Missing or invalid 'version'");
+    if (!m.main || typeof m.main !== "string")
+        errors.push("Missing or invalid 'main' entry point");
+    if (!m.prismVersion || typeof m.prismVersion !== "string")
+        errors.push("Missing 'prismVersion'");
+    if (!Array.isArray(m.capabilities))
+        errors.push("Missing 'capabilities' array");
+    const validCaps = ["tools", "storage", "dashboard", "preprocessor", "postprocessor", "scheduler"];
+    if (Array.isArray(m.capabilities)) {
+        for (const cap of m.capabilities) {
+            if (!validCaps.includes(cap)) {
+                errors.push(`Unknown capability: '${cap}'`);
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+debugLog("v12.5: Plugin manager loaded");

package/dist/prism-cloud.js

@@ -0,0 +1,110 @@
+import { getSettingSync } from './storage/configStorage.js';
+const DEFAULT_LIMITS = {
+    tier: 'free',
+    status: 'active',
+    limits: {
+        llm_daily: 0,
+        search_daily: 0,
+        memory_sync: false,
+        coder_daily: 0,
+    },
+    usage: {
+        llm_calls: 0,
+        search_calls: 0,
+        memory_calls: 0,
+        coder_calls: 0,
+    },
+    features: {
+        cloud_coder: false,
+        cloud_memory: false,
+        cloud_llm: false,
+        cloud_search: false,
+        hivemind: false,
+        voice_video: false,
+    },
+};
+let cachedLimits = null;
+/**
+ * Verify cloud license via Synalux API (v2.0 — JWT Auth).
+ *
+ * Reads auth token from:
+ *   1. PRISM_AUTH_TOKEN env var (set by `prism login`)
+ *   2. prism_auth_token setting (stored by dashboard login)
+ *   3. Legacy: PRISM_LICENSE_KEY (deprecated, returns guidance)
+ *
+ * Calls GET /api/v1/prism/verify with Bearer JWT.
+ */
+export async function verifyCloudLicense() {
+    if (cachedLimits)
+        return cachedLimits;
+    // v2.0: Read JWT auth token (set by `prism login` OAuth flow)
+    const authToken = getSettingSync('prism_auth_token', process.env.PRISM_AUTH_TOKEN || '');
+    // Legacy fallback: if user still has old license key, guide them to upgrade
+    const legacyKey = getSettingSync('prism_license_key', process.env.PRISM_LICENSE_KEY || '');
+    if (!authToken && legacyKey) {
+        console.warn('[Prism Cloud] License key auth is deprecated. Please run `prism login` to switch to OAuth.');
+        return DEFAULT_LIMITS;
+    }
+    if (!authToken) {
+        console.warn('[Prism Cloud] No auth token found. Operating in Free tier. Run `prism login` to authenticate.');
+        return DEFAULT_LIMITS;
+    }
+    try {
+        const baseUrl = process.env.SYNALUX_API_BASE || 'https://synalux.ai';
+        const response = await fetch(`${baseUrl}/api/v1/prism/verify`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${authToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            if (response.status === 401) {
+                console.warn('[Prism Cloud] Auth token expired or invalid. Run `prism login` to re-authenticate.');
+            }
+            else {
+                console.warn(`[Prism Cloud] Verification failed with status ${response.status}. Operating in Free tier.`);
+            }
+            return DEFAULT_LIMITS;
+        }
+        const data = await response.json();
+        if (data.status === 'success') {
+            cachedLimits = {
+                tier: data.user.plan || 'free',
+                status: 'active',
+                limits: {
+                    llm_daily: data.limits?.llm_daily || 0,
+                    search_daily: data.limits?.search_daily || 0,
+                    memory_sync: data.limits?.memory_sync || false,
+                    coder_daily: data.limits?.coder_daily || 0,
+                },
+                usage: {
+                    llm_calls: data.usage?.llm_calls || 0,
+                    search_calls: data.usage?.search_calls || 0,
+                    memory_calls: data.usage?.memory_calls || 0,
+                    coder_calls: data.usage?.coder_calls || 0,
+                },
+                features: data.features || DEFAULT_LIMITS.features,
+            };
+            console.log(`[Prism Cloud] Verified ${cachedLimits.tier} license.`);
+            return cachedLimits;
+        }
+        else {
+            console.warn(`[Prism Cloud] Invalid response. Operating in Free tier.`);
+            return DEFAULT_LIMITS;
+        }
+    }
+    catch (error) {
+        console.error(`[Prism Cloud] Error verifying license: ${error instanceof Error ? error.message : String(error)}`);
+        return DEFAULT_LIMITS;
+    }
+}
+export function getCloudLimits() {
+    return cachedLimits || DEFAULT_LIMITS;
+}
+/**
+ * Clear cached limits (e.g., after `prism login` sets new token).
+ */
+export function clearCloudCache() {
+    cachedLimits = null;
+}