@lobu/gateway 3.0.8 → 3.0.12

package/src/auth/settings/template-utils.ts

@@ -1,44 +0,0 @@
-import type { AgentSettings } from "./index";
-
-function cloneSettingValue<T>(value: T): T {
-  return JSON.parse(JSON.stringify(value)) as T;
-}
-
-export function buildDefaultSettingsFromSource(
-  source: AgentSettings | null
-): Omit<AgentSettings, "updatedAt"> {
-  if (!source) return {};
-
-  const defaults: Omit<AgentSettings, "updatedAt"> = {};
-
-  if (source.model !== undefined) defaults.model = source.model;
-  if (source.modelSelection)
-    defaults.modelSelection = cloneSettingValue(source.modelSelection);
-  if (source.providerModelPreferences)
-    defaults.providerModelPreferences = cloneSettingValue(
-      source.providerModelPreferences
-    );
-  if (source.networkConfig)
-    defaults.networkConfig = cloneSettingValue(source.networkConfig);
-  if (source.nixConfig)
-    defaults.nixConfig = cloneSettingValue(source.nixConfig);
-  if (source.mcpServers)
-    defaults.mcpServers = cloneSettingValue(source.mcpServers);
-  if (source.soulMd !== undefined) defaults.soulMd = source.soulMd;
-  if (source.userMd !== undefined) defaults.userMd = source.userMd;
-  if (source.identityMd !== undefined) defaults.identityMd = source.identityMd;
-  if (source.skillsConfig)
-    defaults.skillsConfig = cloneSettingValue(source.skillsConfig);
-  if (source.toolsConfig)
-    defaults.toolsConfig = cloneSettingValue(source.toolsConfig);
-  if (source.pluginsConfig)
-    defaults.pluginsConfig = cloneSettingValue(source.pluginsConfig);
-  if (source.installedProviders) {
-    defaults.installedProviders = cloneSettingValue(source.installedProviders);
-  }
-  if (source.verboseLogging !== undefined) {
-    defaults.verboseLogging = source.verboseLogging;
-  }
-
-  return defaults;
-}

package/src/auth/settings/token-service.ts

@@ -1,88 +0,0 @@
-/**
- * Pre-filled skill configuration for an agent config session
- */
-export interface PrefillSkill {
-  /** Skill repository (e.g., "anthropics/skills/pdf") */
-  repo: string;
-  /** Display name */
-  name?: string;
-  /** Description */
-  description?: string;
-}
-
-/**
- * Pre-filled MCP server configuration for an agent config session
- */
-export interface PrefillMcpServer {
-  /** MCP server ID (key in mcpServers record) */
-  id: string;
-  /** Display name/description */
-  name?: string;
-  /** Server URL (for SSE type) */
-  url?: string;
-  /** Server type */
-  type?: "sse" | "stdio";
-  /** Command (for stdio type) */
-  command?: string;
-  /** Args (for stdio type) */
-  args?: string[];
-  /** Environment variables needed (just the keys, user fills values) */
-  envVars?: string[];
-}
-
-/**
- * Source message context where settings link was requested.
- * Used to send follow-up notifications back to the same conversation.
- */
-export interface SettingsSourceContext {
-  conversationId: string;
-  channelId: string;
-  teamId?: string;
-  platform?: string;
-}
-
-/**
- * Unified session payload for config/auth sessions.
- *
- * OAuth sessions populate email/name/oauthUserId. Claimed chat sessions
- * populate platform/channelId/userId directly.
- */
-export interface SettingsTokenPayload {
-  /** Agent to configure. Optional when using channel-based entry (user picks agent on page). */
-  agentId?: string;
-  userId: string;
-  platform: string;
-  exp: number; // Expiration timestamp (ms)
-  /** Channel that triggered the settings link. Used for agent switching and binding. */
-  channelId?: string;
-  /** Team/workspace ID for multi-tenant platforms (Slack). */
-  teamId?: string;
-  /** OAuth user email (set for OAuth sessions). */
-  email?: string;
-  /** OAuth user display name (set for OAuth sessions). */
-  name?: string;
-  /** OAuth provider user ID (set for OAuth sessions). */
-  oauthUserId?: string;
-  /** Optional message to display during config/auth flows */
-  message?: string;
-  /** Optional provider IDs to associate with the flow */
-  prefillProviders?: string[];
-  /** Optional skills to pre-fill (user confirms to enable) */
-  prefillSkills?: PrefillSkill[];
-  /** Optional MCP servers to pre-fill (user confirms to enable) */
-  prefillMcpServers?: PrefillMcpServer[];
-  /** Optional Nix packages to pre-fill */
-  prefillNixPackages?: string[];
-  /** Optional domain patterns to pre-fill as grants */
-  prefillGrants?: string[];
-  /** Optional source context for post-install notifications */
-  sourceContext?: SettingsSourceContext;
-  /** Settings mode: "admin" has full access, "user" is restricted by allowedScopes */
-  settingsMode?: "admin" | "user";
-  /** Scopes the user is allowed to configure (only relevant when settingsMode is "user") */
-  allowedScopes?: string[];
-  /** Connection ID that triggered this session */
-  connectionId?: string;
-  /** Whether this session has admin access */
-  isAdmin?: boolean;
-}

