@lobu/gateway 3.0.5 → 3.0.6

package/src/lobu.ts

@@ -0,0 +1,311 @@
+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

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

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