@lobu/gateway 3.0.9 → 3.0.13

package/src/lobu.ts

@@ -1,311 +0,0 @@
-import type { Server } from "node:http";
-import { createLogger } from "@lobu/core";
-import { ApiPlatform } from "./api";
-import { createGatewayApp, startGatewayServer } from "./cli/gateway";
-import { buildGatewayConfig, type GatewayConfig } from "./config";
-import { ChatInstanceManager, ChatResponseBridge } from "./connections";
-import { Gateway } from "./gateway-main";
-import { InMemoryAgentStore } from "./stores/in-memory-agent-store";
-
-const logger = createLogger("lobu");
-
-// ── Public Config Types ────────────────────────────────────────────────────
-
-export interface LobuAgentConfig {
-  id: string;
-  name?: string;
-  description?: string;
-  identity?: string;
-  soul?: string;
-  user?: string;
-  providers?: Array<{ id: string; model?: string; key?: string }>;
-  connections?: Array<{ type: string; [key: string]: string }>;
-  skills?: string[];
-  network?: { allowed?: string[]; denied?: string[] };
-  nixPackages?: string[];
-}
-
-export interface LobuConfig {
-  redis: string;
-  memory?: string;
-  agents?: LobuAgentConfig[];
-  port?: number;
-  deploymentMode?: "embedded" | "docker";
-  /** Public URL of the gateway (used for OAuth callbacks). Defaults to http://localhost:{port}. */
-  publicUrl?: string;
-  /** Admin password for API auth. Auto-generated if not provided. */
-  adminPassword?: string;
-}
-
-// ── Lobu Facade ────────────────────────────────────────────────────────────
-
-export class Lobu {
-  private gateway: Gateway;
-  private gatewayConfig: GatewayConfig;
-  private agentConfigs: LobuAgentConfig[];
-  private httpServer: Server | null = null;
-  private chatInstanceManager: ChatInstanceManager | null = null;
-  private initialized = false;
-  private port: number;
-
-  constructor(config: LobuConfig) {
-    this.agentConfigs = config.agents ?? [];
-    this.port = config.port ?? 8080;
-
-    if (config.memory) {
-      process.env.MEMORY_URL = config.memory;
-    }
-
-    // Set ADMIN_PASSWORD in env so gateway.ts picks it up.
-    // Auto-generate one if not provided.
-    if (config.adminPassword) {
-      process.env.ADMIN_PASSWORD = config.adminPassword;
-    } else if (!process.env.ADMIN_PASSWORD) {
-      const crypto = require("node:crypto");
-      process.env.ADMIN_PASSWORD = crypto.randomBytes(16).toString("base64url");
-    }
-
-    const defaultPublicUrl = `http://localhost:${this.port}`;
-
-    // Convert LobuConfig -> GatewayConfig via buildGatewayConfig overrides
-    this.gatewayConfig = buildGatewayConfig({
-      queues: { connectionString: config.redis },
-      orchestration: {
-        deploymentMode: config.deploymentMode ?? "embedded",
-      },
-      mcp: {
-        publicGatewayUrl: config.publicUrl ?? defaultPublicUrl,
-      },
-    });
-
-    // Build InMemoryAgentStore pre-populated with agents from config
-    const store = new InMemoryAgentStore();
-    this.gateway = new Gateway(this.gatewayConfig, {
-      configStore: store,
-      connectionStore: store,
-      accessStore: store,
-    });
-
-    // Register API platform (always enabled)
-    this.gateway.registerPlatform(new ApiPlatform());
-  }
-
-  /**
-   * Initialize services, populate agents, and seed connections without starting
-   * an HTTP server. Call this when embedding Lobu in an existing server, then
-   * use `getApp()` to get the Hono handler.
-   *
-   * Safe to call multiple times — initialization runs only once.
-   */
-  async initialize(): Promise<void> {
-    if (this.initialized) return;
-
-    // Start the gateway (initializes CoreServices, platforms, consumer)
-    await this.gateway.start();
-
-    const coreServices = this.gateway.getCoreServices();
-
-    // Populate agents from config into the InMemoryAgentStore
-    await this.populateAgents();
-
-    // Initialize Chat SDK connection manager for platform connections
-    this.chatInstanceManager = new ChatInstanceManager();
-    try {
-      await this.chatInstanceManager.initialize(coreServices);
-
-      // Register chat platform adapters
-      for (const adapter of this.chatInstanceManager.createPlatformAdapters()) {
-        this.gateway.registerPlatform(adapter);
-      }
-
-      // Seed connections from agent configs
-      await this.seedConnections();
-
-      // Wire ChatResponseBridge into unified thread consumer
-      const unifiedConsumer = this.gateway.getUnifiedConsumer();
-      if (unifiedConsumer) {
-        const chatResponseBridge = new ChatResponseBridge(
-          this.chatInstanceManager
-        );
-        unifiedConsumer.setChatResponseBridge(chatResponseBridge);
-      }
-    } catch (error) {
-      logger.warn(
-        { error: String(error) },
-        "ChatInstanceManager initialization failed — connections feature disabled"
-      );
-    }
-
-    this.initialized = true;
-    logger.info("Lobu gateway initialized");
-  }
-
-  /**
-   * Start the gateway and an HTTP server. Shorthand for `initialize()` + bind
-   * to a port. Use `initialize()` + `getApp()` instead when mounting Lobu in
-   * an existing framework.
-   */
-  async start(): Promise<void> {
-    await this.initialize();
-
-    const app = this.getApp();
-    this.httpServer = startGatewayServer(app, this.port);
-
-    logger.info(`Lobu gateway running on port ${this.port}`);
-  }
-
-  /**
-   * Stop the gateway and HTTP server.
-   */
-  async stop(): Promise<void> {
-    if (this.chatInstanceManager) {
-      await this.chatInstanceManager.shutdown();
-    }
-    await this.gateway.stop();
-    if (this.httpServer) {
-      this.httpServer.close();
-      this.httpServer = null;
-    }
-    logger.info("Lobu gateway stopped");
-  }
-
-  /**
-   * Get the Hono app for mounting in another server (no HTTP server started).
-   * Call this instead of start() when embedding in an existing HTTP server.
-   */
-  getApp() {
-    const coreServices = this.gateway.getCoreServices();
-    return createGatewayApp({
-      secretProxy: coreServices.getSecretProxy(),
-      workerGateway: coreServices.getWorkerGateway(),
-      mcpProxy: coreServices.getMcpProxy(),
-      interactionService: coreServices.getInteractionService(),
-      platformRegistry: this.gateway.getPlatformRegistry(),
-      coreServices,
-      chatInstanceManager: this.chatInstanceManager,
-    });
-  }
-
-  // ── Private Helpers ──────────────────────────────────────────────────────
-
-  /**
-   * Populate InMemoryAgentStore + seed credentials from LobuAgentConfig[].
-   * Mirrors what CoreServices.populateStoreFromFiles() does for file-loaded agents.
-   */
-  private async populateAgents(): Promise<void> {
-    if (this.agentConfigs.length === 0) return;
-
-    const coreServices = this.gateway.getCoreServices();
-    const configStore = coreServices.getConfigStore();
-    if (!configStore) return;
-
-    const store = configStore as InMemoryAgentStore;
-    const authProfilesManager = coreServices.getAuthProfilesManager();
-
-    for (const agent of this.agentConfigs) {
-      // Save metadata
-      await store.saveMetadata(agent.id, {
-        agentId: agent.id,
-        name: agent.name ?? agent.id,
-        description: agent.description,
-        owner: { platform: "system", userId: "sdk" },
-        createdAt: Date.now(),
-      });
-
-      // Build settings (same shape as FileLoadedAgent.settings)
-      const settings: Record<string, any> = {};
-
-      if (agent.identity) settings.identityMd = agent.identity;
-      if (agent.soul) settings.soulMd = agent.soul;
-      if (agent.user) settings.userMd = agent.user;
-
-      if (agent.providers?.length) {
-        settings.installedProviders = agent.providers.map((p) => ({
-          providerId: p.id,
-          installedAt: Date.now(),
-        }));
-        settings.modelSelection = { mode: "auto" };
-        const providerModelPreferences = Object.fromEntries(
-          agent.providers
-            .filter((p) => !!p.model?.trim())
-            .map((p) => [p.id, p.model!.trim()])
-        );
-        if (Object.keys(providerModelPreferences).length > 0) {
-          settings.providerModelPreferences = providerModelPreferences;
-        }
-      }
-
-      if (agent.network) {
-        settings.networkConfig = {
-          allowedDomains: agent.network.allowed,
-          deniedDomains: agent.network.denied,
-        };
-      }
-
-      if (agent.nixPackages?.length) {
-        settings.nixConfig = { packages: agent.nixPackages };
-      }
-
-      await store.saveSettings(agent.id, {
-        ...settings,
-        updatedAt: Date.now(),
-      } as any);
-
-      // Seed provider credentials
-      if (authProfilesManager && agent.providers) {
-        for (const provider of agent.providers) {
-          if (!provider.key) continue;
-          await authProfilesManager.upsertProfile({
-            agentId: agent.id,
-            provider: provider.id,
-            credential: provider.key,
-            authType: "api-key",
-            label: `${provider.id} (from SDK config)`,
-            makePrimary: true,
-          });
-        }
-      }
-    }
-
-    logger.info(
-      `Populated ${this.agentConfigs.length} agent(s) from SDK config`
-    );
-  }
-
-  /**
-   * Seed platform connections from agent configs.
-   * Mirrors the file-loaded agent connection seeding in gateway.ts startGateway().
-   */
-  private async seedConnections(): Promise<void> {
-    if (!this.chatInstanceManager) return;
-
-    for (const agent of this.agentConfigs) {
-      if (!agent.connections?.length) continue;
-
-      for (const conn of agent.connections) {
-        const { type, ...configFields } = conn;
-
-        const existing = await this.chatInstanceManager.listConnections({
-          platform: type,
-          templateAgentId: agent.id,
-        });
-        if (existing.length > 0) continue;
-
-        try {
-          await this.chatInstanceManager.addConnection(
-            type,
-            agent.id,
-            { platform: type as any, ...configFields },
-            { allowGroups: true }
-          );
-          logger.debug(`Created ${type} connection for agent "${agent.id}"`);
-        } catch (err) {
-          logger.error(
-            `Failed to create ${type} connection for agent "${agent.id}"`,
-            { error: err instanceof Error ? err.message : String(err) }
-          );
-        }
-      }
-    }
-  }
-}