package/src/auth/system-env-store.ts

@@ -1,98 +0,0 @@
-import { createLogger, decrypt, encrypt } from "@lobu/core";
-import type Redis from "ioredis";
-
-const logger = createLogger("system-env-store");
-const KEY_PREFIX = "system:env:";
-
-/**
- * Redis-backed store for system environment variables.
- * Maintains an in-memory cache for synchronous resolution
- * (required by the string-substitution system).
- */
-export class SystemEnvStore {
-  private redis: Redis;
-  private cache: Map<string, string> = new Map();
-
-  constructor(redis: Redis) {
-    this.redis = redis;
-  }
-
-  async get(key: string): Promise<string | null> {
-    try {
-      const raw = await this.redis.get(`${KEY_PREFIX}${key}`);
-      if (raw === null) return null;
-      return decrypt(raw);
-    } catch (error) {
-      logger.error("Failed to get env var", { key, error });
-      return null;
-    }
-  }
-
-  async set(key: string, value: string): Promise<void> {
-    try {
-      await this.redis.set(`${KEY_PREFIX}${key}`, encrypt(value));
-      this.cache.set(key, value);
-      logger.info(`Set system env var: ${key}`);
-    } catch (error) {
-      logger.error("Failed to set env var", { key, error });
-      throw error;
-    }
-  }
-
-  async delete(key: string): Promise<void> {
-    try {
-      await this.redis.del(`${KEY_PREFIX}${key}`);
-      this.cache.delete(key);
-      logger.info(`Deleted system env var: ${key}`);
-    } catch (error) {
-      logger.error("Failed to delete env var", { key, error });
-    }
-  }
-
-  async listAll(): Promise<Record<string, string>> {
-    const result: Record<string, string> = {};
-    let cursor = "0";
-    try {
-      do {
-        const [nextCursor, keys] = await this.redis.scan(
-          cursor,
-          "MATCH",
-          `${KEY_PREFIX}*`,
-          "COUNT",
-          100
-        );
-        cursor = nextCursor;
-        for (const key of keys) {
-          const raw = await this.redis.get(key);
-          if (raw !== null) {
-            result[key.slice(KEY_PREFIX.length)] = decrypt(raw);
-          }
-        }
-      } while (cursor !== "0");
-    } catch (error) {
-      logger.error("Failed to list env vars", { error });
-    }
-    return result;
-  }
-
-  /**
-   * Synchronous lookup: cache first, then process.env.
-   * Used by the string-substitution env resolver.
-   */
-  resolve(key: string): string | undefined {
-    return this.cache.get(key) ?? process.env[key] ?? undefined;
-  }
-
-  /**
-   * Load all system:env:* keys from Redis into the in-memory cache.
-   * Call on startup before registering the resolver.
-   */
-  async refreshCache(): Promise<void> {
-    const all = await this.listAll();
-    this.cache.clear();
-    for (const [key, value] of Object.entries(all)) {
-      this.cache.set(key, value);
-    }
-    logger.debug(`Loaded ${this.cache.size} system env vars into cache`);
-  }
-}

package/src/auth/user-agents-store.ts

