@xalia/agent 0.5.0

package/dist/sudoMcpServerManager.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SudoMcpServerManager = exports.LOCAL_SERVER_URL = void 0;
+const sdk_1 = require("@xalia/xmcp/sdk");
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const logger = (0, sdk_1.getLogger)();
+exports.LOCAL_SERVER_URL = "http://localhost:5001";
+/**
+ * ServerBrief with sanitized name, and original name in another field.
+ */
+class SanitizedServerBrief extends sdk_1.McpServerBrief {
+    constructor() {
+        super("dummy", "dummy", "dummy", false, {}, "dummy", "dummy");
+        this.originalName = "dummy";
+    }
+    static fromServerBrief(brief) {
+        const b = brief;
+        const origName = brief.name;
+        b.originalName = origName; // eslint-disable-line
+        brief.name = sanitizeName(origName);
+        return b;
+    }
+}
+/**
+ * Manages access to the catalogue of servers hosted by sudomcp.  Supports
+ * adding these servers to McpServerManager.
+ */
+class SudoMcpServerManager {
+    constructor(mcpServerManager, apiClient, serverBriefs, serverBriefsMap, toolCache, openUrl, 
+    // Redirect to this page after successful authorization
+    authorized_url) {
+        this.mcpServerManager = mcpServerManager;
+        this.apiClient = apiClient;
+        this.serverBriefs = serverBriefs;
+        this.serverBriefsMap = serverBriefsMap;
+        this.toolCache = toolCache;
+        this.openUrl = openUrl;
+        this.authorized_url = authorized_url;
+    }
+    /**
+     * Initialize an ApiClient to interface with SudoMCP backend and
+     * fetch the current list of ServerBriefs.
+     */
+    static async initialize(mcpServerManager, openUrl, sudoMcpUrl, sudoMcpApiKey, authorized_url) {
+        // TODO: Keep it on here and pass to `McpServerManager.addMcpServer`
+        const apiClient = new sdk_1.ApiClient(sudoMcpUrl ?? sdk_1.DEFAULT_SERVER_URL, sudoMcpApiKey ?? "dummy_key");
+        // Fetch server list
+        const servers = await apiClient.listServers();
+        const [mcpServers, mcpServersMap] = buildServersList(servers);
+        return new SudoMcpServerManager(mcpServerManager, apiClient, mcpServers, mcpServersMap, {}, openUrl, authorized_url);
+    }
+    /// TODO: Bit awkward that we have to restore via this class, but it's the
+    /// only class which knows how to restore (restart) the mcp servers.
+    async restoreMcpSettings(mcpSettings) {
+        await this.restoreConfiguration(mcpSettings);
+    }
+    /**
+     * Load the configuration from sudomcp, and enable the specified tools.
+     */
+    async restoreConfiguration(mcpConfig) {
+        logger.debug("Restoring Mcp config");
+        // Concurrently establish all server connections
+        const addServer = async (serverName) => {
+            logger.debug(`restoring ${serverName} ...`);
+            return this.addMcpServer(serverName);
+        };
+        await Promise.all(Object.entries(mcpConfig).map((e) => addServer(e[0])));
+        // Enable tools
+        const enableTools = ([serverName, enabled]) => {
+            // Migrate the old style: { [tool: string]: true } to the new list format
+            if (!(enabled instanceof Array)) {
+                enabled = Object.keys(enabled);
+            }
+            if (enabled.length === 0) {
+                logger.debug(` restoring "${serverName}": (all tools)`);
+                this.mcpServerManager.enableAllTools(serverName);
+                return;
+            }
+            logger.debug(` restoring "${serverName}": ${JSON.stringify(enabled)}`);
+            for (const toolName of enabled) {
+                this.mcpServerManager.enableTool(serverName, toolName);
+            }
+        };
+        Object.entries(mcpConfig).map((e) => enableTools(e));
+    }
+    /**
+     * Query backend for server list, clear tool cache.
+     */
+    async refresh() {
+        const servers = await this.apiClient.listServers();
+        const [mcpServers, mcpServersMap] = buildServersList(servers);
+        this.serverBriefs = mcpServers;
+        this.serverBriefsMap = mcpServersMap;
+        this.toolCache = {};
+    }
+    getServerBriefs() {
+        return this.serverBriefs;
+    }
+    getMcpServerManager() {
+        return this.mcpServerManager;
+    }
+    /**
+     * Return tool list for a given MCP server. Queries the backend
+     * if necessary and caches the result.
+     */
+    async getServerTools(serverName) {
+        // Check cache
+        let tools = this.toolCache[serverName];
+        if (tools) {
+            return tools;
+        }
+        // Query backend (using the original name)
+        const originalName = this.serverBriefsMap[serverName].originalName;
+        tools = await this.apiClient.listTools(originalName);
+        this.toolCache[serverName] = tools;
+        return tools;
+    }
+    /**
+     * Add a server to the `McpServerManager`, using `ApiClient`
+     * to produce the transport. Validates the server's config
+     * schema, if applicable.
+     */
+    async addMcpServer(serverName) {
+        const tools = await this.getServerTools(serverName);
+        const originalName = this.serverBriefsMap[serverName].originalName;
+        const mcpserver = await this.apiClient.getDetails(originalName, "run");
+        const client = new index_js_1.Client({
+            name: "@xalia/agent",
+            version: "1.0.0",
+        });
+        await connectServer(client, this.apiClient, mcpserver, this.openUrl, this.authorized_url);
+        await this.mcpServerManager.addMcpServerWithClient(client, serverName, tools);
+    }
+    getOriginalName(serverName) {
+        return this.serverBriefsMap[serverName].name;
+    }
+    getApiClient() {
+        return this.apiClient;
+    }
+}
+exports.SudoMcpServerManager = SudoMcpServerManager;
+/**
+ * Connect a client to a hosted MCP server session,
+ * prompting for authentication if needed.
+ */
+async function connectServer(client, apiClient, mcpServer, openUrl, authorized_url, noRetry = false) {
+    const transport = apiClient.mcpSession(mcpServer);
+    await client.connect(transport).catch(async (e) => {
+        if (e instanceof sdk_1.AuthenticationRequired && !noRetry) {
+            logger.info("authentication required: " + e.msg);
+            const { url, authenticatedP } = await apiClient.authenticate(mcpServer.name, authorized_url);
+            logger.info(`authenticate at url: ${url}`);
+            openUrl(url, authenticatedP, mcpServer.title);
+            const authResult = await authenticatedP;
+            logger.info(`authResult: ${authResult}`);
+            if (!authResult) {
+                throw "authentication failed";
+            }
+            return connectServer(client, apiClient, mcpServer, openUrl, authorized_url, true);
+        }
+        else {
+            throw e;
+        }
+    });
+}
+/**
+ * Given a list of`ServerBrief` objects, create the corresponding list and map
+ * of `SantiizedServerBrief` objects (namely, objects with sanitized names,
+ * holding the original name in a new field).
+ */
+function buildServersList(serverList) {
+    const servers = [];
+    const serversMap = {};
+    for (const s of serverList) {
+        const ss = SanitizedServerBrief.fromServerBrief(s);
+        servers.push(ss);
+        serversMap[ss.name] = ss;
+    }
+    return [servers, serversMap];
+}
+function sanitizeName(name) {
+    return name.replace("/", "_");
+}

