@harborclient/team-hub 0.2.3 → 0.3.0

package/dist/cli.js

@@ -25,6 +25,35 @@ import path from "path";
 import { parse as parseYaml } from "yaml";
 
 // src/config/llmConfig.ts
+function headerRowsFromSingleKeyObject(record) {
+  const rows = [];
+  for (const [key, value] of Object.entries(record)) {
+    const trimmedKey = key.trim();
+    if (trimmedKey.length > 0) {
+      rows.push({ key: trimmedKey, value: String(value) });
+    }
+  }
+  return rows;
+}
+function normalizeHubMcpHeaders(headers) {
+  if (!headers) {
+    return [];
+  }
+  if (!Array.isArray(headers)) {
+    return headerRowsFromSingleKeyObject(headers);
+  }
+  const rows = [];
+  for (const item of headers) {
+    if (Array.isArray(item)) {
+      for (const nested of item) {
+        rows.push(...headerRowsFromSingleKeyObject(nested));
+      }
+      continue;
+    }
+    rows.push(...headerRowsFromSingleKeyObject(item));
+  }
+  return rows;
+}
 function normalizeLlmConfig(section) {
   const providers = {};
   if (section.providers.openai?.apiKey) {
@@ -36,9 +65,15 @@ function normalizeLlmConfig(section) {
   if (section.providers.gemini?.apiKey) {
     providers.gemini = { apiKey: section.providers.gemini.apiKey };
   }
+  const mcp = section.mcp && section.mcp.length > 0 ? section.mcp.map((entry) => ({
+    name: entry.name.trim(),
+    url: entry.url.trim().replace(/\/+$/, ""),
+    headers: normalizeHubMcpHeaders(entry.headers)
+  })) : void 0;
   return {
     providers,
-    ...section.models && section.models.length > 0 ? { models: section.models } : {}
+    ...section.models && section.models.length > 0 ? { models: section.models } : {},
+    ...mcp && mcp.length > 0 ? { mcp } : {}
   };
 }
 
@@ -116,6 +151,15 @@ var redisSectionSchema = z.object({
 var llmProviderEntrySchema = z.object({
   apiKey: z.string().trim().min(1, { message: "LLM provider apiKey must not be empty." })
 });
+var hubMcpHeadersSchema = z.union([
+  z.record(z.string(), z.string()),
+  z.array(z.union([z.record(z.string(), z.string()), z.array(z.record(z.string(), z.string()))]))
+]);
+var hubMcpServerEntrySchema = z.object({
+  name: z.string().trim().min(1),
+  url: z.string().trim().min(1),
+  headers: hubMcpHeadersSchema.optional()
+});
 var llmSectionSchema = z.object({
   providers: z.object({
     openai: llmProviderEntrySchema.optional(),
@@ -125,7 +169,8 @@ var llmSectionSchema = z.object({
     (providers) => Boolean(providers.openai?.apiKey || providers.claude?.apiKey || providers.gemini?.apiKey),
     { message: "llm.providers must include at least one provider with an apiKey." }
   ),
-  models: z.array(z.string().trim().min(1)).optional()
+  models: z.array(z.string().trim().min(1)).optional(),
+  mcp: z.array(hubMcpServerEntrySchema).optional()
 });
 var pluginsSectionSchema = z.object({
   catalogs: z.array(z.string().trim().url()).optional(),
@@ -6043,6 +6088,12 @@ function canAccessEnvironment(user, environmentId) {
   }
   return user.environmentAccess.includes(environmentId);
 }
+function canDeleteCollection(user, collection) {
+  return canUseDataApi(user) && canAccessCollection(user, collection.id) && collection.createdByUserId === user.id && !collection.deletionLocked;
+}
+function canDeleteRequest(user, request) {
+  return canUseDataApi(user) && canAccessCollection(user, request.collectionId) && request.createdByUserId === user.id;
+}
 function canCreateCollection(user) {
   return user.role === "user" && hasWildcardAccess(user.collectionAccess);
 }
@@ -6718,6 +6769,80 @@ async function registerAdminRoutes(app, options) {
       }
     }
   });
+  routes.route({
+    method: "GET",
+    url: "/admin/collections/:collectionId/folders",
+    schema: {
+      params: collectionIdParamSchema,
+      response: {
+        200: listFoldersResponseSchema,
+        403: errorResponseSchema,
+        404: errorResponseSchema
+      }
+    },
+    /**
+     * Lists folders in a collection for operator inspection.
+     */
+    handler: async (request, reply) => {
+      try {
+        const user = requireAuthenticatedUser(request);
+        if (denyUnlessAllowed(reply, canUseManagementApi(user))) {
+          return;
+        }
+        const collection = await db.findCollectionById(request.params.collectionId);
+        if (!collection) {
+          void reply.code(404).send({ error: "Collection not found" });
+          return;
+        }
+        const folders = await db.listFolders(request.params.collectionId);
+        return reply.send({
+          folders: folders.map((folder) => serializeFolder(folder))
+        });
+      } catch (error) {
+        if (handleDbError(reply, error)) {
+          return;
+        }
+        throw error;
+      }
+    }
+  });
+  routes.route({
+    method: "GET",
+    url: "/admin/collections/:collectionId/requests",
+    schema: {
+      params: collectionIdParamSchema,
+      response: {
+        200: listRequestsResponseSchema,
+        403: errorResponseSchema,
+        404: errorResponseSchema
+      }
+    },
+    /**
+     * Lists saved requests in a collection for operator inspection.
+     */
+    handler: async (request, reply) => {
+      try {
+        const user = requireAuthenticatedUser(request);
+        if (denyUnlessAllowed(reply, canUseManagementApi(user))) {
+          return;
+        }
+        const collection = await db.findCollectionById(request.params.collectionId);
+        if (!collection) {
+          void reply.code(404).send({ error: "Collection not found" });
+          return;
+        }
+        const requests = await db.listRequests(request.params.collectionId);
+        return reply.send({
+          requests: requests.map((savedRequest) => serializeSavedRequest(savedRequest))
+        });
+      } catch (error) {
+        if (handleDbError(reply, error)) {
+          return;
+        }
+        throw error;
+      }
+    }
+  });
   routes.route({
     method: "GET",
     url: "/admin/environments",
@@ -6787,6 +6912,41 @@ async function registerAdminRoutes(app, options) {
       }
     }
   });
+  routes.route({
+    method: "DELETE",
+    url: "/admin/requests/:id",
+    schema: {
+      params: idParamSchema,
+      response: {
+        204: emptyResponseSchema,
+        403: errorResponseSchema,
+        404: errorResponseSchema
+      }
+    },
+    /**
+     * Deletes a saved request regardless of collection access lists.
+     */
+    handler: async (request, reply) => {
+      try {
+        const user = requireAuthenticatedUser(request);
+        if (denyUnlessAllowed(reply, canUseManagementApi(user))) {
+          return;
+        }
+        const existingRequest = await db.findRequestById(request.params.id);
+        if (!existingRequest) {
+          void reply.code(404).send({ error: "Request not found" });
+          return;
+        }
+        await db.deleteRequest(request.params.id, user.id);
+        return reply.code(204).send(null);
+      } catch (error) {
+        if (handleDbError(reply, error)) {
+          return;
+        }
+        throw error;
+      }
+    }
+  });
   routes.route({
     method: "PUT",
     url: "/admin/collections/:id",
@@ -7350,12 +7510,6 @@ async function registerCollectionRoutes(app, db) {
     handler: async (request, reply) => {
       try {
         const user = requireAuthenticatedUser(request);
-        if (denyUnlessAllowed(
-          reply,
-          canUseDataApi(user) && canAccessCollection(user, request.params.id)
-        )) {
-          return;
-        }
         const collection = await db.findCollectionById(request.params.id);
         if (!collection) {
           void reply.code(404).send({ error: "Collection not found" });
@@ -7364,6 +7518,9 @@ async function registerCollectionRoutes(app, db) {
         if (collection.deletionLocked) {
           throw new DeletionLockedError("collection");
         }
+        if (denyUnlessAllowed(reply, canDeleteCollection(user, collection))) {
+          return;
+        }
         await db.deleteCollection(request.params.id, user.id);
         return reply.code(204).send(null);
       } catch (error) {
@@ -7892,10 +8049,7 @@ async function registerRequestRoutes(app, db) {
         if (!existingRequest) {
           return reply.code(404).send({ error: "Request not found" });
         }
-        if (denyUnlessAllowed(
-          reply,
-          canUseDataApi(user) && canAccessCollection(user, existingRequest.collectionId)
-        )) {
+        if (denyUnlessAllowed(reply, canDeleteRequest(user, existingRequest))) {
           return;
         }
         await db.deleteRequest(request.params.id, user.id);
@@ -8107,6 +8261,258 @@ async function runLlmCompletion(config, input) {
   return parseCompletionResponse(json);
 }
 
+// src/server/llm/hubMcpToolNames.ts
+var HUB_MCP_TOOL_PREFIX = "hubmcp__";
+function encodeHubMcpToolName(serverIndex, toolName) {
+  return `${HUB_MCP_TOOL_PREFIX}${serverIndex}__${toolName}`;
+}
+function decodeHubMcpToolName(prefixed) {
+  if (!prefixed.startsWith(HUB_MCP_TOOL_PREFIX)) {
+    return null;
+  }
+  const rest = prefixed.slice(HUB_MCP_TOOL_PREFIX.length);
+  const separatorIndex = rest.indexOf("__");
+  if (separatorIndex <= 0) {
+    return null;
+  }
+  const serverIndex = Number.parseInt(rest.slice(0, separatorIndex), 10);
+  if (!Number.isInteger(serverIndex) || serverIndex < 0) {
+    return null;
+  }
+  const toolName = rest.slice(separatorIndex + 2);
+  if (!toolName) {
+    return null;
+  }
+  return { serverIndex, toolName };
+}
+function isHubMcpToolName(name) {
+  return decodeHubMcpToolName(name) !== null;
+}
+
+// src/server/llm/mcpClient.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+var connectedClients = /* @__PURE__ */ new Map();
+var activeConfigSignature = "";
+function buildRequestHeaders(headers) {
+  const result = {};
+  for (const row of headers) {
+    if (row.key.trim()) {
+      result[row.key.trim()] = row.value;
+    }
+  }
+  return result;
+}
+function buildMcpConfigSignature(config) {
+  return JSON.stringify(config.mcp ?? []);
+}
+function flattenMcpToolContent(content) {
+  if (!Array.isArray(content)) {
+    return JSON.stringify(content ?? null);
+  }
+  const parts = content.map((item) => {
+    if (!item || typeof item !== "object") {
+      return String(item);
+    }
+    const record = item;
+    if (record.type === "text" && typeof record.text === "string") {
+      return record.text;
+    }
+    if (record.type === "resource" && typeof record.uri === "string") {
+      return record.uri;
+    }
+    return JSON.stringify(record);
+  });
+  return parts.join("\n");
+}
+function toOpenAiTool(serverIndex, tool) {
+  return {
+    type: "function",
+    function: {
+      name: encodeHubMcpToolName(serverIndex, tool.name),
+      description: tool.description ?? `MCP tool ${tool.name}`,
+      parameters: tool.inputSchema ?? {
+        type: "object",
+        properties: {},
+        additionalProperties: true
+      }
+    }
+  };
+}
+async function connectHubMcpServer(serverIndex, server) {
+  const headers = buildRequestHeaders(server.headers);
+  const url = new URL(server.url);
+  const client = new Client(
+    {
+      name: "team-hub",
+      version: "1.0.0"
+    },
+    {}
+  );
+  let transport;
+  try {
+    transport = new StreamableHTTPClientTransport(url, {
+      requestInit: { headers }
+    });
+    await client.connect(transport);
+  } catch {
+    transport = new SSEClientTransport(url, {
+      requestInit: { headers }
+    });
+    await client.connect(transport);
+  }
+  const { tools } = await client.listTools();
+  return {
+    serverIndex,
+    client,
+    remoteTools: tools
+  };
+}
+async function ensureHubMcpConnections(config) {
+  const servers = config.mcp ?? [];
+  const signature = buildMcpConfigSignature(config);
+  if (signature !== activeConfigSignature) {
+    await disposeHubMcpConnections();
+    activeConfigSignature = signature;
+  }
+  if (servers.length === 0) {
+    return;
+  }
+  for (const [index, server] of servers.entries()) {
+    if (connectedClients.has(index)) {
+      continue;
+    }
+    try {
+      const connected = await connectHubMcpServer(index, server);
+      connectedClients.set(index, connected);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Connection failed";
+      console.warn(`Hub MCP server "${server.name}" failed to connect: ${message}`);
+    }
+  }
+}
+function listHubMcpTools() {
+  const tools = [];
+  for (const entry of connectedClients.values()) {
+    for (const tool of entry.remoteTools) {
+      tools.push(toOpenAiTool(entry.serverIndex, tool));
+    }
+  }
+  return tools;
+}
+async function callHubMcpTool(prefixedName, args) {
+  const decoded = decodeHubMcpToolName(prefixedName);
+  if (!decoded) {
+    return JSON.stringify({ error: `Unknown hub MCP tool: ${prefixedName}` });
+  }
+  const entry = connectedClients.get(decoded.serverIndex);
+  if (!entry) {
+    return JSON.stringify({ error: `Hub MCP server ${decoded.serverIndex} is not connected.` });
+  }
+  try {
+    const result = await entry.client.callTool({
+      name: decoded.toolName,
+      arguments: args ?? {}
+    });
+    if (result.isError) {
+      return JSON.stringify({
+        error: flattenMcpToolContent(result.content)
+      });
+    }
+    return flattenMcpToolContent(result.content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "MCP tool execution failed.";
+    return JSON.stringify({ error: message });
+  }
+}
+async function disposeHubMcpConnections() {
+  const closePromises = [...connectedClients.values()].map(async (entry) => {
+    try {
+      await entry.client.close();
+    } catch {
+    }
+  });
+  connectedClients.clear();
+  activeConfigSignature = "";
+  await Promise.allSettled(closePromises);
+}
+
+// src/server/llm/agent.ts
+var HUB_CHAT_STEP_MAX_ITERATIONS = 8;
+function addUsage(current, next) {
+  return {
+    promptTokens: current.promptTokens + next.promptTokens,
+    completionTokens: current.completionTokens + next.completionTokens,
+    totalTokens: current.totalTokens + next.totalTokens
+  };
+}
+function parseToolArguments(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function runHubChatStep(config, input, deps = {}) {
+  const runCompletion = deps.runCompletion ?? runLlmCompletion;
+  const ensureConnections = deps.ensureConnections ?? ensureHubMcpConnections;
+  const listTools = deps.listTools ?? listHubMcpTools;
+  const callTool = deps.callTool ?? callHubMcpTool;
+  await ensureConnections(config);
+  const hubTools = listTools();
+  const mergedTools = hubTools.length > 0 || (input.tools?.length ?? 0) > 0 ? [...hubTools, ...input.tools ?? []] : void 0;
+  let messages = [...input.messages];
+  let usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+  let lastContent = null;
+  for (let iteration = 0; iteration < HUB_CHAT_STEP_MAX_ITERATIONS; iteration += 1) {
+    const result = await runCompletion(config, {
+      model: input.model,
+      messages,
+      systemPrompt: input.systemPrompt,
+      tools: mergedTools
+    });
+    usage = addUsage(usage, result.usage);
+    lastContent = result.content;
+    const toolCalls = result.toolCalls ?? [];
+    if (toolCalls.length === 0) {
+      return {
+        content: result.content,
+        usage
+      };
+    }
+    const hubCalls = toolCalls.filter((call) => isHubMcpToolName(call.name));
+    const passthroughCalls = toolCalls.filter((call) => !isHubMcpToolName(call.name));
+    if (passthroughCalls.length > 0) {
+      return {
+        content: result.content,
+        toolCalls: passthroughCalls,
+        usage
+      };
+    }
+    messages = [
+      ...messages,
+      {
+        role: "assistant",
+        content: result.content,
+        tool_calls: hubCalls
+      }
+    ];
+    for (const call of hubCalls) {
+      const toolResult = await callTool(call.name, parseToolArguments(call.arguments));
+      messages.push({
+        role: "tool",
+        tool_call_id: call.id,
+        content: toolResult
+      });
+    }
+  }
+  return {
+    content: lastContent,
+    usage
+  };
+}
+
 // src/server/routes/llm.ts
 function sendMonthlyLimitExceeded(reply) {
   return reply.code(402).send({
@@ -8224,7 +8630,7 @@ async function registerLlmRoutes(app, options) {
       if (isNewTurn && isOverMonthlyLimit(totalTokens, user.llmMonthlyTokenLimit)) {
         return sendMonthlyLimitExceeded(reply);
       }
-      const result = await runLlmCompletion(llm, {
+      const result = await runHubChatStep(llm, {
         model,
         messages,
         tools,
@@ -8716,6 +9122,7 @@ function registerGracefulShutdown(app, ctx) {
   const shutdown = async (signal) => {
     app.log.info(`Received ${signal}, shutting down.`);
     await app.close();
+    await disposeHubMcpConnections();
     await disconnectAll(ctx);
     process.exit(0);
   };