@xalia/agent 0.5.8 → 0.6.0

package/src/tool/chatMain.ts

@@ -1,12 +1,6 @@
-import {
-  command,
-  optional,
-  option,
-  flag,
-  string,
-  number,
-  subcommands,
-} from "cmd-ts";
+/* eslint-disable @typescript-eslint/only-throw-error */
+
+import { command, optional, option, string, number, subcommands } from "cmd-ts";
 import { stdout } from "process";
 import * as fs from "fs";
 import { strict as assert } from "assert";
@@ -14,22 +8,105 @@ import { strict as assert } from "assert";
 import { configuration } from "@xalia/xmcp/tool";
 import { getLogger } from "@xalia/xmcp/sdk";
 
-import { IConversation } from "../agent/agent";
-import { ChatClient } from "../chat/client";
-import { runServer } from "../chat/server";
 import {
-  ClientUserMessage,
+  ChatClient,
+  SessionClient,
+  IChatClientEventHandler,
+} from "../chat/client";
+import {
+  runServer,
+  resolveSessionIdFromIdentifier,
+} from "../chat/server/server";
+import {
   ServerToClient,
   decodeAssistantMessageParam,
-} from "../chat/messages";
+} from "../chat/protocol/messages";
 
 import { IPrompt, Prompt, ScriptPrompt } from "./prompt";
 import * as options from "./options";
 import { CommandPrompt } from "./commandPrompt";
 import { NODE_PLATFORM } from "./nodePlatform";
+import { Database, createSessionParticipantMap } from "../chat/data/database";
+import { loadImageB64 } from "./files";
 
 const logger = getLogger();
 