package/dist/test/imageLoad.test.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const files_1 = require("../files");
+const assert_1 = require("assert");
+describe("Image loading", () => {
+    it("convert to data url", async function () {
+        const imageB64 = (0, files_1.loadImageB64OrUndefined)("frog.png");
+        // console.log(`imageB64: ${imageB64}`);
+        (0, chai_1.expect)(imageB64).to.be.a("string");
+        (0, assert_1.strict)(typeof imageB64 === "string");
+        (0, chai_1.expect)(imageB64.startsWith("data:image/png;base64")).eql(true);
+    });
+});

package/dist/test/mcpServerManager.test.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mcpServerManager_1 = require("../mcpServerManager");
+// Handle automatically closing at the end of tests.
+let managers = {};
+let idx = 0;
+function getMcpServerManager() {
+    const tm = new mcpServerManager_1.McpServerManager();
+    const name = "mgr" + ++idx;
+    managers[name] = tm;
+    return tm;
+}
+async function shutdownAll() {
+    for (const [k, v] of Object.entries(managers)) {
+        console.log(`shutting down ${k}`);
+        await v.shutdown();
+    }
+    managers = {};
+}
+describe("McpServerManager", async () => {
+    it("should initialize with correct descriptions", async () => {
+        const tm = getMcpServerManager();
+        await tm.addMcpServer("simplecalc", "http://localhost:5001/mcpservers/sudomcp/simplecalc/session", "dummy_key");
+        const server = tm.getMcpServer("simplecalc");
+        const availableTools = server.getTools();
+        (0, chai_1.expect)(availableTools.length).greaterThan(0);
+        // Initially, no tools are enabled.
+        (0, chai_1.expect)(tm.getOpenAITools().length).equal(0);
+        // Enable a tool and check we get a description for it.
+        const toolName = availableTools[0].name;
+        {
+            tm.enableTool("simplecalc", toolName);
+            const tools = tm.getOpenAITools();
+            (0, chai_1.expect)(tools.length).greaterThan(0);
+            console.log(`tools: ${JSON.stringify(tools, undefined, 2)}`);
+        }
+        // Invoke
+        {
+            const qualifiedName = tm.getOpenAITools()[0].function.name;
+            const r = await tm.invoke(qualifiedName, { a: 1000, b: 10 });
+            console.log(`response: ${r}`);
+        }
+        // Disable and check we don't get the spec anymore
+        {
+            tm.disableTool("simplecalc", toolName);
+            const tools = tm.getOpenAITools();
+            (0, chai_1.expect)(tools.length).equal(0);
+        }
+    }).timeout(10000);
+    it("qualified names", async () => {
+        const serverName = "server";
+        const toolName = "tool";
+        const qualifiedName = (0, mcpServerManager_1.computeQualifiedName)(serverName, toolName);
+        const [_serverName, _toolName] = (0, mcpServerManager_1.splitQualifiedName)(qualifiedName);
+        (0, chai_1.expect)(_serverName).eql(serverName);
+        (0, chai_1.expect)(_toolName).eql(toolName);
+    });
+    it("add / remove servers", async () => {
+        const tm = getMcpServerManager();
+        await tm.addMcpServer("simplecalc", "http://localhost:5001/mcpservers/sudomcp/simplecalc/session", "dummy_key");
+        tm.enableAllTools("simplecalc");
+        (0, chai_1.expect)(tm.getOpenAITools().length).greaterThan(0);
+        // Remove server and check there is no server, and no openai entries.
+        await tm.removeMcpServer("simplecalc");
+        (0, chai_1.expect)(tm.getOpenAITools().length).equal(0);
+        (0, chai_1.expect)(() => {
+            tm.getMcpServer("simplecalc");
+        }).throws();
+    });
+}).afterAll(shutdownAll);

