@xalia/agent 1.0.19

package/dist/chat.js

@@ -0,0 +1,278 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runChat = runChat;
+const yocto_spinner_1 = __importDefault(require("yocto-spinner"));
+const fs = __importStar(require("fs"));
+const tools_1 = require("./tools");
+const files_1 = require("./files");
+const prompt_1 = require("./prompt");
+const chalk_1 = __importDefault(require("chalk"));
+const tool_1 = require("@xalia/xmcp/tool");
+const sdk_1 = require("@xalia/xmcp/sdk");
+const agentUtils_1 = require("./agentUtils");
+const nodePlatform_1 = require("./nodePlatform");
+const logger = (0, sdk_1.getLogger)();
+async function runChat(agentProfile, conversation, prompt, image, openaiApiKey, sudomcpConfig, approveToolsUpTo) {
+    // In chat mode, just print the messages.  Ask for tool confirmation
+    // unless approveTools is set.
+    const spinner = (0, yocto_spinner_1.default)();
+    const onMessage = async (msg, _msgEnd) => {
+        if (msg.content) {
+            if (spinner) {
+                spinner.stop().clear();
+            }
+            console.log(`AGENT: ${msg.content}`);
+        }
+    };
+    let remainingApprovedToolCalls = approveToolsUpTo;
+    const onToolCall = async (toolCall) => {
+        if (remainingApprovedToolCalls !== 0) {
+            --remainingApprovedToolCalls;
+            return true;
+        }
+        spinner.stop().clear();
+        const result = await promptToolCall(repl, toolCall);
+        spinner.start();
+        return result;
+    };
+    // Create agent
+    const [agent, sudoMcpServerManager] = await (0, agentUtils_1.createAgentAndSudoMcpServerManager)(agentProfile, onMessage, onToolCall, nodePlatform_1.NODE_PLATFORM, openaiApiKey, sudomcpConfig, tool_1.authenticate.FRONTEND_PROD_AUTHORIZED_URL, undefined);
+    if (conversation) {
+        agent.setConversation(conversation);
+    }
+    // Opening banner
+    console.log(`${chalk_1.default.green("SudoMCP Agent CLI")}`);
+    console.log(`(Type ${chalk_1.default.yellow("/h")} for help, ${chalk_1.default.yellow("/q")} to quit.)`);
+    // Display first prompt if supplied
+    if (prompt) {
+        console.log(`USER: ${prompt}`);
+    }
+    const repl = new prompt_1.Prompt();
+    // Conversation loop
+    while (true) {
+        if (!prompt) {
+            const [msg, img] = await getNextPrompt(repl, agent, sudoMcpServerManager);
+            if (!msg && !img) {
+                break;
+            }
+            prompt = msg;
+            image = img;
+        }
+        image = (0, files_1.loadImageB64OrUndefined)(image);
+        // Pass the prompt and image to the Agent
+        try {
+            spinner.start();
+            await agent.userMessage(prompt, image);
+        }
+        catch (e) {
+            console.log(`ERROR: ${e}`);
+        }
+        prompt = undefined;
+        image = undefined;
+    }
+    // Shutdown the agent
+    repl.shutdown();
+    await agent.shutdown();
+    logger.debug("shutdown done");
+}
+/**
+ * Read lines from the prompt, parsing any commands, and return once there is
+ * a prompt and/or image for the llm.  Both undefined means exit.
+ */
+async function getNextPrompt(repl, agent, sudoMcpServerManager) {
+    while (true) {
+        // Get a line, detecting the EOF signal.
+        const line = await repl.run();
+        if (typeof line === "undefined") {
+            console.log("closing ...");
+            return [undefined, undefined];
+        }
+        if (line.length === 0) {
+            continue;
+        }
+        // Extract prompt or commands
+        const { msg, cmds } = (0, prompt_1.parsePrompt)(line);
+        // If there are no commands, this must be a prompt only
+        if (!cmds) {
+            return [msg, undefined];
+        }
+        // There are commands.  If it's image, return [prompt, image].  If it's
+        // quit, return [undefined, undefined], otherwise it must be a command.
+        // Execute it and prompt again.
+        switch (cmds[0]) {
+            case "i": // image
+                return [msg, cmds[1]];
+            case "q":
+            case "quit":
+            case "exit":
+                return [undefined, undefined];
+            default:
+                break;
+        }
+        try {
+            await runCommand(agent, agent.getMcpServerManager(), sudoMcpServerManager, cmds);
+        }
+        catch (e) {
+            console.log(`ERROR: ${e}`);
+        }
+    }
+}
+async function runCommand(agent, mcpServerManager, sudoMcpServerManager, cmds) {
+    switch (cmds[0]) {
+        case "lt":
+            listTools(mcpServerManager);
+            break;
+        case "ls":
+            listServers(sudoMcpServerManager);
+            break;
+        case "as":
+            await addServer(sudoMcpServerManager, cmds[1]);
+            break;
+        case "rs":
+            await mcpServerManager.removeMcpServer(cmds[1]);
+            break;
+        case "e":
+            mcpServerManager.enableTool(cmds[1], cmds[2]);
+            console.log(`Enabled tool ${cmds[2]} for server ${cmds[1]}`);
+            break;
+        case "d":
+            mcpServerManager.disableTool(cmds[1], cmds[2]);
+            console.log(`Disabled tool ${cmds[2]} for server ${cmds[1]}`);
+            break;
+        case "ea":
+            mcpServerManager.enableAllTools(cmds[1]);
+            console.log(`Enabled all tools for server ${cmds[1]}`);
+            break;
+        case "da":
+            mcpServerManager.disableAllTools(cmds[1]);
+            console.log(`Disabled all tools for server ${cmds[1]}`);
+            break;
+        case "wc":
+            writeConversation(agent, cmds[1]);
+            break;
+        case "wa":
+            writeAgentProfile(agent, cmds[1]);
+            break;
+        case "h":
+        case "help":
+        case "?":
+            helpMenu();
+            break;
+        default:
+            console.log(`error: Unknown command ${cmds[0]}`);
+    }
+}
+function helpMenu() {
+    console.log(`Tool management commands:`);
+    console.log(`  ${chalk_1.default.yellow("/lt")}                          List tools: `);
+    console.log(`  ${chalk_1.default.yellow("/ls")}                          List servers`);
+    console.log(`  ${chalk_1.default.yellow("/as <server-name>")}            Add server`);
+    console.log(`  ${chalk_1.default.yellow("/rs <server-name>")}            Remove server`);
+    console.log(`  ${chalk_1.default.yellow("/e <server-name> <tool-name>")} Enable tool`);
+    console.log(`  ${chalk_1.default.yellow("/d <server-name> <tool-name>")} Disable tool`);
+    console.log(`  ${chalk_1.default.yellow("/ea <server-name>")}            Enable all tools`);
+    console.log(`  ${chalk_1.default.yellow("/da <server-name>")}            Disable all tools`);
+    console.log(`  ${chalk_1.default.yellow("/wc <file-name>")}              Write conversation file`);
+    console.log(`  ${chalk_1.default.yellow("/wa <file-name>")}              Write agent profile file`);
+    console.log(`  ${chalk_1.default.yellow("/q")}                           Quit`);
+}
+function listTools(mcpServerManager) {
+    console.log("Mcp servers and tools (* - enabled):");
+    const serverNames = mcpServerManager.getMcpServerNames();
+    for (const serverName of serverNames) {
+        const server = mcpServerManager.getMcpServer(serverName);
+        console.log(` ${chalk_1.default.green(serverName)}`);
+        const tools = server.getTools();
+        const enabled = server.getEnabledTools();
+        for (const tool of tools) {
+            const isEnabled = enabled[tool.name] ? "*" : " ";
+            console.log(`  [${isEnabled}] ${tool.name}`);
+        }
+    }
+}
+function listServers(sudoMcpServerManager) {
+    console.log(`Available MCP Servers:`);
+    const serverBriefs = sudoMcpServerManager.getServerBriefs();
+    serverBriefs.sort((a, b) => a.name.localeCompare(b.name));
+    for (const brief of serverBriefs) {
+        console.log(`- ${chalk_1.default.green(brief.name)}: ${brief.description}`);
+    }
+}
+/**
+ * Adds server and enables all tools.
+ */
+async function addServer(sudoMcpServerManager, serverName) {
+    const sudoMcpConfig = tool_1.configuration.loadEnsureConfig();
+    const config = sudoMcpConfig
+        ? sudoMcpConfig.getConfigForServer(serverName)
+        : {};
+    try {
+        await sudoMcpServerManager.addMcpServer(serverName, config);
+    }
+    catch (e) {
+        if (e instanceof sdk_1.InvalidConfiguration) {
+            throw `${e}. \n
+      Have you installed server ${serverName} using the SudoMCP CLI tool?`;
+        }
+        else {
+            throw e;
+        }
+    }
+    sudoMcpServerManager.getMcpServerManager().enableAllTools(serverName);
+    console.log(`Added server: ${serverName} and enabled all tools.`);
+    console.log(`Current tool list:`);
+    listTools(sudoMcpServerManager.getMcpServerManager());
+}
+function writeConversation(agent, fileName) {
+    const conversation = agent.getConversation();
+    fs.writeFileSync(fileName, JSON.stringify(conversation), {
+        encoding: "utf8",
+    });
+    console.log(`Conversation written to ${fileName}`);
+}
+function writeAgentProfile(agent, fileName) {
+    const profile = agent.getAgentProfile();
+    fs.writeFileSync(fileName, JSON.stringify(profile));
+    console.log(`AgentProfile written to ${fileName}`);
+}
+async function promptToolCall(repl, toolCall) {
+    (0, tools_1.displayToolCall)(toolCall);
+    const response = await repl.run("Approve tool call? (Y/n) ");
+    return response === "y" || response === "yes" || response == "";
+}