@@ -1,68 +0,0 @@
-import { createLogger } from "@lobu/core";
-import type Redis from "ioredis";
-
-const logger = createLogger("user-agents-store");
-
-/**
- * Track which agents belong to which users.
- * Uses Redis sets for fast membership checks and listing.
- *
- * Storage pattern:
- * - user_agents:{platform}:{userId} -> Set of agentIds
- */
-export class UserAgentsStore {
-  private readonly KEY_PREFIX = "user_agents";
-
-  constructor(private redis: Redis) {}
-
-  private buildKey(platform: string, userId: string): string {
-    return `${this.KEY_PREFIX}:${platform}:${userId}`;
-  }
-
-  /**
-   * Add an agent to a user's list
-   */
-  async addAgent(
-    platform: string,
-    userId: string,
-    agentId: string
-  ): Promise<void> {
-    const key = this.buildKey(platform, userId);
-    await this.redis.sadd(key, agentId);
-    logger.info(`Added agent ${agentId} to user ${platform}/${userId}`);
-  }
-
-  /**
-   * Remove an agent from a user's list
-   */
-  async removeAgent(
-    platform: string,
-    userId: string,
-    agentId: string
-  ): Promise<void> {
-    const key = this.buildKey(platform, userId);
-    await this.redis.srem(key, agentId);
-    logger.info(`Removed agent ${agentId} from user ${platform}/${userId}`);
-  }
-
-  /**
-   * List all agents owned by a user
-   */
-  async listAgents(platform: string, userId: string): Promise<string[]> {
-    const key = this.buildKey(platform, userId);
-    return this.redis.smembers(key);
-  }
-
-  /**
-   * Check if a user owns a specific agent
-   */
-  async ownsAgent(
-    platform: string,
-    userId: string,
-    agentId: string
-  ): Promise<boolean> {
-    const key = this.buildKey(platform, userId);
-    const result = await this.redis.sismember(key, agentId);
-    return result === 1;
-  }
-}

package/src/channels/binding-service.ts

