@agentick/gateway 0.0.1

package/src/__tests__/ws-transport.spec.ts

@@ -0,0 +1,246 @@
+/**
+ * WebSocket Transport Tests
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { WSTransport } from "../ws-transport.js";
+import WebSocket from "ws";
+
+describe("WSTransport", () => {
+  let server: WSTransport;
+  let client: WebSocket;
+  const TEST_PORT = 19999;
+  const TEST_HOST = "127.0.0.1";
+
+  beforeEach(async () => {
+    server = new WSTransport({
+      port: TEST_PORT,
+      host: TEST_HOST,
+    });
+    await server.start();
+  });
+
+  afterEach(async () => {
+    if (client && client.readyState === WebSocket.OPEN) {
+      client.close();
+    }
+    await server.stop();
+  });
+
+  describe("start/stop", () => {
+    it("starts and stops server", async () => {
+      const anotherServer = new WSTransport({
+        port: TEST_PORT + 1,
+        host: TEST_HOST,
+      });
+
+      await anotherServer.start();
+      expect(anotherServer.clientCount).toBe(0);
+
+      await anotherServer.stop();
+    });
+  });
+
+  describe("connections", () => {
+    it("accepts client connection", async () => {
+      const connectionPromise = new Promise<void>((resolve) => {
+        server.on("connection", () => resolve());
+      });
+
+      client = new WebSocket(`ws://${TEST_HOST}:${TEST_PORT}`);
+      await connectionPromise;
+
+      expect(server.clientCount).toBe(1);
+    });
+
+    it("handles client disconnect", async () => {
+      const disconnectPromise = new Promise<string>((resolve) => {
+        server.on("disconnect", (clientId) => resolve(clientId));
+      });
+
+      client = new WebSocket(`ws://${TEST_HOST}:${TEST_PORT}`);
+      await new Promise<void>((resolve) => {
+        client.on("open", () => resolve());
+      });
+
+      client.close();
+      const disconnectedId = await disconnectPromise;
+
+      expect(disconnectedId).toBeDefined();
+      expect(server.clientCount).toBe(0);
+    });
+  });
+
+  describe("authentication", () => {
+    it("authenticates with valid token", async () => {
+      await server.stop();
+
+      server = new WSTransport({
+        port: TEST_PORT,
+        host: TEST_HOST,
+        auth: { type: "token", token: "secret123" },
+      });
+      await server.start();
+
+      client = new WebSocket(`ws://${TEST_HOST}:${TEST_PORT}`);
+      await new Promise<void>((resolve) => {
+        client.on("open", () => resolve());
+      });
+
+      // Track any error responses
+      let gotError = false;
+      client.on("message", (data) => {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "error") gotError = true;
+      });
+
+      client.send(
+        JSON.stringify({
+          type: "connect",
+          clientId: "test-client",
+          token: "secret123",
+        }),
+      );
+
+      // Wait a bit and verify no error was received
+      await new Promise((r) => setTimeout(r, 100));
+      expect(gotError).toBe(false);
+      expect(server.clientCount).toBe(1);
+    });
+
+    it("rejects invalid token", async () => {
+      await server.stop();
+
+      server = new WSTransport({
+        port: TEST_PORT,
+        host: TEST_HOST,
+        auth: { type: "token", token: "secret123" },
+      });
+      await server.start();
+
+      client = new WebSocket(`ws://${TEST_HOST}:${TEST_PORT}`);
+      await new Promise<void>((resolve) => {
+        client.on("open", () => resolve());
+      });
+
+      const responsePromise = new Promise<{ type: string; code?: string }>((resolve) => {
+        client.on("message", (data) => {
+          resolve(JSON.parse(data.toString()));
+        });
+      });
+
+      client.send(
+        JSON.stringify({
+          type: "connect",
+          clientId: "test-client",
+          token: "wrong-token",
+        }),
+      );
+
+      const response = await responsePromise;
+      expect(response.type).toBe("error");
+      expect(response.code).toBe("AUTH_FAILED");
+    });
+
+    it("allows connection without auth when not configured", async () => {
+      client = new WebSocket(`ws://${TEST_HOST}:${TEST_PORT}`);
+      await new Promise<void>((resolve) => {
+        client.on("open", () => resolve());
+      });
+
+      const responsePromise = new Promise<{ type: string }>((resolve) => {
+        client.on("message", (data) => {
+          resolve(JSON.parse(data.toString()));
+        });
+      });
+
+      client.send(
+        JSON.stringify({
+          type: "connect",
+          clientId: "test-client",
+        }),
+      );
+
+      // Should not get auth error
+      // Since no auth configured, any connect should work
+      await new Promise((r) => setTimeout(r, 100));
+      expect(server.clientCount).toBe(1);
+    });
+  });
+
+  describe("ping/pong", () => {
+    it("responds to ping with pong", async () => {
+      client = new WebSocket(`ws://${TEST_HOST}:${TEST_PORT}`);
+      await new Promise<void>((resolve) => {
+        client.on("open", () => resolve());
+      });
+
+      // Connect first
+      client.send(
+        JSON.stringify({
+          type: "connect",
+          clientId: "test-client",
+        }),
+      );
+
+      const pongPromise = new Promise<{ type: string; timestamp: number }>((resolve) => {
+        client.on("message", (data) => {
+          const msg = JSON.parse(data.toString());
+          if (msg.type === "pong") {
+            resolve(msg);
+          }
+        });
+      });
+
+      const timestamp = Date.now();
+      client.send(
+        JSON.stringify({
+          type: "ping",
+          timestamp,
+        }),
+      );
+
+      const pong = await pongPromise;
+      expect(pong.type).toBe("pong");
+      expect(pong.timestamp).toBe(timestamp);
+    });
+  });
+
+  describe("broadcast", () => {
+    it("broadcasts to authenticated clients", async () => {
+      // Connect two clients
+      const client1 = new WebSocket(`ws://${TEST_HOST}:${TEST_PORT}`);
+      const client2 = new WebSocket(`ws://${TEST_HOST}:${TEST_PORT}`);
+
+      await Promise.all([
+        new Promise<void>((r) => client1.on("open", () => r())),
+        new Promise<void>((r) => client2.on("open", () => r())),
+      ]);
+
+      // Authenticate both
+      client1.send(JSON.stringify({ type: "connect", clientId: "c1" }));
+      client2.send(JSON.stringify({ type: "connect", clientId: "c2" }));
+
+      await new Promise((r) => setTimeout(r, 50));
+
+      const messages: unknown[] = [];
+      client1.on("message", (data) => messages.push(JSON.parse(data.toString())));
+      client2.on("message", (data) => messages.push(JSON.parse(data.toString())));
+
+      server.broadcast({
+        type: "event",
+        event: "test_event",
+        sessionId: "test",
+        data: { foo: "bar" },
+      });
+
+      await new Promise((r) => setTimeout(r, 50));
+
+      const events = messages.filter((m: any) => m.type === "event");
+      expect(events.length).toBeGreaterThanOrEqual(2);
+
+      client1.close();
+      client2.close();
+    });
+  });
+});

package/src/app-registry.ts

@@ -0,0 +1,103 @@
+/**
+ * App Registry
+ *
+ * Manages available apps and their configurations.
+ */
+
+import type { App } from "@agentick/core";
+
+export interface AppInfo {
+  id: string;
+  app: App;
+  name?: string;
+  description?: string;
+  isDefault: boolean;
+}
+
+export class AppRegistry {
+  private apps = new Map<string, AppInfo>();
+  private defaultAppId: string;
+
+  constructor(apps: Record<string, App>, defaultApp: string) {
+    if (!apps[defaultApp]) {
+      throw new Error(
+        `Default app "${defaultApp}" not found in apps: ${Object.keys(apps).join(", ")}`,
+      );
+    }
+
+    this.defaultAppId = defaultApp;
+
+    for (const [id, app] of Object.entries(apps)) {
+      this.apps.set(id, {
+        id,
+        app,
+        isDefault: id === defaultApp,
+      });
+    }
+  }
+
+  /**
+   * Get an app by ID
+   */
+  get(id: string): AppInfo | undefined {
+    return this.apps.get(id);
+  }
+
+  /**
+   * Get the default app
+   */
+  getDefault(): AppInfo {
+    return this.apps.get(this.defaultAppId)!;
+  }
+
+  /**
+   * Get the default app ID
+   */
+  get defaultId(): string {
+    return this.defaultAppId;
+  }
+
+  /**
+   * Check if an app exists
+   */
+  has(id: string): boolean {
+    return this.apps.has(id);
+  }
+
+  /**
+   * Get all app IDs
+   */
+  ids(): string[] {
+    return Array.from(this.apps.keys());
+  }
+
+  /**
+   * Get all apps
+   */
+  all(): AppInfo[] {
+    return Array.from(this.apps.values());
+  }
+
+  /**
+   * Get app count
+   */
+  get size(): number {
+    return this.apps.size;
+  }
+
+  /**
+   * Resolve an app ID, falling back to default
+   */
+  resolve(id?: string): AppInfo {
+    if (!id) {
+      return this.getDefault();
+    }
+
+    const app = this.apps.get(id);
+    if (!app) {
+      throw new Error(`Unknown app "${id}". Available: ${this.ids().join(", ")}`);
+    }
+
+    return app;
+  }
+}

package/src/bin.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+/**
+ * Gateway CLI
+ *
+ * Run the gateway daemon from the command line.
+ */
+
+import { createGateway } from "./gateway.js";
+
+// For now, just a placeholder that shows usage
+console.log("@agentick/gateway");
+console.log("");
+console.log("Usage:");
+console.log("  The gateway is typically started programmatically:");
+console.log("");
+console.log("  ```typescript");
+console.log("  import { createGateway } from '@agentick/gateway';");
+console.log("  import { createApp } from '@agentick/core';");
+console.log("");
+console.log("  const Agent = () => (");
+console.log("    <>");
+console.log("      <Model model={gpt4} />");
+console.log("      <System>You are a helpful assistant.</System>");
+console.log("      <Timeline />");
+console.log("    </>");
+console.log("  );");
+console.log("");
+console.log("  const gateway = createGateway({");
+console.log("    agents: { chat: createApp(Agent) },");
+console.log("    defaultAgent: 'chat',");
+console.log("    port: 18789,");
+console.log("  });");
+console.log("");
+console.log("  await gateway.start();");
+console.log("  ```");
+console.log("");
+console.log("Future versions will support a config file:");
+console.log("  agentick-gateway --config ./gateway.config.ts");