0xray 4.0.13 → 4.0.14

package/dist/mcps/knowledge-skills/session-management.server.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Session Management MCP Server
+ *
+ * Tools for managing user sessions and persistent state.
+ * Provides session lifecycle management, state persistence, and cleanup utilities.
+ */
+import { XrayKnowledgeSkillBase, type ToolDefinition } from "../shared/knowledge-skill-base.js";
+declare class SessionManagementServer extends XrayKnowledgeSkillBase {
+    private sessions;
+    protected tools: ToolDefinition[];
+    constructor();
+    private generateSessionId;
+    private isExpired;
+    private handleCreateSession;
+    private handleGetSession;
+    private handleUpdateSession;
+    private handleDeleteSession;
+    private handleListSessions;
+    private handleSessionExists;
+    private handleCleanupExpiredSessions;
+}
+export default SessionManagementServer;

package/dist/mcps/knowledge-skills/session-management.server.js

@@ -0,0 +1,394 @@
+/**
+ * Session Management MCP Server
+ *
+ * Tools for managing user sessions and persistent state.
+ * Provides session lifecycle management, state persistence, and cleanup utilities.
+ */
+import * as fs from "fs";
+import { frameworkLogger } from "../../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+class SessionManagementServer extends XrayKnowledgeSkillBase {
+    sessions = new Map();
+    tools = [
+        {
+            name: "create_session",
+            description: "Create a new session with optional data and expiration",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sessionId: {
+                        type: "string",
+                        description: "Optional custom session ID (generated if not provided)",
+                    },
+                    data: {
+                        type: "object",
+                        description: "Initial session data",
+                    },
+                    ttl: {
+                        type: "number",
+                        description: "Time to live in seconds (optional)",
+                    },
+                },
+            },
+        },
+        {
+            name: "get_session",
+            description: "Retrieve session data by session ID",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sessionId: {
+                        type: "string",
+                        description: "Session ID to retrieve",
+                    },
+                },
+                required: ["sessionId"],
+            },
+        },
+        {
+            name: "update_session",
+            description: "Update session data",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sessionId: {
+                        type: "string",
+                        description: "Session ID to update",
+                    },
+                    data: {
+                        type: "object",
+                        description: "Data to merge with existing session",
+                    },
+                    extendTtl: {
+                        type: "number",
+                        description: "Extend TTL by this many seconds",
+                    },
+                },
+                required: ["sessionId", "data"],
+            },
+        },
+        {
+            name: "delete_session",
+            description: "Delete a session",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sessionId: {
+                        type: "string",
+                        description: "Session ID to delete",
+                    },
+                },
+                required: ["sessionId"],
+            },
+        },
+        {
+            name: "list_sessions",
+            description: "List all active sessions",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    includeExpired: {
+                        type: "boolean",
+                        default: false,
+                        description: "Include expired sessions in the list",
+                    },
+                    limit: {
+                        type: "number",
+                        default: 50,
+                        description: "Maximum number of sessions to return",
+                    },
+                },
+            },
+        },
+        {
+            name: "session_exists",
+            description: "Check if a session exists and is valid",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sessionId: {
+                        type: "string",
+                        description: "Session ID to check",
+                    },
+                },
+                required: ["sessionId"],
+            },
+        },
+        {
+            name: "cleanup_expired_sessions",
+            description: "Clean up all expired sessions",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    dryRun: {
+                        type: "boolean",
+                        default: false,
+                        description: "If true, only return what would be deleted without deleting",
+                    },
+                },
+            },
+        },
+    ];
+    constructor() {
+        super("session-management", "3.1.0");
+        this.handlers = {
+            create_session: async (args) => this.handleCreateSession(args),
+            get_session: async (args) => this.handleGetSession(args),
+            update_session: async (args) => this.handleUpdateSession(args),
+            delete_session: async (args) => this.handleDeleteSession(args),
+            list_sessions: async (args) => this.handleListSessions(args),
+            session_exists: async (args) => this.handleSessionExists(args),
+            cleanup_expired_sessions: async (args) => this.handleCleanupExpiredSessions(args),
+        };
+        this.setupToolHandlers();
+    }
+    generateSessionId() {
+        return `session_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    }
+    isExpired(session) {
+        if (!session.expiresAt)
+            return false;
+        return Date.now() > session.expiresAt;
+    }
+    handleCreateSession(args) {
+        const sessionId = args.sessionId;
+        const data = args.data || {};
+        const ttl = args.ttl;
+        const id = sessionId || this.generateSessionId();
+        const now = Date.now();
+        const session = {
+            id,
+            data: data,
+            createdAt: now,
+            lastAccessed: now,
+            expiresAt: ttl ? now + ttl * 1000 : undefined,
+        };
+        this.sessions.set(id, session);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        sessionId: id,
+                        createdAt: new Date(session.createdAt).toISOString(),
+                        expiresAt: session.expiresAt
+                            ? new Date(session.expiresAt).toISOString()
+                            : "never",
+                        data: session.data,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    handleGetSession(args) {
+        const sessionId = args.sessionId;
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            error: "Session not found",
+                            sessionId,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (this.isExpired(session)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            error: "Session has expired",
+                            sessionId,
+                            expiredAt: session.expiresAt,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Update last accessed
+        session.lastAccessed = Date.now();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        sessionId: session.id,
+                        createdAt: new Date(session.createdAt).toISOString(),
+                        lastAccessed: new Date(session.lastAccessed).toISOString(),
+                        expiresAt: session.expiresAt
+                            ? new Date(session.expiresAt).toISOString()
+                            : "never",
+                        data: session.data,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    handleUpdateSession(args) {
+        const sessionId = args.sessionId;
+        const data = args.data;
+        const extendTtl = args.extendTtl;
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            error: "Session not found",
+                            sessionId,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Merge data
+        session.data = { ...session.data, ...data };
+        session.lastAccessed = Date.now();
+        // Extend TTL if requested
+        if (extendTtl && session.expiresAt) {
+            session.expiresAt = session.expiresAt + extendTtl * 1000;
+        }
+        else if (extendTtl && !session.expiresAt) {
+            session.expiresAt = Date.now() + extendTtl * 1000;
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        sessionId: session.id,
+                        updatedAt: new Date(session.lastAccessed).toISOString(),
+                        expiresAt: session.expiresAt
+                            ? new Date(session.expiresAt).toISOString()
+                            : "never",
+                        data: session.data,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    handleDeleteSession(args) {
+        const sessionId = args.sessionId;
+        const existed = this.sessions.has(sessionId);
+        this.sessions.delete(sessionId);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        sessionId,
+                        deleted: existed,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    handleListSessions(args) {
+        const includeExpired = args.includeExpired || false;
+        const limit = args.limit || 50;
+        const now = Date.now();
+        const sessions = Array.from(this.sessions.values())
+            .filter((session) => {
+            if (includeExpired)
+                return true;
+            if (!session.expiresAt)
+                return true;
+            return now < session.expiresAt;
+        })
+            .sort((a, b) => b.lastAccessed - a.lastAccessed)
+            .slice(0, limit)
+            .map((session) => ({
+            sessionId: session.id,
+            createdAt: new Date(session.createdAt).toISOString(),
+            lastAccessed: new Date(session.lastAccessed).toISOString(),
+            expiresAt: session.expiresAt
+                ? new Date(session.expiresAt).toISOString()
+                : "never",
+            isExpired: session.expiresAt ? now > session.expiresAt : false,
+            dataKeys: Object.keys(session.data),
+        }));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        total: sessions.length,
+                        includeExpired,
+                        sessions,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    handleSessionExists(args) {
+        const sessionId = args.sessionId;
+        const session = this.sessions.get(sessionId);
+        const exists = session && !this.isExpired(session);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        sessionId,
+                        exists,
+                        ...(session && !this.isExpired(session)
+                            ? {
+                                createdAt: new Date(session.createdAt).toISOString(),
+                                lastAccessed: new Date(session.lastAccessed).toISOString(),
+                            }
+                            : {}),
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    handleCleanupExpiredSessions(args) {
+        const dryRun = args.dryRun || false;
+        const now = Date.now();
+        let cleaned = 0;
+        const expiredIds = [];
+        for (const [id, session] of this.sessions.entries()) {
+            if (session.expiresAt && now > session.expiresAt) {
+                expiredIds.push(id);
+                if (!dryRun) {
+                    this.sessions.delete(id);
+                }
+                cleaned++;
+            }
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        dryRun,
+                        cleaned,
+                        expiredSessionIds: expiredIds,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+}
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
+    const server = new SessionManagementServer();
+    server.run().catch((error) => frameworkLogger.log("mcps/session-management", "run", "error", { error: String(error) }));
+}
+export default SessionManagementServer;

package/dist/mcps/knowledge-skills/skill-invocation.server.d.ts

@@ -0,0 +1,32 @@
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class SkillInvocationServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private skillMetrics;
+    /**
+     * Record skill invocation outcome for adaptive learning
+     */
+    private recordSkillOutcome;
+    private handleListSkills;
+    private handleInvokeSkill;
+    private handleSkillCodeReview;
+    private handleSkillSecurityAudit;
+    private handleSkillPerformanceOptimization;
+    private handleSkillTestingStrategy;
+    private handleSkillProjectAnalysis;
+    private handleSkillDatabaseDesign;
+    private handleSkillDevopsDeployment;
+    private handleSkillApiDesign;
+    private handleSkillUiUxDesign;
+    private handleSkillDocumentationGeneration;
+    private handleSkillStoryteller;
+    private captureConsole;
+    private handleInstallSkill;
+    private handleSkillRegistryList;
+    private handleSkillRegistryAdd;
+    private handleSkillRegistryRemove;
+    /**
+     * Run as HTTP server using Streamable HTTP transport (for Grok CLI compatibility).
+     */
+    runHttp(port?: number): Promise<void>;
+}
+export { SkillInvocationServer };