@lobu/gateway 3.0.5 → 3.0.6

package/src/cli/index.ts

@@ -0,0 +1,74 @@
+#!/usr/bin/env bun
+
+import { ConfigError, createLogger, initSentry, initTracing } from "@lobu/core";
+import { Command } from "commander";
+import {
+  buildGatewayConfig,
+  displayGatewayConfig,
+  loadEnvFile,
+} from "../config";
+import { startGateway } from "./gateway";
+
+const logger = createLogger("cli");
+
+async function main() {
+  const program = new Command();
+
+  program
+    .name("lobu-gateway")
+    .description(
+      "Lobu gateway service — API-driven platform connections via Chat SDK"
+    )
+    .version("1.0.0");
+
+  program
+    .option("--env <path>", "Path to .env file (default: .env)")
+    .option("--validate", "Validate configuration and exit")
+    .option("--show-config", "Display parsed configuration and exit")
+    .action(async (options) => {
+      try {
+        loadEnvFile(options.env);
+
+        await initSentry();
+
+        initTracing({
+          serviceName: "lobu-gateway",
+          serviceVersion: process.env.npm_package_version || "2.0.0",
+          tempoEndpoint: process.env.TEMPO_ENDPOINT,
+          enabled: !!process.env.TEMPO_ENDPOINT,
+        });
+
+        const config = buildGatewayConfig();
+
+        if (options.validate) {
+          console.log("Configuration is valid");
+          displayGatewayConfig(config);
+          process.exit(0);
+        }
+
+        if (options.showConfig) {
+          displayGatewayConfig(config);
+          process.exit(0);
+        }
+
+        await startGateway(config);
+      } catch (error) {
+        if (error instanceof ConfigError) {
+          logger.error("Configuration error:", error.message);
+          process.exit(1);
+        }
+        logger.error(
+          "Failed to start gateway:",
+          error instanceof Error ? error.message : String(error)
+        );
+        process.exit(1);
+      }
+    });
+
+  await program.parseAsync(process.argv);
+}
+
+main().catch((error) => {
+  logger.error("CLI error:", error);
+  process.exit(1);
+});

package/src/commands/built-in-commands.ts

@@ -0,0 +1,80 @@
+import type { CommandContext, CommandRegistry } from "@lobu/core";
+import type { AgentSettingsStore } from "../auth/settings";
+import {
+  getModelSelectionState,
+  resolveEffectiveModelRef,
+} from "../auth/settings/model-selection";
+
+export interface BuiltInCommandDeps {
+  agentSettingsStore: AgentSettingsStore;
+}
+
+/**
+ * Register all built-in slash commands on the given registry.
+ */
+export function registerBuiltInCommands(
+  registry: CommandRegistry,
+  deps: BuiltInCommandDeps
+): void {
+  registry.register({
+    name: "new",
+    description: "Save context to memory and start a fresh session",
+    handler: async (ctx: CommandContext) => {
+      // Handled by message-handler-bridge before slash dispatch
+      await ctx.reply("Starting new session...");
+    },
+  });
+
+  registry.register({
+    name: "clear",
+    description: "Clear chat history and start fresh",
+    handler: async (ctx: CommandContext) => {
+      // Handled by message-handler-bridge before slash dispatch
+      await ctx.reply("Chat history cleared.");
+    },
+  });
+
+  registry.register({
+    name: "help",
+    description: "Show available commands",
+    handler: async (ctx: CommandContext) => {
+      const commands = registry.getAll();
+      const lines = commands.map((c) => `/${c.name} - ${c.description}`);
+      await ctx.reply(
+        `Available commands:\n${lines.join("\n")}\n\nYou can also just send a message to start a conversation with the agent.`
+      );
+    },
+  });
+
+  registry.register({
+    name: "status",
+    description: "Show current agent status",
+    handler: async (ctx: CommandContext) => {
+      if (!ctx.agentId) {
+        await ctx.reply("No agent is configured for this conversation yet.");
+        return;
+      }
+
+      const settings = await deps.agentSettingsStore.getSettings(ctx.agentId);
+
+      const modelSelection = getModelSelectionState(settings);
+      const effectiveModel = resolveEffectiveModelRef(settings);
+      const model = effectiveModel || "auto";
+      const mcpCount = settings?.mcpServers
+        ? Object.keys(settings.mcpServers).length
+        : 0;
+      const skillsCount = settings?.skillsConfig?.skills
+        ? Object.keys(settings.skillsConfig.skills).length
+        : 0;
+
+      const parts = [
+        `Agent: ${ctx.agentId}`,
+        `Model: ${model} (${modelSelection.mode})`,
+        `MCP servers: ${mcpCount}`,
+        `Skills: ${skillsCount}`,
+      ];
+
+      await ctx.reply(parts.join("\n"));
+    },
+  });
+}

