@xalia/agent 0.5.8 → 0.6.0

package/dist/agent/src/chat/client/sessionClient.js

@@ -0,0 +1,331 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionClient = void 0;
+const assert_1 = require("assert");
+const uuid_1 = require("uuid");
+const sdk_1 = require("@xalia/xmcp/sdk");
+const mcpServerManager_1 = require("../../agent/mcpServerManager");
+const database_1 = require("../data/database");
+const logger = (0, sdk_1.getLogger)();
+class RemoteSudoMcpServerManager {
+    constructor(sender, briefs) {
+        this.briefsMap = new Map();
+        this.mcpServers = new Map();
+        this.sender = sender;
+        this.briefs = briefs;
+        briefs.forEach((b) => {
+            this.briefsMap.set(b.name, b);
+        });
+    }
+    hasMcpServer(mcpServerName) {
+        return this.mcpServers.has(mcpServerName);
+    }
+    getMcpServerNames() {
+        return Array.from(this.mcpServers.keys());
+    }
+    getMcpServer(mcpServerName) {
+        const server = this.mcpServers.get(mcpServerName);
+        if (server) {
+            return server;
+        }
+        throw Error(`[getMcpServer] unknown server ${mcpServerName}`);
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async removeMcpServer(mcpServerName) {
+        if (!this.mcpServers.has(mcpServerName)) {
+            logger.info(`[removeMcpServer] mcpServers: ${JSON.stringify(this.mcpServers)}`);
+            throw Error(`no server ${mcpServerName} (removeMcpServer)`);
+        }
+        this.sender.sendSessionMessage({
+            type: "remove_mcp_server",
+            server_name: mcpServerName,
+        });
+    }
+    enableAllTools(mcpServerName) {
+        if (!this.mcpServers.has(mcpServerName)) {
+            throw Error(`no server ${mcpServerName} (enableAllTools)`);
+        }
+        this.sender.sendSessionMessage({
+            type: "enable_all_mcp_server_tools",
+            server_name: mcpServerName,
+        });
+    }
+    disableAllTools(mcpServerName) {
+        if (!this.mcpServers.has(mcpServerName)) {
+            throw Error(`no server ${mcpServerName} (disableAllTools)`);
+        }
+        this.sender.sendSessionMessage({
+            type: "disable_all_mcp_server_tools",
+            server_name: mcpServerName,
+        });
+    }
+    enableTool(mcpServerName, toolName) {
+        const server = this.mcpServers.get(mcpServerName);
+        if (!server) {
+            throw Error(`no server ${mcpServerName} (enableTool)`);
+        }
+        const tools = server.getTool(toolName);
+        if (!tools) {
+            throw Error(`no tool ${toolName} on server ${mcpServerName}`);
+        }
+        this.sender.sendSessionMessage({
+            type: "enable_mcp_server_tool",
+            server_name: mcpServerName,
+            tool: toolName,
+        });
+    }
+    disableTool(mcpServerName, toolName) {
+        const server = this.mcpServers.get(mcpServerName);
+        if (!server) {
+            throw Error(`no server ${mcpServerName} (disableTool)`);
+        }
+        const tools = server.getTool(toolName);
+        if (!tools) {
+            throw Error(`no tool ${toolName} on server ${mcpServerName}`);
+        }
+        this.sender.sendSessionMessage({
+            type: "disable_mcp_server_tool",
+            server_name: mcpServerName,
+            tool: toolName,
+        });
+    }
+    onMcpServerAdded(mcpServerName, tools, enabled_tools) {
+        logger.debug(`[onMcpServerAdded]: ${mcpServerName}, tools: ${JSON.stringify(tools)}` +
+            `, enabled: ${JSON.stringify(enabled_tools)}`);
+        const mcpServerInfo = new mcpServerManager_1.McpServerInfoRW(tools);
+        for (const tool of enabled_tools) {
+            mcpServerInfo.enableTool(tool);
+        }
+        this.mcpServers.set(mcpServerName, mcpServerInfo);
+    }
+    onMcpServerRemoved(mcpServerName) {
+        this.mcpServers.delete(mcpServerName);
+    }
+    onMcpServerToolEnabled(mcpServerName, toolName) {
+        const server = this.mcpServers.get(mcpServerName);
+        if (!server) {
+            throw Error(`no server ${mcpServerName} (onMcpServerToolEnabled)`);
+        }
+        const tools = server.getTool(toolName);
+        if (!tools) {
+            throw Error(`no tool ${toolName} on server ${mcpServerName}`);
+        }
+        server.enableTool(toolName);
+    }
+    onMcpServerToolDisabled(mcpServerName, toolName) {
+        const server = this.mcpServers.get(mcpServerName);
+        if (!server) {
+            throw Error(`no server ${mcpServerName} (onMcpServerToolDisabled)`);
+        }
+        const tools = server.getTool(toolName);
+        if (!tools) {
+            throw Error(`no tool ${toolName} on server ${mcpServerName}`);
+        }
+        server.disableTool(toolName);
+    }
+    getServerBriefs() {
+        return this.briefs;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async addMcpServer(server_name, enable_all) {
+        if (!this.briefsMap.has(server_name)) {
+            throw Error(`no such server ${server_name} (addMcpServer)`);
+        }
+        this.sender.sendSessionMessage({
+            type: "add_mcp_server",
+            server_name,
+            enable_all,
+        });
+    }
+    hasServer(server_name) {
+        return this.briefsMap.has(server_name);
+    }
+    async shutdown() { }
+}
+class SessionClient {
+    constructor(sessionUUID, savedAgentProfile, sender, serverBriefs, participants) {
+        this.sessionUUID = sessionUUID;
+        this.savedAgentProfile = savedAgentProfile;
+        this.sender = sender;
+        this.participants = participants;
+        this.sender = sender;
+        this.smsm = new RemoteSudoMcpServerManager(this, serverBriefs);
+        this.systemPrompt = "";
+        this.model = "";
+        this.participants = participants;
+    }
+    getSessionUUID() {
+        return this.sessionUUID;
+    }
+    getSudoMcpServerManager() {
+        return this.smsm;
+    }
+    getConversation() {
+        throw new Error("unimpl: getConversation");
+    }
+    getAgentProfile() {
+        return this.savedAgentProfile.profile;
+    }
+    getAgentUuid() {
+        return this.savedAgentProfile.uuid;
+    }
+    getSavedAgentProfile() {
+        return this.savedAgentProfile;
+    }
+    getSystemPrompt() {
+        return this.systemPrompt;
+    }
+    setSystemPrompt(system_prompt) {
+        // Don't set system prompt here.  Wait until we get confirmation from the
+        // server.
+        this.sendSessionMessage({ type: "set_system_prompt", system_prompt });
+    }
+    getModel() {
+        return this.model;
+    }
+    setModel(model) {
+        // Don't set model here.  Wait until we get confirmation from the server.
+        this.sendSessionMessage({ type: "set_model", model });
+    }
+    userMessage(msg, imageB64) {
+        (0, assert_1.strict)(msg || imageB64, "Either message or image must be provided");
+        this.sendSessionMessage({ type: "msg", message: msg, imageB64 });
+    }
+    resetConversation() {
+        throw new Error("resetConversation not implemented for ChatClient");
+    }
+    shutdown() {
+        throw new Error("shutdown not implemented for ChatClient");
+    }
+    getParticipants() {
+        return this.participants;
+    }
+    /**
+     * Sets auto-approval preference for a specific tool.
+     */
+    setAutoApproval(serverName, toolName, autoApprove) {
+        const smsm = this.getSudoMcpServerManager();
+        if (!smsm.hasMcpServer(serverName)) {
+            throw Error(`server ${serverName} not added (setAutoApproval)`);
+        }
+        const server = smsm.getMcpServer(serverName);
+        const tool = server.getTool(toolName);
+        if (!tool) {
+            throw Error(`no tool ${toolName} on server ${serverName}`);
+        }
+        this.sendSessionMessage({
+            type: "set_auto_approval",
+            server_name: serverName,
+            tool: toolName,
+            auto_approve: autoApprove,
+        });
+    }
+    /**
+     * Send a generic message (for compatibility)
+     */
+    sendMessage(message) {
+        throw new Error(`Unsupported message type: ${message.type}`);
+    }
+    /**
+     * The caller sees a message `ServerApproveToolCall`, at which point it
+     * should prompt the user for permission to run the tool. The result of
+     * that prompt should be passed here.
+     */
+    toolCallApprovalResult(id, result, auto_approve) {
+        this.sendSessionMessage({
+            type: "tool_call_approval_result",
+            id,
+            result,
+            auto_approve,
+        });
+    }
+    // Implementation of IMessageSender interface
+    sendSessionMessage(message) {
+        const enrichedMessage = {
+            ...message,
+            client_message_id: (0, uuid_1.v4)(),
+            session_id: this.sessionUUID,
+        };
+        this.sender.send(enrichedMessage);
+    }
+    updateSessionInfo(sessionInfo) {
+        // TODO: Implement this
+        // throw new Error("[SessionClient.updateSessionInfo] not implemented");
+        const infoStr = JSON.stringify(sessionInfo.workspace);
+        logger.debug(`[SessionClient] ignoring session info: ${infoStr}`);
+    }
+    setWorkspace(message, imageB64) {
+        const msg = {
+            type: "set_workspace",
+            message,
+            imageB64,
+        };
+        this.sendSessionMessage(msg);
+    }
+    /**
+     * Set MCP server configuration.
+     */
+    setMcpServerConfig(server_name, config) {
+        this.sendSessionMessage({
+            type: "set_mcp_server_config",
+            server_name,
+            config,
+        });
+    }
+    deleteMcpServerConfig(server_name) {
+        this.sendSessionMessage({
+            type: "set_mcp_server_config",
+            server_name,
+        });
+    }
+    handleMessage(message) {
+        switch (message.type) {
+            //
+            // State updates
+            //
+            case "mcp_server_added":
+                this.smsm.onMcpServerAdded(message.server_name, message.tools, message.enabled_tools);
+                break;
+            case "mcp_server_removed":
+                this.smsm.onMcpServerRemoved(message.server_name);
+                break;
+            case "mcp_server_tool_enabled":
+                this.smsm.onMcpServerToolEnabled(message.server_name, message.tool);
+                break;
+            case "mcp_server_tool_disabled":
+                this.smsm.onMcpServerToolDisabled(message.server_name, message.tool);
+                break;
+            case "system_prompt_updated":
+                this.systemPrompt = message.system_prompt;
+                break;
+            case "model_updated":
+                this.model = message.model;
+                break;
+            case "session_info":
+                // Update participants if we receive session_info again
+                if ("participants" in message) {
+                    this.participants = (0, database_1.createSessionParticipantMap)(message.participants);
+                }
+                break;
+            case "user_added":
+                this.participants.set(message.user_uuid, {
+                    user_uuid: message.user_uuid,
+                    nickname: message.nickname,
+                    email: message.email,
+                    role: message.role,
+                });
+                break;
+            case "user_removed":
+                this.participants.delete(message.user_uuid);
+                break;
+            //
+            // Ignore other messages - the owner (the UI layer) can handle them at
+            // its discretion.
+            //
+            default:
+                logger.debug(`[handleMessageInternal]: ignoring message: ${message.type}`);
+                break;
+        }
+    }
+}
+exports.SessionClient = SessionClient;

package/dist/agent/src/chat/client/teamManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/agent/src/chat/{apiKeyManager.js → data/apiKeyManager.js}

@@ -3,13 +3,17 @@
 // - lru-cache
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiKeyManager = void 0;
+const sdk_1 = require("@xalia/xmcp/sdk");
+const logger = (0, sdk_1.getLogger)();
 class ApiKeyManager {
     constructor(db) {
         this.db = db;
     }
     async verifyApiKey(apiKey) {
         // TODO: Cache this
+        logger.info(`[ApiKeyManager] Verifying API key: ${apiKey}`);
         const userInfo = await this.db.getUserDataFromApiKey(apiKey);
+        logger.info(`[ApiKeyManager] User info: ${JSON.stringify(userInfo)}`);
         return userInfo;
         // if (apiKey.startsWith("dummy_key")) {
         //   return {

package/dist/agent/src/chat/data/dataModels.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });