@lobu/gateway 3.0.5 → 3.0.7

package/src/routes/internal/files.ts

@@ -0,0 +1,226 @@
+#!/usr/bin/env bun
+
+import { Readable } from "node:stream";
+import { createLogger } from "@lobu/core";
+import { Hono } from "hono";
+import type { PlatformRegistry } from "../../platform";
+import type { IFileHandler } from "../../platform/file-handler";
+import { authenticateWorker } from "./middleware";
+import type { WorkerContext } from "./types";
+
+const logger = createLogger("file-routes");
+
+/**
+ * Resolve the file handler for a given platform from the registry.
+ */
+function resolveFileHandler(
+  platformRegistry: PlatformRegistry,
+  platformName?: string
+): IFileHandler | null {
+  if (!platformName) return null;
+  const platform = platformRegistry.get(platformName);
+  return platform?.getFileHandler?.() ?? null;
+}
+
+/**
+ * Create internal file routes (Hono)
+ */
+export function createFileRoutes(
+  platformRegistry: PlatformRegistry
+): Hono<WorkerContext> {
+  const router = new Hono<WorkerContext>();
+
+  /**
+   * Download file endpoint for workers
+   * GET /download?fileId=xxx
+   */
+  router.get("/download", authenticateWorker, async (c) => {
+    try {
+      const fileId = c.req.query("fileId");
+      const worker = c.get("worker");
+
+      if (!fileId) {
+        return c.json({ error: "Missing fileId parameter" }, 400);
+      }
+
+      const fileHandler = resolveFileHandler(platformRegistry, worker.platform);
+      if (!fileHandler) {
+        return c.json(
+          {
+            error: `No file handler available for platform ${worker.platform || "unknown"}`,
+          },
+          501
+        );
+      }
+
+      logger.info(
+        `Worker downloading file ${fileId} for conversation ${worker.conversationId}`
+      );
+
+      // Each platform's file handler manages its own authentication internally
+      const { stream, metadata } = await fileHandler.downloadFile(fileId);
+
+      c.header("Content-Type", metadata.mimetype || "application/octet-stream");
+      c.header("Content-Length", metadata.size.toString());
+      c.header(
+        "Content-Disposition",
+        `attachment; filename="${metadata.name}"`
+      );
+
+      // Convert Node stream to web stream
+      const webStream = new ReadableStream({
+        start(controller) {
+          stream.on("data", (chunk: Buffer) => controller.enqueue(chunk));
+          stream.on("end", () => controller.close());
+          stream.on("error", (err: Error) => controller.error(err));
+        },
+      });
+
+      return new Response(webStream, {
+        headers: c.res.headers,
+      });
+    } catch (error) {
+      logger.error("Failed to download file:", error);
+      return c.json({ error: "Failed to download file" }, 500);
+    }
+  });
+
+  /**
+   * Upload file endpoint for workers
+   * POST /upload
+   */
+  router.post("/upload", authenticateWorker, async (c) => {
+    try {
+      const worker = c.get("worker");
+      const channelId = c.req.header("x-channel-id");
+      const conversationId = c.req.header("x-conversation-id");
+      const voiceMessage = c.req.header("x-voice-message") === "true";
+
+      if (!channelId || !conversationId) {
+        return c.json({ error: "Missing channel or conversation ID" }, 400);
+      }
+
+      const fileHandler = resolveFileHandler(platformRegistry, worker.platform);
+      if (!fileHandler) {
+        return c.json(
+          {
+            error: `No file handler available for platform ${worker.platform || "unknown"}`,
+          },
+          501
+        );
+      }
+
+      const formData = await c.req.formData();
+      const file = formData.get("file") as File | null;
+
+      if (!file) {
+        return c.json({ error: "No file provided" }, 400);
+      }
+
+      const filename = (formData.get("filename") as string) || file.name;
+      const initialComment = formData.get("comment") as string | null;
+
+      logger.info(
+        `Worker uploading file ${filename} via ${worker.platform || "unknown"} for conversation ${worker.conversationId} to conversation ${conversationId}${voiceMessage ? " as voice message" : ""}`
+      );
+
+      const arrayBuffer = await file.arrayBuffer();
+      const fileStream = Readable.from(Buffer.from(arrayBuffer));
+
+      const result = await fileHandler.uploadFile(fileStream, {
+        filename,
+        channelId,
+        threadTs: conversationId,
+        initialComment: initialComment || undefined,
+        voiceMessage,
+      });
+
+      logger.info(`File uploaded successfully: ${result.fileId}`);
+
+      return c.json({
+        success: true,
+        fileId: result.fileId,
+        permalink: result.permalink,
+        name: result.name,
+        size: result.size,
+      });
+    } catch (error) {
+      logger.error("Failed to upload file:", error);
+      return c.json({ error: "Failed to upload file" }, 500);
+    }
+  });
+
+  /**
+   * Batch upload endpoint for multiple files
+   * POST /upload-batch
+   */
+  router.post("/upload-batch", authenticateWorker, async (c) => {
+    try {
+      const worker = c.get("worker");
+      const channelId = c.req.header("x-channel-id");
+      const conversationId = c.req.header("x-conversation-id");
+
+      if (!channelId || !conversationId) {
+        return c.json({ error: "Missing channel or conversation ID" }, 400);
+      }
+
+      const fileHandler = resolveFileHandler(platformRegistry, worker.platform);
+      if (!fileHandler) {
+        return c.json(
+          {
+            error: `No file handler available for platform ${worker.platform || "unknown"}`,
+          },
+          501
+        );
+      }
+
+      const formData = await c.req.formData();
+      const fileEntries = formData.getAll("files");
+
+      if (!fileEntries || fileEntries.length === 0) {
+        return c.json({ error: "No files provided" }, 400);
+      }
+
+      logger.info(
+        `Worker uploading ${fileEntries.length} files for conversation ${worker.conversationId}`
+      );
+
+      const uploadPromises = fileEntries.map(async (entry, index) => {
+        if (!(entry instanceof File)) {
+          throw new Error(`Entry ${index} is not a file`);
+        }
+
+        const filename = entry.name;
+        const arrayBuffer = await entry.arrayBuffer();
+        const fileStream = Readable.from(Buffer.from(arrayBuffer));
+
+        return fileHandler.uploadFile(fileStream, {
+          filename,
+          channelId,
+          threadTs: conversationId,
+        });
+      });
+
+      const uploadResults = await Promise.allSettled(uploadPromises);
+
+      const results = uploadResults.map((result, index) => {
+        if (result.status === "fulfilled") {
+          return { success: true, ...result.value };
+        } else {
+          logger.error(`Failed to upload file ${index}:`, result.reason);
+          return {
+            success: false,
+            error: result.reason?.message || "Upload failed",
+          };
+        }
+      });
+
+      return c.json({ results });
+    } catch (error) {
+      logger.error("Failed to batch upload files:", error);
+      return c.json({ error: "Failed to batch upload files" }, 500);
+    }
+  });
+
+  return router;
+}