package/dist/dummyLLM.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DummyLLM = void 0;
+const assert_1 = require("assert");
+class DummyLLM {
+    constructor(responses) {
+        this.responses = responses;
+        this.idx = 0;
+    }
+    getModel() {
+        return "dummy";
+    }
+    getUrl() {
+        throw "cannot get url for DummyLLM";
+    }
+    async getConversationResponse(_messages, _tools) {
+        await new Promise((r) => setTimeout(r, 0));
+        (0, assert_1.strict)(this.idx < this.responses.length);
+        return {
+            id: "" + this.idx,
+            choices: [this.responses[this.idx++]],
+            created: Date.now(),
+            model: "dummyLlmModel",
+            object: "chat.completion",
+        };
+    }
+}
+exports.DummyLLM = DummyLLM;

package/dist/files.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFileOrUndefined = loadFileOrUndefined;
+exports.loadFileOrStdin = loadFileOrStdin;
+exports.loadImageB64OrUndefined = loadImageB64OrUndefined;
+exports.loadServerUrls = loadServerUrls;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function loadFileOrUndefined(file) {
+    if (file) {
+        return fs.readFileSync(file, { encoding: "utf8" });
+    }
+    return undefined;
+}
+/**
+ * If filename is `-` read everything from stdin and return it.  Otherwise,
+ * load the file and return the content.
+ */
+async function loadFileOrStdin(file) {
+    if (file === "-") {
+        return new Promise((resolve, reject) => {
+            let data = "";
+            process.stdin.setEncoding("utf8");
+            process.stdin.on("data", (chunk) => {
+                data += chunk;
+            });
+            process.stdin.on("end", () => {
+                resolve(data);
+            });
+            process.stdin.on("error", (err) => {
+                reject(err);
+            });
+        });
+    }
+    return fs.readFileSync(file, { encoding: "utf8" });
+}
+function loadImageB64OrUndefined(file) {
+    if (file) {
+        const ext = path.extname(file).slice(1).toLowerCase();
+        const mimeType = {
+            jpg: "image/jpeg",
+            jpeg: "image/jpeg",
+            png: "image/png",
+            gif: "image/gif",
+            svg: "image/svg+xml",
+            webp: "image/webp",
+        }[ext];
+        if (!mimeType) {
+            throw Error(`invalid file extension: ${ext}`);
+        }
+        const fileBuffer = fs.readFileSync(file);
+        const imgB64 = fileBuffer.toString("base64");
+        return `data:${mimeType};base64,${imgB64}`;
+    }
+    return undefined;
+}
+function loadServerUrls(path) {
+    try {
+        const file = fs.readFileSync(path, "utf-8");
+        const urls = JSON.parse(file);
+        // Validate the structure
+        if (typeof urls !== "object" || urls === null) {
+            throw new Error("Invalid server URLs format: must be an object");
+        }
+        // Validate each URL is a string
+        for (const [key, value] of Object.entries(urls)) {
+            if (typeof value !== "string") {
+                throw new Error(`Invalid URL format for server ${key}: must be a string`);
+            }
+        }
+        return urls;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in server URLs file: ${error.message}`);
+        }
+        if (error instanceof Error) {
+            throw new Error(`Failed to load server URLs: ${error.message}`);
+        }
+        throw error;
+    }
+}

package/dist/iplatform.js

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

package/dist/llm.js

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

package/dist/main.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+"use strict";
+// -*- typescript -*-
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const dotenv = __importStar(require("dotenv"));
+const cmd_ts_1 = require("cmd-ts");
+const agent_1 = require("./agent");
+const options_1 = require("./options");
+const files_1 = require("./files");
+const tool_1 = require("@xalia/xmcp/tool");
+const sdk_1 = require("@xalia/xmcp/sdk");
+const agentUtils_1 = require("./agentUtils");
+const chat_1 = require("./chat");
+const nodePlatform_1 = require("./nodePlatform");
+const assert_1 = require("assert");
+dotenv.config();
+const logger = (0, sdk_1.getLogger)();
+const main = (0, cmd_ts_1.command)({
+    name: "main",
+    args: {
+        promptFile: options_1.promptFile,
+        imageFile: options_1.imageFile,
+        openaiApiKey: options_1.openaiApiKey,
+        oneShot: options_1.oneShot,
+        approveTools: options_1.approveTools,
+        approveToolsUpTo: options_1.approveToolsUpTo,
+        sudomcpConfigFile: (0, cmd_ts_1.option)({
+            type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+            long: "sudomcp-config-file",
+            description: "SudoMCP config file (content or file, default: ~/config/..)",
+            env: "SUDOMCP_CONFIG",
+        }),
+        conversationFile: (0, cmd_ts_1.option)({
+            type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+            long: "conversation",
+            description: "Restore conversation (content or file) (see /wc)",
+            env: "CONVERSATION",
+        }),
+        conversationOutputFile: (0, cmd_ts_1.option)({
+            type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+            long: "conversation-output",
+            description: "Save final conversation to file (--one-shot mode)",
+            env: "CONVERSATION_OUTPUT",
+        }),
+        agentProfileFile: (0, cmd_ts_1.option)({
+            type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+            long: "agent-profile",
+            description: "Agent profile (content or filename)",
+            env: "AGENT_PROFILE",
+        }),
+    },
+    handler: async ({ promptFile, imageFile, openaiApiKey, oneShot, approveTools, approveToolsUpTo, sudomcpConfigFile, conversationFile, conversationOutputFile, agentProfileFile, }) => {
+        approveToolsUpTo = (() => {
+            if (typeof approveToolsUpTo === "undefined") {
+                // For the non-interactive case, `--approve-tools` is ignored.
+                if (oneShot) {
+                    return -1;
+                }
+                return approveTools ? -1 : 0;
+            }
+            return approveToolsUpTo;
+        })();
+        (0, assert_1.strict)(typeof approveToolsUpTo === "number");
+        // Load the AgentProfile or use a default
+        const agentProfile = (() => {
+            let agentProfile = tool_1.utils.loadContentOrFileOrUndefined(agentProfileFile, agent_1.AgentProfile);
+            if (!agentProfile) {
+                agentProfile = new agent_1.AgentProfile(undefined, undefined, "You are a helpful agent", {});
+            }
+            return agentProfile;
+        })();
+        logger.debug(`agent config: ${JSON.stringify(agentProfile)}`);
+        // Read sudomcp config file, overriding values from command lines params.
+        const sudomcpConfig = tool_1.configuration.loadEnsureConfig(sudomcpConfigFile);
+        // Restore conversation from value or file.
+        const startingConversation = tool_1.utils.loadContentOrFileOrUndefined(conversationFile);
+        logger.debug(`startingConversation: ${JSON.stringify(startingConversation)}`);
+        // Run in one-shot mode or chat-mode
+        if (oneShot) {
+            if (!promptFile) {
+                throw "one-shot mode requires a prompt";
+            }
+            const prompt = await (0, files_1.loadFileOrStdin)(promptFile);
+            const { response, conversation } = await (0, agentUtils_1.runOneShot)(agentProfile, startingConversation, nodePlatform_1.NODE_PLATFORM, prompt, (0, files_1.loadImageB64OrUndefined)(imageFile), openaiApiKey, sudomcpConfig, approveToolsUpTo);
+            console.log(response);
+            if (conversationOutputFile) {
+                logger.debug(`writing conversation to ${conversationOutputFile}:`);
+                logger.debug(`  conversation: ${JSON.stringify(conversation)}`);
+                fs.writeFileSync(conversationOutputFile, JSON.stringify(conversation));
+            }
+        }
+        else {
+            const prompt = (0, files_1.loadFileOrUndefined)(promptFile);
+            return (0, chat_1.runChat)(agentProfile, startingConversation, prompt, imageFile, openaiApiKey, sudomcpConfig, approveToolsUpTo);
+        }
+    },
+});
+function handleError(msg) {
+    console.error(msg);
+    process.exit(1);
+}
+(0, cmd_ts_1.run)(main, process.argv.slice(2)).catch(handleError);