package/src/metrics/prometheus.ts

@@ -1,159 +0,0 @@
-/**
- * Simple Prometheus metrics exporter (no external dependencies)
- * Exposes basic gateway metrics in Prometheus text format
- */
-
-import { createLogger } from "@lobu/core";
-
-const logger = createLogger("metrics");
-
-interface MetricValue {
-  value: number;
-  labels: Record<string, string>;
-}
-
-interface Metric {
-  name: string;
-  help: string;
-  type: "counter" | "gauge" | "histogram";
-  values: MetricValue[];
-}
-
-const metrics: Map<string, Metric> = new Map();
-
-function initializeMetrics() {
-  registerMetric(
-    "lobu_worker_deployments_total",
-    "Total number of worker deployments created",
-    "counter"
-  );
-  registerMetric(
-    "lobu_worker_deployments_failed_total",
-    "Total number of failed worker deployments",
-    "counter"
-  );
-  registerMetric(
-    "lobu_worker_deployments_active",
-    "Current number of active worker deployments",
-    "gauge"
-  );
-  registerMetric(
-    "lobu_messages_received_total",
-    "Total number of messages received",
-    "counter"
-  );
-  registerMetric(
-    "lobu_messages_processed_total",
-    "Total number of messages processed",
-    "counter"
-  );
-  registerMetric("lobu_queue_length", "Current message queue length", "gauge");
-  registerMetric(
-    "lobu_pvc_created_total",
-    "Total number of PVCs created",
-    "counter"
-  );
-  registerMetric(
-    "lobu_pvc_deleted_total",
-    "Total number of PVCs deleted",
-    "counter"
-  );
-  registerMetric(
-    "lobu_pvc_cleanup_failed_total",
-    "Total number of failed PVC cleanup operations",
-    "counter"
-  );
-  registerMetric(
-    "lobu_redis_connection_errors_total",
-    "Total number of Redis connection errors",
-    "counter"
-  );
-  registerMetric(
-    "lobu_proxy_requests_total",
-    "Total number of HTTP proxy requests",
-    "counter"
-  );
-  registerMetric(
-    "lobu_proxy_requests_blocked_total",
-    "Total number of blocked proxy requests",
-    "counter"
-  );
-  registerMetric(
-    "lobu_process_start_time_seconds",
-    "Start time of the process since unix epoch in seconds",
-    "gauge"
-  );
-
-  setGauge("lobu_process_start_time_seconds", Math.floor(Date.now() / 1000));
-  logger.info("Prometheus metrics initialized");
-}
-
-function registerMetric(
-  name: string,
-  help: string,
-  type: "counter" | "gauge" | "histogram"
-) {
-  metrics.set(name, { name, help, type, values: [] });
-}
-
-function setGauge(
-  name: string,
-  value: number,
-  labels: Record<string, string> = {}
-) {
-  const metric = metrics.get(name);
-  if (!metric || metric.type !== "gauge") {
-    logger.warn(`Gauge metric ${name} not found`);
-    return;
-  }
-
-  const labelKey = JSON.stringify(labels);
-  const existing = metric.values.find(
-    (entry) => JSON.stringify(entry.labels) === labelKey
-  );
-  if (existing) {
-    existing.value = value;
-  } else {
-    metric.values.push({ value, labels });
-  }
-}
-
-export function getMetricsText(): string {
-  const lines: string[] = [];
-
-  for (const metric of metrics.values()) {
-    lines.push(`# HELP ${metric.name} ${metric.help}`);
-    lines.push(`# TYPE ${metric.name} ${metric.type}`);
-
-    if (metric.values.length === 0) {
-      lines.push(`${metric.name} 0`);
-      continue;
-    }
-
-    for (const { value, labels } of metric.values) {
-      const labelStr = Object.entries(labels)
-        .map(([key, labelValue]) => `${key}="${labelValue}"`)
-        .join(",");
-      if (labelStr) {
-        lines.push(`${metric.name}{${labelStr}} ${value}`);
-      } else {
-        lines.push(`${metric.name} ${value}`);
-      }
-    }
-  }
-
-  const memUsage = process.memoryUsage();
-  lines.push("# HELP nodejs_heap_size_bytes Node.js heap size in bytes");
-  lines.push("# TYPE nodejs_heap_size_bytes gauge");
-  lines.push(`nodejs_heap_size_bytes{type="used"} ${memUsage.heapUsed}`);
-  lines.push(`nodejs_heap_size_bytes{type="total"} ${memUsage.heapTotal}`);
-  lines.push(
-    "# HELP nodejs_external_memory_bytes Node.js external memory in bytes"
-  );
-  lines.push("# TYPE nodejs_external_memory_bytes gauge");
-  lines.push(`nodejs_external_memory_bytes ${memUsage.external}`);
-
-  return `${lines.join("\n")}\n`;
-}
-
-initializeMetrics();