package/src/commands/command-dispatcher.ts

@@ -0,0 +1,94 @@
+import {
+  type CommandContext,
+  type CommandRegistry,
+  createLogger,
+} from "@lobu/core";
+import type { ChannelBindingService } from "../channels";
+import { platformAgentId } from "../spaces";
+
+const logger = createLogger("command-dispatcher");
+
+export interface CommandDispatchInput {
+  platform: string;
+  userId: string;
+  channelId: string;
+  teamId?: string;
+  isGroup: boolean;
+  conversationId?: string;
+  connectionId?: string;
+  reply: CommandContext["reply"];
+}
+
+export interface CommandDispatcherDeps {
+  registry: CommandRegistry;
+  channelBindingService: ChannelBindingService;
+}
+
+export class CommandDispatcher {
+  private registry: CommandRegistry;
+  private channelBindingService: ChannelBindingService;
+
+  constructor(deps: CommandDispatcherDeps) {
+    this.registry = deps.registry;
+    this.channelBindingService = deps.channelBindingService;
+  }
+
+  async tryHandleSlashText(
+    rawText: string,
+    input: CommandDispatchInput
+  ): Promise<boolean> {
+    const match = rawText.trim().match(/^\/(\w+)(?:\s+(.*))?$/);
+    if (!match?.[1]) return false;
+    return this.tryHandle(match[1], match[2]?.trim() || "", input);
+  }
+
+  async tryHandle(
+    commandName: string,
+    commandArgs: string,
+    input: CommandDispatchInput
+  ): Promise<boolean> {
+    const agentId = await this.resolveAgentId(input);
+
+    logger.info(
+      {
+        platform: input.platform,
+        commandName,
+        userId: input.userId,
+        channelId: input.channelId,
+        teamId: input.teamId,
+        agentId,
+      },
+      "Dispatching command"
+    );
+
+    return this.registry.tryHandle(commandName, {
+      userId: input.userId,
+      channelId: input.channelId,
+      conversationId: input.conversationId,
+      connectionId: input.connectionId,
+      agentId,
+      args: commandArgs,
+      platform: input.platform,
+      reply: input.reply,
+    });
+  }
+
+  private async resolveAgentId(input: CommandDispatchInput): Promise<string> {
+    // Check channel binding first (Slack multi-tenant)
+    const binding = await this.channelBindingService.getBinding(
+      input.platform,
+      input.channelId,
+      input.teamId
+    );
+    if (binding?.agentId) {
+      return binding.agentId;
+    }
+
+    return platformAgentId(
+      input.platform,
+      input.userId,
+      input.channelId,
+      input.isGroup
+    );
+  }
+}

package/src/commands/command-reply-adapters.ts

@@ -0,0 +1,27 @@
+import type { CommandContext } from "@lobu/core";
+
+export function createChatReply(
+  postFn: (content: any) => Promise<void>
+): CommandContext["reply"] {
+  return async (text, options) => {
+    if (options?.url) {
+      const { Card, CardText, Actions, LinkButton } = await import("chat");
+      const linkButton: any = LinkButton({
+        url: options.url,
+        label: options.urlLabel || "Open",
+      });
+      if (options.webApp) {
+        linkButton.webApp = true;
+      }
+      const card = Card({
+        children: [CardText(text), Actions([linkButton])],
+      });
+      await postFn({
+        card,
+        fallbackText: `${text}\n${options.urlLabel || "Open"}: ${options.url}`,
+      });
+      return;
+    }
+    await postFn(text);
+  };
+}