package/dist/test/prompt.test.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const prompt_1 = require("../prompt");
+describe("Prompt", () => {
+    it("should recognise commands", async function () {
+        const expectedResults = {
+            "some text  ": { msg: "some text", cmds: undefined },
+            ":i image.png some text": { msg: "some text", cmds: ["i", "image.png"] },
+            ":i image.png": { msg: undefined, cmds: ["i", "image.png"] },
+            ":l": { msg: undefined, cmds: ["l"] },
+            ":e serverName toolName": {
+                msg: undefined,
+                cmds: ["e", "serverName", "toolName"],
+            },
+            ":ea serverName": {
+                msg: undefined,
+                cmds: ["ea", "serverName"],
+            },
+        };
+        for (const [prompt, expected] of Object.entries(expectedResults)) {
+            const res = (0, prompt_1.parsePrompt)(prompt);
+            (0, chai_1.expect)(res).eql(expected);
+        }
+    });
+});

package/dist/test/sudoMcpServerManager.test.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyPrintTool = prettyPrintTool;
+const chai_1 = require("chai");
+const mcpServerManager_1 = require("../mcpServerManager");
+const sudoMcpServerManager_1 = require("../sudoMcpServerManager");
+const chalk_1 = __importDefault(require("chalk"));
+let managers = undefined;
+async function getServerManagers() {
+    if (!managers) {
+        const tm = new mcpServerManager_1.McpServerManager();
+        const sm = await sudoMcpServerManager_1.SudoMcpServerManager.initialize(tm, (_url) => {
+            throw "unexpected call to openUrl";
+        }, sudoMcpServerManager_1.LOCAL_SERVER_URL, "dummy_key");
+        managers = [tm, sm];
+    }
+    return managers;
+}
+async function shutdownAll() {
+    if (managers) {
+        await managers[0].shutdown();
+    }
+    managers = undefined;
+}
+describe("SudoMcpServerManager", async () => {
+    it("should fetch servers from deployed backend", async () => {
+        const [, sm] = await getServerManagers();
+        const serverBriefs = sm.getServerBriefs();
+        (0, chai_1.expect)(serverBriefs.length).greaterThan(0);
+    }).timeout(10000);
+    it("should fetch tools for a server", async () => {
+        const [, sm] = await getServerManagers();
+        const tools = await sm.getServerTools("sudomcp_simplecalc");
+        (0, chai_1.expect)(tools.length).greaterThan(0);
+    }).timeout(10000);
+    it("should add a new MCP server", async () => {
+        const [, sm] = await getServerManagers();
+        await sm.addMcpServer("sudomcp_simplecalc");
+        const serverBriefs = sm.getServerBriefs();
+        (0, chai_1.expect)(serverBriefs.some((brief) => brief.name === "sudomcp_simplecalc")).eql(true);
+    }).timeout(20000);
+}).afterAll(shutdownAll);
+function prettyPrintTool(tool) {
+    console.log(`- ${chalk_1.default.green(tool.name)}:`);
+    console.log(`  ${chalk_1.default.italic(tool.description)}\n`);
+}