package/src/modules/module-system.ts

@@ -1,179 +0,0 @@
-import type { CliBackendConfig } from "@lobu/core";
-import {
-  type ActionButton,
-  type ModuleInterface,
-  type ModuleSessionContext,
-  moduleRegistry,
-  type WorkerContext,
-  type WorkerModule,
-} from "@lobu/core";
-
-export interface ModelOption {
-  value: string;
-  label: string;
-}
-
-export interface OrchestratorModule<TModuleData = unknown>
-  extends ModuleInterface<TModuleData> {
-  buildEnvVars(
-    agentId: string,
-    baseEnv: Record<string, string>
-  ): Promise<Record<string, string>>;
-  getContainerAddress(): string;
-}
-
-export interface ProviderUpstreamConfig {
-  slug: string;
-  upstreamBaseUrl: string;
-}
-
-export interface ModelProviderModule extends OrchestratorModule {
-  providerId: string;
-  providerDisplayName: string;
-  providerIconUrl?: string;
-  authType?: "oauth" | "device-code" | "api-key";
-  supportedAuthTypes?: ("oauth" | "device-code" | "api-key")[];
-  apiKeyInstructions?: string;
-  apiKeyPlaceholder?: string;
-  catalogDescription?: string;
-  catalogVisible?: boolean;
-  getSecretEnvVarNames(): string[];
-  getCredentialEnvVarName(): string;
-  getUpstreamConfig?(): ProviderUpstreamConfig | null;
-  hasCredentials(agentId: string): Promise<boolean>;
-  hasSystemKey(): boolean;
-  getProxyBaseUrlMappings(
-    proxyUrl: string,
-    agentId?: string
-  ): Record<string, string>;
-  injectSystemKeyFallback(
-    envVars: Record<string, string>
-  ): Record<string, string>;
-  getApp?(): any;
-  getModelOptions?(agentId: string, userId: string): Promise<ModelOption[]>;
-  getCliBackendConfig?(): CliBackendConfig | null;
-  buildCredentialPlaceholder?(agentId: string): Promise<string> | string;
-  startDeviceCode?(agentId: string): Promise<{
-    userCode: string;
-    deviceAuthId: string;
-    interval: number;
-    verificationUrl?: string;
-  }>;
-  pollDeviceCode?(
-    agentId: string,
-    payload: { deviceAuthId: string; userCode: string }
-  ): Promise<{
-    status: "pending" | "success";
-    error?: string;
-    accountId?: string;
-  }>;
-}
-
-export interface DispatcherContext<TModuleData = unknown> {
-  userId: string;
-  channelId: string;
-  threadTs: string;
-  platformClient?: unknown;
-  moduleData: TModuleData;
-}
-
-export interface DispatcherModule<TModuleData = unknown>
-  extends ModuleInterface<TModuleData> {
-  generateActionButtons(
-    context: DispatcherContext<TModuleData>
-  ): Promise<ActionButton[]>;
-  handleAction(
-    actionId: string,
-    userId: string,
-    agentId: string,
-    context: any
-  ): Promise<boolean>;
-}
-
-export interface DispatcherModuleSource {
-  getDispatcherModules(): DispatcherModule[];
-}
-
-export abstract class BaseModule<TModuleData = unknown>
-  implements
-    WorkerModule<TModuleData>,
-    DispatcherModule<TModuleData>,
-    OrchestratorModule<TModuleData>
-{
-  abstract name: string;
-  abstract isEnabled(): boolean;
-
-  async init(): Promise<void> {
-    // no-op
-  }
-
-  registerEndpoints(_app: any): void {
-    // no-op
-  }
-
-  async initWorkspace(_config: any): Promise<void> {
-    // no-op
-  }
-
-  async onSessionStart(
-    context: ModuleSessionContext
-  ): Promise<ModuleSessionContext> {
-    return context;
-  }
-
-  async onSessionEnd(_context: ModuleSessionContext): Promise<ActionButton[]> {
-    return [];
-  }
-
-  async onBeforeResponse(_context: WorkerContext): Promise<TModuleData | null> {
-    return null;
-  }
-
-  async buildEnvVars(
-    _agentId: string,
-    baseEnv: Record<string, string>
-  ): Promise<Record<string, string>> {
-    return baseEnv;
-  }
-
-  async getModelOptions(
-    _agentId: string,
-    _userId: string
-  ): Promise<ModelOption[]> {
-    return [];
-  }
-
-  getContainerAddress(): string {
-    return "";
-  }
-
-  async generateActionButtons(
-    _context: DispatcherContext<TModuleData>
-  ): Promise<ActionButton[]> {
-    return [];
-  }
-
-  async handleAction(
-    _actionId: string,
-    _userId: string,
-    _agentId: string,
-    _context: any
-  ): Promise<boolean> {
-    return false;
-  }
-}
-
-export function getOrchestratorModules(): OrchestratorModule[] {
-  return moduleRegistry
-    .getModules()
-    .filter((m): m is OrchestratorModule => "buildEnvVars" in m);
-}
-
-export function getModelProviderModules(): ModelProviderModule[] {
-  return moduleRegistry
-    .getModules()
-    .filter(
-      (m): m is ModelProviderModule =>
-        "providerId" in m && "getSecretEnvVarNames" in m
-    );
-}