@xalia/agent 1.0.19

package/src/chat.ts

@@ -0,0 +1,325 @@
+import yocto from "yocto-spinner";
+import { Spinner } from "yocto-spinner";
+import * as fs from "fs";
+import { Agent, AgentProfile } from "./agent";
+import { displayToolCall } from "./tools";
+import { McpServerManager } from "./mcpServerManager";
+import OpenAI from "openai";
+import { loadImageB64OrUndefined } from "./files";
+import { Prompt, parsePrompt } from "./prompt";
+import { SudoMcpServerManager } from "./sudoMcpServerManager";
+import chalk from "chalk";
+import { configuration, authenticate } from "@xalia/xmcp/tool";
+import { getLogger, InvalidConfiguration } from "@xalia/xmcp/sdk";
+import { createAgentAndSudoMcpServerManager } from "./agentUtils";
+import { NODE_PLATFORM } from "./nodePlatform";
+
+const logger = getLogger();
+
+export async function runChat(
+  agentProfile: AgentProfile,
+  conversation: OpenAI.ChatCompletionMessageParam[] | undefined,
+  prompt: string | undefined,
+  image: string | undefined,
+  openaiApiKey: string | undefined,
+  sudomcpConfig: configuration.Configuration,
+  approveToolsUpTo: number
+) {
+  // In chat mode, just print the messages.  Ask for tool confirmation
+  // unless approveTools is set.
+
+  const spinner: Spinner = yocto();
+  const onMessage = async (
+    msg: OpenAI.ChatCompletionMessageParam,
+    _msgEnd: boolean
+  ) => {
+    if (msg.content) {
+      if (spinner) {
+        spinner.stop().clear();
+      }
+      console.log(`AGENT: ${msg.content}`);
+    }
+  };
+
+  let remainingApprovedToolCalls = approveToolsUpTo;
+  const onToolCall = async (toolCall: OpenAI.ChatCompletionMessageToolCall) => {
+    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 createAgentAndSudoMcpServerManager(
+      agentProfile,
+      onMessage,
+      onToolCall,
+      NODE_PLATFORM,
+      openaiApiKey,
+      sudomcpConfig,
+      authenticate.FRONTEND_PROD_AUTHORIZED_URL,
+      undefined
+    );
+  if (conversation) {
+    agent.setConversation(conversation);
+  }
+
+  // Opening banner
+  console.log(`${chalk.green("SudoMCP Agent CLI")}`);
+  console.log(
+    `(Type ${chalk.yellow("/h")} for help, ${chalk.yellow("/q")} to quit.)`
+  );
+
+  // Display first prompt if supplied
+  if (prompt) {
+    console.log(`USER: ${prompt}`);
+  }
+
+  const repl = new Prompt();
+
+  // Conversation loop
+  while (true) {
+    if (!prompt) {
+      const [msg, img] = await getNextPrompt(repl, agent, sudoMcpServerManager);
+      if (!msg && !img) {
+        break;
+      }
+      prompt = msg;
+      image = img;
+    }
+
+    image = 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: Prompt,
+  agent: Agent,
+  sudoMcpServerManager: SudoMcpServerManager
+): Promise<[string | undefined, string | undefined]> {
+  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 } = 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: Agent,
+  mcpServerManager: McpServerManager,
+  sudoMcpServerManager: SudoMcpServerManager,
+  cmds: string[]
+) {
+  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.yellow("/lt")}                          List tools: `);
+  console.log(`  ${chalk.yellow("/ls")}                          List servers`);
+  console.log(`  ${chalk.yellow("/as <server-name>")}            Add server`);
+  console.log(
+    `  ${chalk.yellow("/rs <server-name>")}            Remove server`
+  );
+  console.log(`  ${chalk.yellow("/e <server-name> <tool-name>")} Enable tool`);
+  console.log(`  ${chalk.yellow("/d <server-name> <tool-name>")} Disable tool`);
+  console.log(
+    `  ${chalk.yellow("/ea <server-name>")}            Enable all tools`
+  );
+  console.log(
+    `  ${chalk.yellow("/da <server-name>")}            Disable all tools`
+  );
+  console.log(
+    `  ${chalk.yellow("/wc <file-name>")}              Write conversation file`
+  );
+  console.log(
+    `  ${chalk.yellow("/wa <file-name>")}              Write agent profile file`
+  );
+
+  console.log(`  ${chalk.yellow("/q")}                           Quit`);
+}
+
+function listTools(mcpServerManager: 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.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: 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.green(brief.name)}: ${brief.description}`);
+  }
+}
+
+/**
+ * Adds server and enables all tools.
+ */
+async function addServer(
+  sudoMcpServerManager: SudoMcpServerManager,
+  serverName: string
+) {
+  const sudoMcpConfig = configuration.loadEnsureConfig();
+  const config = sudoMcpConfig
+    ? sudoMcpConfig.getConfigForServer(serverName)
+    : {};
+  try {
+    await sudoMcpServerManager.addMcpServer(serverName, config);
+  } catch (e) {
+    if (e instanceof 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: Agent, fileName: string) {
+  const conversation = agent.getConversation();
+  fs.writeFileSync(fileName, JSON.stringify(conversation), {
+    encoding: "utf8",
+  });
+  console.log(`Conversation written to ${fileName}`);
+}
+
+function writeAgentProfile(agent: Agent, fileName: string) {
+  const profile = agent.getAgentProfile();
+  fs.writeFileSync(fileName, JSON.stringify(profile));
+  console.log(`AgentProfile written to ${fileName}`);
+}
+
+async function promptToolCall(
+  repl: Prompt,
+  toolCall: OpenAI.ChatCompletionMessageToolCall
+): Promise<boolean> {
+  displayToolCall(toolCall);
+  const response = await repl.run("Approve tool call? (Y/n) ");
+  return response === "y" || response === "yes" || response == "";
+}

package/src/dummyLLM.ts

@@ -0,0 +1,36 @@
+import { ILLM } from "./llm";
+import { OpenAI } from "openai";
+import { strict as assert } from "assert";
+
+export class DummyLLM implements ILLM {
+  private readonly responses: OpenAI.Chat.Completions.ChatCompletion.Choice[];
+  private idx: number;
+
+  constructor(responses: OpenAI.Chat.Completions.ChatCompletion.Choice[]) {
+    this.responses = responses;
+    this.idx = 0;
+  }
+
+  public getModel(): string {
+    return "dummy";
+  }
+
+  public getUrl(): string {
+    throw "cannot get url for DummyLLM";
+  }
+
+  public async getConversationResponse(
+    _messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[],
+    _tools?: OpenAI.Chat.Completions.ChatCompletionTool[]
+  ): Promise<OpenAI.Chat.Completions.ChatCompletion> {
+    await new Promise((r) => setTimeout(r, 0));
+    assert(this.idx < this.responses.length);
+    return {
+      id: "" + this.idx,
+      choices: [this.responses[this.idx++]],
+      created: Date.now(),
+      model: "dummyLlmModel",
+      object: "chat.completion",
+    };
+  }
+}

package/src/files.ts

@@ -0,0 +1,95 @@
+import * as fs from "fs";
+import * as path from "path";
+import { McpServerUrls } from "./agent";
+
+export function loadFileOrUndefined(
+  file: string | undefined
+): string | undefined {
+  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.
+ */
+export async function loadFileOrStdin(file: string): Promise<string> {
+  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" });
+}
+
+export function loadImageB64OrUndefined(
+  file: string | undefined
+): string | undefined {
+  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;
+}
+
+export function loadServerUrls(path: string): McpServerUrls {
+  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 as McpServerUrls;
+  } 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/src/iplatform.ts

@@ -0,0 +1,11 @@
+/**
+ * Per-platform services that the agent and related classes can use.
+ */
+export interface IPlatform {
+  /**
+   * Open the browser (or a new tab) at some URL.
+   */
+  openUrl(url: string): void;
+
+  load(filename: string): Promise<string>;
+}

package/src/llm.ts

@@ -0,0 +1,12 @@
+import { OpenAI } from "openai";
+
+export interface ILLM {
+  getModel(): string;
+
+  getUrl(): string;
+
+  getConversationResponse(
+    messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[],
+    tools?: OpenAI.Chat.Completions.ChatCompletionTool[]
+  ): Promise<OpenAI.Chat.Completions.ChatCompletion>;
+}

package/src/main.ts

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+// -*- typescript -*-
+
+import * as fs from "fs";
+import * as dotenv from "dotenv";
+import { run, command, option, optional, string } from "cmd-ts";
+import { AgentProfile } from "./agent";
+import {
+  openaiApiKey,
+  promptFile,
+  oneShot,
+  approveTools,
+  approveToolsUpTo,
+  imageFile,
+} from "./options";
+import OpenAI from "openai";
+import {
+  loadFileOrUndefined,
+  loadFileOrStdin,
+  loadImageB64OrUndefined,
+} from "./files";
+import { configuration, utils } from "@xalia/xmcp/tool";
+import { getLogger } from "@xalia/xmcp/sdk";
+import { runOneShot } from "./agentUtils";
+import { runChat } from "./chat";
+import { NODE_PLATFORM } from "./nodePlatform";
+import { strict as assert } from "assert";
+
+dotenv.config();
+
+const logger = getLogger();
+
+const main = command({
+  name: "main",
+  args: {
+    promptFile,
+    imageFile,
+    openaiApiKey,
+    oneShot,
+    approveTools,
+    approveToolsUpTo,
+    sudomcpConfigFile: option({
+      type: optional(string),
+      long: "sudomcp-config-file",
+      description:
+        "SudoMCP config file (content or file, default: ~/config/..)",
+      env: "SUDOMCP_CONFIG",
+    }),
+    conversationFile: option({
+      type: optional(string),
+      long: "conversation",
+      description: "Restore conversation (content or file) (see /wc)",
+      env: "CONVERSATION",
+    }),
+    conversationOutputFile: option({
+      type: optional(string),
+      long: "conversation-output",
+      description: "Save final conversation to file (--one-shot mode)",
+      env: "CONVERSATION_OUTPUT",
+    }),
+    agentProfileFile: option({
+      type: optional(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,
+  }): Promise<void> => {
+    approveToolsUpTo = (() => {
+      if (typeof approveToolsUpTo === "undefined") {
+        // For the non-interactive case, `--approve-tools` is ignored.
+        if (oneShot) {
+          return -1;
+        }
+        return approveTools ? -1 : 0;
+      }
+      return approveToolsUpTo;
+    })();
+    assert(typeof approveToolsUpTo === "number");
+
+    // Load the AgentProfile or use a default
+
+    const agentProfile: AgentProfile = (() => {
+      let agentProfile = utils.loadContentOrFileOrUndefined(
+        agentProfileFile,
+        AgentProfile
+      );
+      if (!agentProfile) {
+        agentProfile = new 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 = configuration.loadEnsureConfig(sudomcpConfigFile);
+
+    // Restore conversation from value or file.
+
+    const startingConversation:
+      | OpenAI.ChatCompletionMessageParam[]
+      | undefined = 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 loadFileOrStdin(promptFile);
+
+      const { response, conversation } = await runOneShot(
+        agentProfile,
+        startingConversation,
+        NODE_PLATFORM,
+        prompt,
+        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 = loadFileOrUndefined(promptFile);
+      return runChat(
+        agentProfile,
+        startingConversation,
+        prompt,
+        imageFile,
+        openaiApiKey,
+        sudomcpConfig,
+        approveToolsUpTo
+      );
+    }
+  },
+});
+
+function handleError(msg: string) {
+  console.error(msg);
+  process.exit(1);
+}
+
+run(main, process.argv.slice(2)).catch(handleError);