package/dist/tokenAuth.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenAuth = void 0;
+class TokenAuth {
+    constructor(token) {
+        this.token = token;
+    }
+    get redirectUrl() {
+        throw "unimpl";
+    }
+    get clientMetadata() {
+        throw "unimpl";
+    }
+    clientInformation() {
+        return undefined;
+    }
+    saveClientInformation(_clientInformation) {
+        throw "unimpl";
+    }
+    tokens() {
+        return {
+            access_token: this.token,
+            token_type: "bearer",
+        };
+    }
+    saveTokens(_tokens) {
+        throw "unimpl";
+    }
+    redirectToAuthorization(_authorizationUrl) {
+        throw "unimpl";
+    }
+    saveCodeVerifier(_codeVerifier) {
+        throw "unimpl";
+    }
+    codeVerifier() {
+        throw "unimpl";
+    }
+}
+exports.TokenAuth = TokenAuth;

package/dist/tools.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolCallbacks = exports.temperatureTool = void 0;
+exports.displayToolCall = displayToolCall;
+exports.temperatureTool = {
+    type: "function",
+    function: {
+        name: "getCurrentTemperature",
+        description: "Get the current temperature for a specific location",
+        parameters: {
+            type: "object",
+            properties: {
+                location: {
+                    type: "string",
+                    description: "The city and state, e.g., San Francisco, CA",
+                },
+                unit: {
+                    type: "string",
+                    enum: ["Celsius", "Fahrenheit"],
+                    description: "The temperature unit to use. Infer this from the user's location.",
+                },
+            },
+            required: ["location", "unit"],
+        },
+    },
+};
+function isTemperatureArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        ("location" in args || "unit" in args));
+}
+// Handle non-MCP tools
+exports.toolCallbacks = {
+    getCurrentTemperature: (args) => {
+        if (!isTemperatureArgs(args) || !args.location) {
+            return `Location required`;
+        }
+        return `The temperature in ${args.location} is 22 degrees ${args.unit}`;
+    },
+};
+function displayToolCall(toolCall) {
+    console.log(`AGENT: Tool Call: ${toolCall.function.name}`);
+    console.log(`       Args: ${toolCall.function.arguments}`);
+}

package/eslint.config.mjs

@@ -0,0 +1,25 @@
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  tseslint.configs.recommended,
+  {
+    "rules": {
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          "args": "all",
+          "argsIgnorePattern": "^_",
+          "caughtErrors": "all",
+          "caughtErrorsIgnorePattern": "^_",
+          "destructuredArrayIgnorePattern": "^_",
+          "varsIgnorePattern": "^_",
+          "ignoreRestSiblings": true
+        }
+      ],
+      "max-len": ["error", { code: 80 }],
+      "linebreak-style": ["error", "unix"]
+    }
+  }
+);

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@xalia/agent",
+  "version": "0.5.0",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "bin": {
+    "agent": "dist/main.js"
+  },
+  "scripts": {
+    "build": "tsc && node -e \"require('fs').chmodSync('dist/main.js', '755')\"",
+    "lint": "eslint src && yarn prettier --check src/**/*.ts",
+    "format": "yarn prettier --write src/**/*.ts",
+    "test": "yarn --emoji false build && mocha dist/test/**.js --reporter-option maxDiffSize=0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "=1.11.1",
+    "@types/readline-sync": "^1.4.8",
+    "chalk": "^4.1.2",
+    "cmd-ts": "^0.13.0",
+    "dotenv": "^16.5.0",
+    "openai": "=4.98.0",
+    "readline-sync": "^1.4.10",
+    "yocto-spinner": "^0.2.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.24.0",
+    "@types/chai": "^4.0.0",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.13.9",
+    "chai": "^4.0.0",
+    "eslint": "^9.24.0",
+    "mocha": "^11.1.0",
+    "prettier": "3.5.3",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.29.1"
+  }
+}

