@lobu/gateway 3.0.8 → 3.0.12

package/src/routes/internal/files.ts

@@ -1,226 +0,0 @@
-#!/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

@@ -1,69 +0,0 @@
-#!/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

@@ -1,127 +0,0 @@
-/**
- * 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

@@ -1,84 +0,0 @@
-#!/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

@@ -1,23 +0,0 @@
-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();
-};