@xalia/agent 0.5.7 → 0.6.0

package/src/chat/server.ts

@@ -1,177 +0,0 @@
-#!/usr/bin/env node
-// -*- typescript -*-
-
-import type * as supabase from "../../../supabase/database.types";
-import * as dotenv from "dotenv";
-import { getLogger } from "@xalia/xmcp/sdk";
-import * as ws from "ws";
-import { IncomingMessage } from "http";
-import { parse } from "url";
-import { ConversationManager } from "./conversationManager";
-import { Database, UserData, resolveCompoundName } from "./db";
-import { ApiKeyManager } from "./apiKeyManager";
-import { ParsedUrlQuery } from "querystring";
-
-dotenv.config();
-
-const logger = getLogger();
-
-/**
- * Try as id, then by user/name and return the AgentProfile uuid.
- */
-async function resolveAgentProfileId(
-  db: Database,
-  userData: UserData,
-  agentProfileIdentifier: string
-): Promise<string | undefined> {
-  let ap = await db.getSavedAgentProfileById(agentProfileIdentifier);
-  logger.debug(`[resolveAgentProfileId]: by id: {JSON.stringify(ap)}`);
-  if (ap) {
-    return agentProfileIdentifier;
-  }
-
-  ap = await db.getSavedAgentProfileByName(
-    userData.uuid,
-    agentProfileIdentifier
-  );
-  logger.debug(`[resolveAgentProfileId]: by name: {JSON.stringify(ap)}`);
-  if (ap) {
-    return ap.uuid;
-  }
-
-  logger.debug("[resolveAgentProfileId]: agent profile not found");
-  return undefined;
-}
-
-async function resolveSessionIdFromIdentifier(
-  db: Database,
-  userData: UserData,
-  sessionIdentifier: string
-): Promise<string | undefined> {
-  let session: supabase.Tables<"sessions"> | undefined = undefined;
-  const compound = resolveCompoundName(sessionIdentifier);
-  if (typeof compound === "string") {
-    // Interpret as an id, or as a number under the current user.
-    session = await db.getSessionById(compound);
-    if (!session) {
-      session = await db.getSessionByName(userData.uuid, compound);
-    }
-  } else {
-    session = await db.getSessionByName(compound[0], compound[1]);
-  }
-
-  return session?.uuid;
-}
-
-/**
- * Expect parameters to be either:
- *   session_id                  - uuid, name, user/name
- *   agent_profile_id (optional) - uuid, name
- *
- * If session_idd resolves to an existing session, it is used (and
- * agent_profile_id is ignored).  Otherwise, session_id is used as the name of
- * a new session to create using `agent_profile_id`.  The session UUID is
- * returned in either case.
- */
-async function findOrCreateSession(
-  db: Database,
-  userData: UserData,
-  query: ParsedUrlQuery
-): Promise<string | undefined> {
-  logger.debug(`[findOrCreateSession]: query: ${JSON.stringify(query)}`);
-  if (!query.session_id || typeof query.session_id !== "string") {
-    throw "session_id invalid or not present";
-  }
-
-  const sessionId = await resolveSessionIdFromIdentifier(
-    db,
-    userData,
-    query.session_id
-  );
-  if (sessionId) {
-    return sessionId;
-  }
-
-  const agentProfileIdParam = query.agent_profile_id;
-  logger.debug(`[findOrCreateSession]: agent: ${agentProfileIdParam}`);
-  if (!agentProfileIdParam) {
-    throw "no existing session, and no agent_profile_id given";
-  }
-  if (typeof agentProfileIdParam !== "string") {
-    throw "no existing session and invalid agent_profile_id";
-  }
-
-  logger.debug(`[findOrCreateSession]: creating session: ${query.session_id}`);
-  const agentProfileId = await resolveAgentProfileId(
-    db,
-    userData,
-    agentProfileIdParam
-  );
-  logger.debug(
-    `[findOrCreateSession]: resolved agentProfileId: ${agentProfileId}`
-  );
-  if (!agentProfileId) {
-    throw `no agent profile: ${agentProfileIdParam}`;
-  }
-
-  return db.createSession(userData.uuid, query.session_id, agentProfileId);
-}
-
-export async function runServer(
-  port: number,
-  supabaseUrl: string,
-  supabaseKey: string,
-  llmUrl: string,
-  xmcpUrl: string
-): Promise<ws.Server> {
-  return new Promise((r, _e) => {
-    const wss = new ws.Server({ port });
-    const db = new Database(supabaseUrl, supabaseKey);
-    const apiKeyManager = new ApiKeyManager(db);
-    const cm = new ConversationManager(db, llmUrl, xmcpUrl);
-
-    wss.on("connection", async (ws: ws.WebSocket, req: IncomingMessage) => {
-      try {
-        logger.info(`[server] connection: ${req}`);
-
-        // Check header
-
-        logger.info(`[server] headers: ${JSON.stringify(req.headers)}`);
-        const apiKey = req.headers["sec-websocket-protocol"];
-        if (!apiKey) {
-          throw "empty api key";
-        }
-
-        const userData = await apiKeyManager.verifyApiKey(apiKey);
-        if (!userData) {
-          throw "invalid api key";
-        }
-
-        // Get sessionId
-
-        const { query } = parse(req.url || "", true);
-        const sessionId = await findOrCreateSession(db, userData, query);
-        logger.debug(`resolved session id: ${sessionId}`);
-        if (!sessionId) {
-          throw "failed to find/create session";
-        }
-
-        // Associate the ws, username with the conversation
-
-        await cm.join(sessionId, apiKey, apiKey, userData, ws);
-      } catch (e) {
-        if (typeof e === "string") {
-          logger.warn(`[server]: error: ${e}`);
-          ws.close(4000, e);
-        } else {
-          logger.error(`other error: ${JSON.stringify(e)}`);
-          throw e;
-        }
-      }
-    });
-
-    logger.info(`[server] started: ws://localhost:${port}/`);
-
-    r(wss);
-  });
-}