package/scripts/git_message

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+
+this_dir=`dirname ${BASH_SOURCE[0]}`
+this_dir=`realpath ${this_dir}`
+client=${this_dir}/../dist/main.js
+
+prompt=/tmp/git_message_prompt.txt
+msg=/tmp/git_message.txt
+
+while [[ "$#" -gt 0 ]]; do
+  case "$1" in
+    -n) dry_run=1 ;;
+    *) echo "Unknown parameter: $1" ; exit 1 ;;
+  esac
+  shift
+done
+
+# Create prompt
+echo "Create the commit message for the following diff:" > ${prompt}
+git diff --no-ext-diff --cached -U6 >> ${prompt}
+
+${client} -1 \
+          --agent-profile ${this_dir}/../test_data/git_message_profile.json \
+          --prompt ${prompt} > ${msg}
+
+# Use as commit message
+if [ -z ${dry_run} ] ; then
+    git commit -e -F ${msg}
+else
+    cat ${msg}
+fi

package/scripts/git_wip

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+this_dir=`dirname ${BASH_SOURCE[0]}`
+this_dir=`realpath ${this_dir}`
+client=${this_dir}/../dist/main.js
+
+prompt=/tmp/git_wip_prompt.txt
+
+# Create prompt
+echo "Below are my WIP diffs:" > ${prompt}
+git diff HEAD --no-ext-diff -U6 >> ${prompt}
+num_lines=`cat ${prompt} | wc -l`
+if [ "1" == ${num_lines} ] ; then
+    echo Using last commit
+    git show -U6 >> ${prompt}
+fi
+
+${client} -y -1 -q \
+          --sysprompt ${this_dir}/../test_data/git_wip_system.txt \
+          --prompt ${prompt} | pbcopy
+pbpaste

package/scripts/pr_message

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+this_dir=`dirname ${BASH_SOURCE[0]}`
+this_dir=`realpath ${this_dir}`
+client=${this_dir}/../dist/main.js
+
+prompt=/tmp/pr_message_prompt.txt
+msg=/tmp/pr_message.txt
+
+
+# Create prompt
+echo "Create the PR message for the following commits:" > ${prompt}
+git log origin/master..HEAD >> ${prompt}
+
+${client} -1 \
+          --agent-profile ${this_dir}/../test_data/pr_message_profile.json \
+          --prompt ${prompt} | tee ${msg}
+cat ${msg} | pbcopy

package/scripts/pr_review

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+this_dir=`dirname ${BASH_SOURCE[0]}`
+this_dir=`realpath ${this_dir}`
+client=${this_dir}/../dist/main.js
+
+prompt=/tmp/pr_review_prompt.txt
+
+
+# Create prompt
+echo "Review the following PR diff:" > ${prompt}
+git log -p -U10 origin/master..HEAD >> ${prompt}
+
+${client} -1 \
+          --agent-profile ${this_dir}/../test_data/pr_review_profile.json \
+          --prompt ${prompt}

package/scripts/sudomcp_import

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+# set -x
+# set -e
+
+this_dir=`dirname ${BASH_SOURCE[0]}`
+this_dir=`realpath ${this_dir}`
+client=${this_dir}/../dist/main.js
+
+if [ -z "$1" ] ; then
+    echo "Usage: $0 <url>"
+    exit 1
+fi
+
+prompt=/tmp/sudomcp_import_prompt.txt
+
+# Create prompt
+echo "Create the sudomcp yaml spec for the MCP at url: $1" \
+     > ${prompt}
+
+${client} -1 \
+    --agent-profile ${this_dir}/../test_data/sudomcp_import_profile.json \
+    --prompt ${prompt}

package/scripts/test_script

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+
+. env/bin/activate
+make dev-setup
+
+# Build client
+
+pushd ../client
+yarn
+yarn build
+client=`realpath dist/src/tool/main.js`
+popd
+
+# Build agent
+yarn
+yarn build
+agent=`realpath dist/main.js`
+
+set -x
+set -e
+
+# Start server
+
+pushd ../mcppro
+
+function stop_server() {
+    if [ -e sudomcp.pid ] ; then
+         kill `cat sudomcp.pid` || echo -n
+    fi
+}
+
+if [ -z ${NO_START} ] ; then
+    stop_server
+    make start-dev > server.log 2>&1 &
+    sleep 5
+fi
+
+[ -n "${URL}" ] || URL=http://localhost:5001
+
+# enable agent logging
+export LOG_LEVEL=DEBUG
+LOG_FILE="agent.log"
+rm -f $LOG_FILE && touch $LOG_FILE
+export LOG_FILE=`realpath $LOG_FILE`
+
+# list mcp servers
+${client} config -f --dev --server-url ${URL}
+${client} server list
+
+if [ -z ${NO_START} ] ; then
+    stop_server
+    # cat server.log
+fi
+
+set +e
+set +x
+
+echo "=============================="
+echo "==  MCP Agent TEST PASSED   =="
+echo "=============================="