package/src/routes/internal/history.ts

@@ -0,0 +1,69 @@
+#!/usr/bin/env bun
+
+import { createLogger } from "@lobu/core";
+import { Hono } from "hono";
+import { platformRegistry } from "../../platform";
+import { authenticateWorker } from "./middleware";
+import type { WorkerContext } from "./types";
+
+const logger = createLogger("history-routes");
+
+/**
+ * Create internal history routes (Hono)
+ * Provides channel history to workers via MCP tool
+ */
+export function createHistoryRoutes(): Hono<WorkerContext> {
+  const router = new Hono<WorkerContext>();
+
+  /**
+   * Get channel history
+   * GET /history?platform=slack&channelId=xxx&conversationId=xxx&limit=50&before=timestamp
+   */
+  router.get("/history", authenticateWorker, async (c) => {
+    try {
+      const worker = c.get("worker");
+      const platform = c.req.query("platform") || worker.platform || "api";
+      const channelId = c.req.query("channelId") || worker.channelId;
+      const conversationId =
+        c.req.query("conversationId") || worker.conversationId;
+      const limitStr = c.req.query("limit") || "50";
+      const before = c.req.query("before"); // ISO timestamp cursor
+
+      const limit = Math.min(Math.max(parseInt(limitStr, 10) || 50, 1), 100);
+
+      if (!channelId) {
+        return c.json({ error: "Missing channelId parameter" }, 400);
+      }
+
+      logger.info(`Fetching history for ${platform}/${channelId}`, {
+        conversationId,
+        limit,
+        before,
+      });
+
+      const platformAdapter = platformRegistry.get(platform);
+      if (platformAdapter?.getConversationHistory) {
+        const response = await platformAdapter.getConversationHistory(
+          channelId,
+          conversationId,
+          limit,
+          before
+        );
+        return c.json(response);
+      }
+
+      return c.json({
+        messages: [],
+        nextCursor: null,
+        hasMore: false,
+      });
+    } catch (error) {
+      logger.error(
+        `Failed to fetch history: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return c.json({ error: "Internal server error" }, 500);
+    }
+  });
+
+  return router;
+}

package/src/routes/internal/images.ts

@@ -0,0 +1,127 @@
+/**
+ * Internal Image Routes
+ *
+ * Worker-facing endpoints for image generation.
+ */
+
+import { createLogger } from "@lobu/core";
+import { Hono } from "hono";
+import type { ImageGenerationService } from "../../services/image-generation-service";
+import { authenticateWorker } from "./middleware";
+import type { WorkerContext } from "./types";
+
+const logger = createLogger("internal-image-routes");
+
+export function createImageRoutes(
+  imageGenerationService: ImageGenerationService
+): Hono<WorkerContext> {
+  const router = new Hono<WorkerContext>();
+
+  /**
+   * Generate an image from prompt text
+   * POST /internal/images/generate
+   */
+  router.post("/internal/images/generate", authenticateWorker, async (c) => {
+    try {
+      const worker = c.get("worker");
+      const { prompt, size, quality, background, format } = await c.req.json<{
+        prompt?: string;
+        size?: "1024x1024" | "1024x1536" | "1536x1024" | "auto";
+        quality?: "low" | "medium" | "high" | "auto";
+        background?: "transparent" | "opaque" | "auto";
+        format?: "png" | "jpeg" | "webp";
+      }>();
+
+      if (!prompt || typeof prompt !== "string") {
+        return c.json(
+          { error: "prompt is required and must be a string" },
+          400
+        );
+      }
+      if (prompt.length > 4000) {
+        return c.json({ error: "prompt must be 4000 characters or less" }, 400);
+      }
+
+      const agentId = worker.agentId;
+      if (!agentId) {
+        return c.json({ error: "Missing agentId in worker context" }, 400);
+      }
+
+      logger.info("Generating image", {
+        agentId,
+        promptLength: prompt.length,
+        size,
+        quality,
+        background,
+        format,
+      });
+
+      const result = await imageGenerationService.generate(prompt, agentId, {
+        size,
+        quality,
+        background,
+        format,
+      });
+      if ("error" in result) {
+        return c.json(
+          {
+            error: result.error,
+            availableProviders: result.availableProviders,
+          },
+          400
+        );
+      }
+
+      return new Response(result.imageBuffer, {
+        headers: {
+          "Content-Type": result.mimeType,
+          "Content-Length": result.imageBuffer.length.toString(),
+          "X-Image-Provider": result.provider,
+        },
+      });
+    } catch (error) {
+      logger.error("Image generation error", { error });
+      return c.json(
+        {
+          error: "Failed to generate image",
+        },
+        500
+      );
+    }
+  });
+
+  /**
+   * Check image generation capabilities for current agent
+   * GET /internal/images/capabilities
+   */
+  router.get("/internal/images/capabilities", authenticateWorker, async (c) => {
+    try {
+      const worker = c.get("worker");
+      const agentId = worker.agentId;
+      if (!agentId) {
+        return c.json({ error: "Missing agentId in worker context" }, 400);
+      }
+
+      const config = await imageGenerationService.getConfig(agentId);
+      if (!config) {
+        return c.json({
+          available: false,
+          features: { generation: false },
+          providers: imageGenerationService.getProviderInfo(),
+        });
+      }
+
+      return c.json({
+        available: true,
+        provider: config.provider,
+        features: { generation: true },
+      });
+    } catch (error) {
+      logger.error("Image capabilities check error", { error });
+      return c.json({ error: "Failed to check capabilities" }, 500);
+    }
+  });
+
+  logger.debug("Internal image routes registered");
+  return router;
+}

package/src/routes/internal/interactions.ts

@@ -0,0 +1,84 @@
+#!/usr/bin/env bun
+
+import { createLogger } from "@lobu/core";
+import { Hono } from "hono";
+import type { InteractionService } from "../../interactions";
+import { authenticateWorker } from "./middleware";
+import type { WorkerContext } from "./types";
+
+const logger = createLogger("internal-interaction-routes");
+
+/**
+ * Create internal interaction routes (Hono)
+ */
+export function createInteractionRoutes(
+  interactionService: InteractionService
+): Hono<WorkerContext> {
+  const router = new Hono<WorkerContext>();
+
+  /**
+   * Post a question with button options (non-blocking)
+   * POST /internal/interactions/create
+   */
+  router.post(
+    "/internal/interactions/create",
+    authenticateWorker,
+    async (c) => {
+      try {
+        const worker = c.get("worker");
+        const { userId, conversationId, channelId, teamId, connectionId } =
+          worker;
+        const { question, options } = await c.req.json();
+
+        logger.info(`Posting question for conversation ${conversationId}`);
+
+        const posted = await interactionService.postQuestion(
+          userId,
+          conversationId,
+          channelId,
+          teamId,
+          connectionId,
+          question,
+          options || []
+        );
+
+        return c.json({ id: posted.id, status: "posted" });
+      } catch (error) {
+        logger.error("Failed to post question:", error);
+        return c.json({ error: "Failed to post question" }, 500);
+      }
+    }
+  );
+
+  /**
+   * Create non-blocking suggestions
+   * POST /internal/suggestions/create
+   */
+  router.post("/internal/suggestions/create", authenticateWorker, async (c) => {
+    try {
+      const worker = c.get("worker");
+      const { userId, conversationId, channelId, teamId } = worker;
+      const { prompts } = await c.req.json();
+
+      logger.info(
+        `Sending suggestions to conversation ${conversationId} (${prompts.length} prompts)`
+      );
+
+      await interactionService.createSuggestion(
+        userId,
+        conversationId,
+        channelId,
+        teamId,
+        prompts
+      );
+
+      return c.json({ success: true });
+    } catch (error) {
+      logger.error("Failed to send suggestions:", error);
+      return c.json({ error: "Failed to send suggestions" }, 500);
+    }
+  });
+
+  logger.debug("Internal interaction routes registered");
+  return router;
+}

package/src/routes/internal/middleware.ts

@@ -0,0 +1,23 @@
+import { verifyWorkerToken } from "@lobu/core";
+
+/**
+ * Shared worker authentication middleware for internal routes.
+ * Verifies the Bearer token from the Authorization header and sets
+ * the decoded token data on `c.var.worker`.
+ */
+export const authenticateWorker = async (
+  c: any,
+  next: () => Promise<void>
+): Promise<Response | undefined> => {
+  const authHeader = c.req.header("authorization");
+  if (!authHeader || !authHeader.startsWith("Bearer ")) {
+    return c.json({ error: "Missing or invalid authorization" }, 401);
+  }
+  const workerToken = authHeader.substring(7);
+  const tokenData = verifyWorkerToken(workerToken);
+  if (!tokenData) {
+    return c.json({ error: "Invalid worker token" }, 401);
+  }
+  c.set("worker", tokenData);
+  await next();
+};