@@ -1,214 +0,0 @@
-import { BaseRedisStore, createLogger } from "@lobu/core";
-import type Redis from "ioredis";
-
-const logger = createLogger("channel-binding-service");
-
-/**
- * Channel binding - links a platform channel to a specific agent
- */
-export interface ChannelBinding {
-  platform: string; // Platform identifier
-  channelId: string;
-  agentId: string;
-  teamId?: string; // Optional workspace/team ID for multi-tenant platforms
-  configuredBy?: string; // userId of who configured this binding
-  configuredAt?: number; // When the binding was configured
-  wasAdmin?: boolean; // Whether the configurer was an admin at time of configuration
-  createdAt: number;
-}
-
-/**
- * Internal storage format includes reverse lookup info
- */
-interface StoredBinding extends ChannelBinding {
-  // Stored at channel_binding:{platform}:{channelId} or channel_binding:{platform}:{teamId}:{channelId}
-}
-
-/**
- * Service for managing channel-to-agent bindings
- *
- * Storage patterns:
- * - Forward lookup: channel_binding:{platform}:{channelId} → binding data
- * - Forward lookup (Slack): channel_binding:{platform}:{teamId}:{channelId} → binding data
- * - Reverse index: channel_binding_index:{agentId} → Set of binding keys
- */
-export class ChannelBindingService extends BaseRedisStore<StoredBinding> {
-  private readonly INDEX_PREFIX = "channel_binding_index";
-
-  constructor(redis: Redis) {
-    super({
-      redis,
-      keyPrefix: "channel_binding",
-      loggerName: "channel-binding-service",
-    });
-  }
-
-  /**
-   * Build the binding key for a channel
-   * Includes teamId for multi-tenant platforms (e.g., Slack workspaces)
-   */
-  private buildBindingKey(
-    platform: string,
-    channelId: string,
-    teamId?: string
-  ): string {
-    if (teamId) {
-      return this.buildKey(platform, teamId, channelId);
-    }
-    return this.buildKey(platform, channelId);
-  }
-
-  /**
-   * Build the index key for an agent's bindings
-   */
-  private buildIndexKey(agentId: string): string {
-    return `${this.INDEX_PREFIX}:${agentId}`;
-  }
-
-  /**
-   * Get binding for a channel
-   * Returns null if channel is not bound to any agent
-   */
-  async getBinding(
-    platform: string,
-    channelId: string,
-    teamId?: string
-  ): Promise<ChannelBinding | null> {
-    const key = this.buildBindingKey(platform, channelId, teamId);
-    const binding = await this.get(key);
-    if (binding) {
-      logger.debug(
-        `Found binding for ${platform}/${channelId}: ${binding.agentId}`
-      );
-    }
-    return binding;
-  }
-
-  /**
-   * Create a binding from a channel to an agent
-   * If the channel was already bound, the old binding is removed
-   */
-  async createBinding(
-    agentId: string,
-    platform: string,
-    channelId: string,
-    teamId?: string,
-    options?: { configuredBy?: string; wasAdmin?: boolean }
-  ): Promise<void> {
-    const key = this.buildBindingKey(platform, channelId, teamId);
-
-    // Check if already bound to a different agent
-    const existing = await this.get(key);
-    if (existing && existing.agentId !== agentId) {
-      // Remove from old agent's index
-      const oldIndexKey = this.buildIndexKey(existing.agentId);
-      await this.redis.srem(oldIndexKey, key);
-      logger.info(
-        `Removed binding from agent ${existing.agentId} for ${platform}/${channelId}`
-      );
-    }
-
-    // Create the binding
-    const binding: StoredBinding = {
-      platform,
-      channelId,
-      agentId,
-      teamId,
-      configuredBy: options?.configuredBy,
-      configuredAt: Date.now(),
-      wasAdmin: options?.wasAdmin,
-      createdAt: Date.now(),
-    };
-    await this.set(key, binding);
-
-    // Add to agent's index
-    const indexKey = this.buildIndexKey(agentId);
-    await this.redis.sadd(indexKey, key);
-
-    logger.info(`Created binding: ${platform}/${channelId} → ${agentId}`);
-  }
-
-  /**
-   * Delete a binding for a channel
-   */
-  async deleteBinding(
-    agentId: string,
-    platform: string,
-    channelId: string,
-    teamId?: string
-  ): Promise<boolean> {
-    const key = this.buildBindingKey(platform, channelId, teamId);
-    const existing = await this.get(key);
-
-    if (!existing) {
-      logger.warn(`No binding found for ${platform}/${channelId}`);
-      return false;
-    }
-
-    if (existing.agentId !== agentId) {
-      logger.warn(
-        `Binding for ${platform}/${channelId} belongs to ${existing.agentId}, not ${agentId}`
-      );
-      return false;
-    }
-
-    // Delete the binding
-    await this.delete(key);
-
-    // Remove from agent's index
-    const indexKey = this.buildIndexKey(agentId);
-    await this.redis.srem(indexKey, key);
-
-    logger.info(`Deleted binding: ${platform}/${channelId} from ${agentId}`);
-    return true;
-  }
-
-  /**
-   * List all bindings for an agent
-   */
-  async listBindings(agentId: string): Promise<ChannelBinding[]> {
-    const indexKey = this.buildIndexKey(agentId);
-    const bindingKeys = await this.redis.smembers(indexKey);
-
-    if (bindingKeys.length === 0) {
-      return [];
-    }
-
-    const bindings: ChannelBinding[] = [];
-    for (const key of bindingKeys) {
-      const binding = await this.get(key);
-      if (binding) {
-        bindings.push(binding);
-      } else {
-        // Clean up stale index entry
-        await this.redis.srem(indexKey, key);
-      }
-    }
-
-    return bindings;
-  }
-
-  /**
-   * Delete all bindings for an agent
-   * Used when deleting an agent
-   */
-  async deleteAllBindings(agentId: string): Promise<number> {
-    const bindings = await this.listBindings(agentId);
-
-    for (const binding of bindings) {
-      const key = this.buildBindingKey(
-        binding.platform,
-        binding.channelId,
-        binding.teamId
-      );
-      await this.delete(key);
-    }
-
-    // Delete the index
-    const indexKey = this.buildIndexKey(agentId);
-    await this.redis.del(indexKey);
-
-    logger.info(`Deleted ${bindings.length} bindings for agent ${agentId}`);
-    return bindings.length;
-  }
-}

package/src/channels/index.ts

@@ -1,4 +0,0 @@
-export {
-  type ChannelBinding,
-  ChannelBindingService,
-} from "./binding-service";