+const listSessions = command({
+  name: "delete-session",
+  args: {
+    supabaseUrl: options.supabaseUrl,
+    supabaseKey: options.supabaseKey,
+  },
+  handler: async ({ supabaseUrl, supabaseKey }): Promise<void> => {
+    const db = new Database(supabaseUrl, supabaseKey);
+    console.log(JSON.stringify(await db.sessionsGet()));
+  },
+});
+
+const clearSessions = command({
+  name: "clear-sessions",
+  args: {
+    supabaseUrl: options.supabaseUrl,
+    supabaseKey: options.supabaseKey,
+  },
+  handler: async ({ supabaseUrl, supabaseKey }): Promise<void> => {
+    const db = new Database(supabaseUrl, supabaseKey);
+    await db.clearSessions();
+  },
+});
+
+const deleteSession = command({
+  name: "delete-session",
+  args: {
+    supabaseUrl: options.supabaseUrl,
+    supabaseKey: options.supabaseKey,
+    session: option({
+      type: string,
+      long: "session",
+      description:
+        "Session identifier (id, name, user/name or name of new session)",
+      env: "SESSION",
+    }),
+  },
+  handler: async ({ supabaseUrl, supabaseKey, session }): Promise<void> => {
+    const db = new Database(supabaseUrl, supabaseKey);
+    const sessionId = await resolveSessionIdFromIdentifier(db, session);
+    if (sessionId) {
+      await db.sessionDeleteById(sessionId);
+    } else {
+      throw `No such session ${session}`;
+    }
+  },
+});
+
+const listParticipants = command({
+  name: "list-participants",
+  args: {
+    supabaseUrl: options.supabaseUrl,
+    supabaseKey: options.supabaseKey,
+    session: option({
+      type: string,
+      long: "session",
+      description:
+        "Session identifier (id, name, user/name or name of new session)",
+      env: "SESSION",
+    }),
+  },
+  handler: async ({ supabaseUrl, supabaseKey, session }): Promise<void> => {
+    const db = new Database(supabaseUrl, supabaseKey);
+    const sessionId = await resolveSessionIdFromIdentifier(db, session);
+    if (sessionId) {
+      const participants = await db.sessionGetParticipants(sessionId);
+
+      console.log(`participants: ${JSON.stringify(participants)}`);
+      const users = createSessionParticipantMap(participants);
+      console.log(JSON.stringify(users));
+    } else {
+      throw `No such session ${session}`;
+    }
+  },
+});
+
 const server = command({
   name: "server",
   args: {
@@ -46,6 +123,7 @@ const server = command({
     xmcpUrl: options.xmcpUrl,
     pidFile: options.pidFile,
   },
+  // eslint-disable-next-line @typescript-eslint/require-await
   handler: async ({
     port,
     supabaseUrl,
@@ -58,58 +136,61 @@ const server = command({
       fs.writeFileSync(pidFile, process.pid.toString());
     }
 
-    runServer(port, supabaseUrl, supabaseKey, llmUrl, xmcpUrl);
+    void runServer(port, supabaseUrl, supabaseKey, llmUrl, xmcpUrl);
   },
 });
 
 const client = command({
   name: "client",
   args: {
-    host: option({
+    url: option({
       type: string,
-      long: "host",
+      long: "url",
       short: "h",
-      env: "CHAT_SERVER_HOST",
-      defaultValue: () => "localhost",
-    }),
-    port: option({
-      type: number,
-      long: "port",
-      short: "p",
-      env: "CHAT_SERVER_PORT",
-      defaultValue: () => 5003,
+      env: "CHAT_URL",
+      description: "Chat server url",
+      defaultValue: () => "ws://localhost:5003",
     }),
     apiKey: options.apiKey,
-    session: option({
-      type: string,
-      long: "session",
-      description: "Session identifier (id, name, user/name)",
-      env: "SESSION",
+    sessionId: option({
+      type: optional(string),
+      long: "session-id",
+      description: "Join existing session with the given UUID",
+      env: "SESSION_UUID",
+    }),
+    teamId: option({
+      type: optional(string),
+      long: "team-id",
+      description:
+        "Team uuid, if not provided, a user session will be created.",
+      env: "TEAM_ID",
     }),
-    agentProfile: option({
+    agentProfileId: option({
       type: optional(string),
-      long: "agent-profile",
-      description: "Create new session using agent profile (id, name)",
-      env: "AGENT_PROFILE",
+      long: "agent-profile-id",
+      description: "Create new session with agent profile (uuid)",
+      env: "AGENT_PROFILE_ID",
+    }),
+    sessionTitle: option({
+      type: optional(string),
+      long: "session-title",
+      description: "Title for new session",
+      env: "SESSION_TITLE",
     }),
     script: option({
       type: optional(string),
       long: "script",
       description: "Script (file) to execute and then exit.",
     }),
-    test: flag({
-      long: "test",
-      description: "Run a test client and disconnect",
-    }),
   },
   handler: async ({
-    host,
-    port,
+    url,
     apiKey,
-    session,
-    agentProfile,
+    sessionId,
+    agentProfileId,
+    sessionTitle,
+    teamId,
     script,
-    test,
   }): Promise<void> => {
     if (!apiKey) {
       // TODO: configFIle param list in ../main.ts
@@ -117,12 +198,6 @@ const client = command({
       apiKey = sudomcpConfig.api_key;
     }
 
-    if (test) {
-      await runClientTest(host, port, apiKey, session);
-      return;
-    }
-
-    const onMessage = getCLIOnMessage();
     const repl: IPrompt = (() => {
       if (script) {
         const scriptLines = fs.readFileSync(script, "utf8").split("\n");
@@ -132,40 +207,87 @@ const client = command({
     })();
     const cmdPrompt = new CommandPrompt(repl);
 
-    const client = await ChatClient.init(
-      host,
-      port,
-      apiKey,
-      onMessage,
-      async () => await cmdPrompt.shutdown(),
-      NODE_PLATFORM,
-      session,
-      agentProfile
-    );
+    const eventHandler = getCLIEventHandler(cmdPrompt);
+
+    const [client, sessionClient] = await (async () => {
+      const newClient = await ChatClient.init(url, apiKey, eventHandler);
+      if (sessionId) {
+        if (agentProfileId || sessionTitle) {
+          throw "t agent-profile-id/session-title set joining existing session";
+        }
 
+        console.log(`joining existing session: ${sessionId} ...`);
+        const newSessionClient = await newClient.connectToSession(sessionId);
+        return [newClient, newSessionClient];
+      }
+
+      const newSessionClient = await newClient.createNewSession(
+        sessionTitle || "New Chat",
+        agentProfileId,
+        teamId
+      );
+      return [newClient, newSessionClient];
+    })();
     logger.debug("client created");
 
+    const onUnknownCommand = (cmds: string[]) => {
+      switch (cmds[0]) {
+        case "aa":
+          sessionClient.setAutoApproval(cmds[1], cmds[2], !!cmds[3]);
+          break;
+        case "error":
+          sessionClient.sendMessage({ type: "fatal_error", message: cmds[1] });
+          break;
+        case "ap": // Add Participant
+        case "au":
+          client.addTeamMember(cmds[1], cmds[2]);
+          break;
+        case "rp": // Remove Participant
+        case "ru":
+          client.removeTeamMember(cmds[1], cmds[2]);
+          break;
+        case "lp": // List Participants
+        case "lu":
+          console.log(JSON.stringify(sessionClient.getParticipants()));
+          break;
+        case "si": // Write Session id to file
+          fs.writeFileSync(cmds[1], sessionClient.getSessionUUID());
+          break;
+        case "ct": // Create Team
+          client.createNewTeam(cmds[1], []);
+          break;
+        case "ci": // Write team id to file
+          fs.writeFileSync(cmds[1], client.getCurrentTeamId() ?? "");
+          break;
+        case "sw": // Set workspace
+          setWorkspaceFromPrompt(sessionClient, cmds);
+          break;
+        default:
+          console.log(`error: Unknown command ${cmds[0]}`);
+      }
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     while (true) {
       const [msgText, imageFile] = await cmdPrompt.getNextPrompt(
-        undefined as unknown as IConversation, // TODO: client
-        client.getSudoMcpServerManager()
+        sessionClient,
+        sessionClient.getSudoMcpServerManager(),
+        onUnknownCommand
       );
       assert(imageFile === undefined);
 
       if (msgText === undefined) {
         logger.debug("exiting...");
-        client.close();
+        logger.info("exiting...");
+        client.shutdown();
         return;
       }
 
       // TODO: other prompts
 
       if (msgText.length > 0) {
-        const msg: ClientUserMessage = {
-          type: "msg",
-          message: msgText,
-        };
-        client.sendMessage(msg);
+        logger.debug(`sending message: ${msgText}`);
+        sessionClient.userMessage(msgText);
       } else {
         logger.debug("(ignoring empty message)");
       }
@@ -173,12 +295,66 @@ const client = command({
   },
 });
 
-function getCLIOnMessage(): (msg: ServerToClient) => void {
+function setWorkspaceFromPrompt(
+  sessionClient: SessionClient,
+  cmds: string[]
+): void {
+  let msg = "";
+  let image = undefined;
+  if (!cmds[1]) {
+    sessionClient.setWorkspace(undefined, undefined);
+    return;
+  }
+  if (cmds[1].startsWith("file:")) {
+    image = loadImageB64(cmds[1].slice(5));
+    msg = cmds.slice(2).join(" ");
+    console.log(`setting workspace: ${msg} (image: ${image})`);
+  } else {
+    msg = cmds.slice(1).join(" ");
+    console.log(`setting workspace: ${msg}`);
+  }
+
+  sessionClient.setWorkspace(msg, image);
+}
+
+function getCLIEventHandler(
+  cmdPrompt?: CommandPrompt
+): IChatClientEventHandler {
+  let numErrors = 0;
+
+  const onClosed = async () => {
+    logger.debug("[onClosed]");
+    if (cmdPrompt) {
+      // TODO: check if this fully shuts down
+      await cmdPrompt.shutdown();
+    }
+
+    // If there have been errors, exit with an error code.
+    process.exit(numErrors);
+  };
+
+  const onError = (message: string) => {
+    numErrors++;
+    logger.debug("[onError]");
+    console.error(message);
+  };
+
   let startMsg = true;
-  return (msg: ServerToClient) => {
+  const onMessage = async (msg: ServerToClient, client: ChatClient) => {
+    let sessionClient: SessionClient | undefined = undefined;
+    try {
+      sessionClient = client.getCurrentSession("[chatMain.onMessage]");
+    } catch (error) {
+      logger.error(String(error));
+      return;
+    }
+
     switch (msg.type) {
       case "user_msg":
-        stdout.write(`[${msg.from}]: ${msg.message}\n`);
+        stdout.write(`[${msg.user_uuid}]: ${msg.message || ""}\n`);
+        if (msg.imageB64) {
+          stdout.write(`[${msg.user_uuid}]: IMAGE: ${msg.imageB64}\n`);
+        }
         break;
       case "agent_msg":
         {
@@ -199,40 +375,43 @@ function getCLIOnMessage(): (msg: ServerToClient) => void {
           startMsg = true;
         }
         break;
+      case "approve_tool_call":
+        {
+          const result = cmdPrompt
+            ? await cmdPrompt.promptToolCall(msg.tool_call)
+            : true;
+          logger.debug(`cmdPrompt.promptToolCall returned: ${String(result)}`);
+          sessionClient.toolCallApprovalResult(
+            msg.id,
+            result,
+            false /*  auto-approve */
+          );
+        }
+        break;
+      case "render_html":
+        await NODE_PLATFORM.renderHTML(msg.html);
+        break;
+      case "authenticate":
+        NODE_PLATFORM.openUrl(
+          msg.url,
+          new Promise<boolean>((r) => {
+            r(true);
+          }),
+          msg.display_name
+        );
+        break;
+
       default:
-        stdout.write(`(unrecognised) ${JSON.stringify(msg)}\n`);
+        stdout.write(`(unrecognised) ${JSON.stringify(msg.type)}\n`);
         break;
     }
   };
-}
 
-async function runClientTest(
-  host: string,
-  port: number,
-  apiKey: string,
-  session: string
-): Promise<void> {
-  const client = await ChatClient.init(
-    host,
-    port,
-    apiKey,
-    getCLIOnMessage(),
-    async () => {},
-    NODE_PLATFORM,
-    session
-  );
-
-  for (let i = 1; i <= 60; i++) {
-    await new Promise((r) => setTimeout(r, 1000));
-
-    const message: ClientUserMessage = {
-      type: "msg",
-      message: `add ${i} and ${i + 1}`,
-    };
-    client.sendMessage(message);
-  }
-
-  client.close();
+  return {
+    onMessage,
+    onError,
+    onClosed: onClosed,
+  };
 }
 
 export const chatMain = subcommands({
@@ -240,5 +419,9 @@ export const chatMain = subcommands({
   cmds: {
     server,
     client,
+    "clear-sessions": clearSessions,
+    "delete-session": deleteSession,
+    "list-sessions": listSessions,
+    "list-participants": listParticipants,
   },
 });

package/src/tool/commandPrompt.ts

@@ -11,6 +11,8 @@ import { IMcpServerManager } from "../agent/mcpServerManager";
 
 import { IPrompt } from "./prompt";
 
+type OnUnknownCommand = (cmds: string[]) => void;
+
 /**
  * A prompt parser which can accept commands or messages from an IPrompt.
  * Commands are sent to an IMcpServerManager, ISkillManager and IConversation.
@@ -28,8 +30,10 @@ export class CommandPrompt {
 
   async getNextPrompt(
     agent: IConversation,
-    sudoMcpServerManager: ISkillManager
+    sudoMcpServerManager: ISkillManager,
+    onUnknownCommand?: OnUnknownCommand
   ): Promise<[string | undefined, string | undefined]> {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     while (true) {
       // Get a line, detecting the EOF signal.
       const line = await this.prompt.run();
@@ -64,9 +68,14 @@ export class CommandPrompt {
       }
 
       try {
-        await this.runCommand(agent, sudoMcpServerManager, cmds);
+        await this.runCommand(
+          agent,
+          sudoMcpServerManager,
+          cmds,
+          onUnknownCommand
+        );
       } catch (e) {
-        console.log(`ERROR: ${e}`);
+        console.log(`ERROR: ${String(e)}`);
       }
     }
   }
@@ -74,7 +83,8 @@ export class CommandPrompt {
   async runCommand(
     agent: IConversation,
     sudoMcpServerManager: ISkillManager,
-    cmds: string[]
+    cmds: string[],
+    onUnknownCommand?: OnUnknownCommand
   ) {
     switch (cmds[0]) {
       case "lt":
@@ -117,7 +127,11 @@ export class CommandPrompt {
         this.helpMenu();
         break;
       default:
-        console.log(`error: Unknown command ${cmds[0]}`);
+        if (onUnknownCommand) {
+          onUnknownCommand(cmds);
+        } else {
+          console.log(`error: Unknown command ${cmds[0]}`);
+        }
     }
   }
 
@@ -147,7 +161,7 @@ export class CommandPrompt {
       const tools = server.getTools();
       const enabled = server.getEnabledTools();
       for (const tool of tools) {
-        const isEnabled = enabled[tool.name] ? "*" : " ";
+        const isEnabled = enabled.get(tool.name) ? "*" : " ";
         console.log(`  [${isEnabled}] ${tool.name}`);
       }
     }
@@ -171,8 +185,8 @@ export class CommandPrompt {
       await sudoMcpServerManager.addMcpServer(serverName, true);
     } catch (e) {
       if (e instanceof InvalidConfiguration) {
-        throw `${e}. \n
-Have you installed server ${serverName} using the SudoMCP CLI tool?`;
+        throw new Error(`${e.msg}. \n
+Have you installed server ${serverName} using the SudoMCP CLI tool?`);
       } else {
         throw e;
       }
@@ -201,7 +215,9 @@ Have you installed server ${serverName} using the SudoMCP CLI tool?`;
   ): Promise<boolean> {
     displayToolCall(toolCall);
     const response = await this.prompt.run("Approve tool call? (Y/n) ");
-    return response === "y" || response === "yes" || response == "";
+    return (
+      response?.toLowerCase() === "y" || response === "yes" || response == ""
+    );
   }
 }
 

package/src/tool/files.ts

@@ -23,7 +23,7 @@ export async function loadFileOrStdin(file: string): Promise<string> {
       process.stdin.setEncoding("utf8");
 
       process.stdin.on("data", (chunk) => {
-        data += chunk;
+        data += chunk.toString();
       });
 
       process.stdin.on("end", () => {
@@ -39,26 +39,30 @@ export async function loadFileOrStdin(file: string): Promise<string> {
   return fs.readFileSync(file, { encoding: "utf8" });
 }
 
+export function loadImageB64(file: string): string {
+  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}`;
+}
+
 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 loadImageB64(file);
   }
   return undefined;
 }
@@ -66,7 +70,7 @@ export function loadImageB64OrUndefined(
 export function loadServerUrls(path: string): McpServerUrls {
   try {
     const file = fs.readFileSync(path, "utf-8");
-    const urls = JSON.parse(file);
+    const urls: unknown = JSON.parse(file);
 
     // Validate the structure
     if (typeof urls !== "object" || urls === null) {
@@ -74,7 +78,9 @@ export function loadServerUrls(path: string): McpServerUrls {
     }
 
     // Validate each URL is a string
-    for (const [key, value] of Object.entries(urls)) {
+    for (const [key, value] of Object.entries(
+      urls as Record<string, unknown>
+    )) {
       if (typeof value !== "string") {
         throw new Error(
           `Invalid URL format for server ${key}: must be a string`