@botcord/daemon 0.1.1

package/src/gateway/__tests__/gateway-add-channel.test.ts

@@ -0,0 +1,180 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Gateway } from "../gateway.js";
+import type {
+  ChannelAdapter,
+  ChannelSendContext,
+  ChannelSendResult,
+  ChannelStartContext,
+  ChannelStopContext,
+  GatewayChannelConfig,
+  RuntimeAdapter,
+  RuntimeRunResult,
+} from "../types.js";
+import type { GatewayLogger } from "../log.js";
+
+function silentLogger(): GatewayLogger {
+  return { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} };
+}
+
+class StubChannel implements ChannelAdapter {
+  readonly type = "stub";
+  readonly sends: ChannelSendContext[] = [];
+  readonly stops: ChannelStopContext[] = [];
+  starts: ChannelStartContext[] = [];
+
+  constructor(public readonly id: string, public readonly accountId: string) {}
+
+  async start(ctx: ChannelStartContext): Promise<void> {
+    this.starts.push(ctx);
+    await new Promise<void>((resolve) => {
+      ctx.abortSignal.addEventListener("abort", () => resolve(), { once: true });
+    });
+  }
+
+  async stop(ctx: ChannelStopContext): Promise<void> {
+    this.stops.push(ctx);
+  }
+
+  async send(ctx: ChannelSendContext): Promise<ChannelSendResult> {
+    this.sends.push(ctx);
+    return {};
+  }
+}
+
+class StubRuntime implements RuntimeAdapter {
+  readonly id = "claude-code";
+  async run(): Promise<RuntimeRunResult> {
+    return { text: "ok", newSessionId: "s1" };
+  }
+}
+
+describe("Gateway.addChannel / removeChannel", () => {
+  let dirs: string[] = [];
+
+  beforeEach(() => {
+    dirs = [];
+  });
+
+  afterEach(async () => {
+    for (const d of dirs) await rm(d, { recursive: true, force: true });
+  });
+
+  async function makeTempPath(): Promise<string> {
+    const dir = await mkdtemp(path.join(tmpdir(), "gw-add-"));
+    dirs.push(dir);
+    return path.join(dir, "sessions.json");
+  }
+
+  it("addChannel starts a new channel without restarting existing ones", async () => {
+    const createChannel = vi.fn(
+      (cfg: GatewayChannelConfig) => new StubChannel(cfg.id, cfg.accountId),
+    );
+    const gw = new Gateway({
+      config: {
+        channels: [{ id: "ag_a", type: "stub", accountId: "ag_a" }],
+        defaultRoute: { runtime: "claude-code", cwd: "/tmp" },
+        routes: [],
+      },
+      sessionStorePath: await makeTempPath(),
+      createChannel,
+      createRuntime: () => new StubRuntime(),
+      log: silentLogger(),
+    });
+
+    await gw.start();
+    await new Promise((r) => setTimeout(r, 5));
+    expect(createChannel).toHaveBeenCalledTimes(1);
+
+    await gw.addChannel({ id: "ag_b", type: "stub", accountId: "ag_b" });
+    await new Promise((r) => setTimeout(r, 5));
+
+    expect(createChannel).toHaveBeenCalledTimes(2);
+    const snap = gw.snapshot();
+    expect(Object.keys(snap.channels).sort()).toEqual(["ag_a", "ag_b"]);
+    expect(snap.channels["ag_a"].running).toBe(true);
+    expect(snap.channels["ag_b"].running).toBe(true);
+
+    await gw.stop();
+  });
+
+  it("addChannel rejects duplicate id", async () => {
+    const createChannel = (cfg: GatewayChannelConfig) =>
+      new StubChannel(cfg.id, cfg.accountId);
+    const gw = new Gateway({
+      config: {
+        channels: [{ id: "ag_a", type: "stub", accountId: "ag_a" }],
+        defaultRoute: { runtime: "claude-code", cwd: "/tmp" },
+        routes: [],
+      },
+      sessionStorePath: await makeTempPath(),
+      createChannel,
+      createRuntime: () => new StubRuntime(),
+      log: silentLogger(),
+    });
+    await gw.start();
+
+    await expect(
+      gw.addChannel({ id: "ag_a", type: "stub", accountId: "ag_a" }),
+    ).rejects.toThrow(/already registered/);
+    await gw.stop();
+  });
+
+  it("removeChannel stops the channel and drops it from the snapshot", async () => {
+    const channels: StubChannel[] = [];
+    const createChannel = (cfg: GatewayChannelConfig) => {
+      const c = new StubChannel(cfg.id, cfg.accountId);
+      channels.push(c);
+      return c;
+    };
+    const gw = new Gateway({
+      config: {
+        channels: [
+          { id: "ag_a", type: "stub", accountId: "ag_a" },
+          { id: "ag_b", type: "stub", accountId: "ag_b" },
+        ],
+        defaultRoute: { runtime: "claude-code", cwd: "/tmp" },
+        routes: [],
+      },
+      sessionStorePath: await makeTempPath(),
+      createChannel,
+      createRuntime: () => new StubRuntime(),
+      log: silentLogger(),
+    });
+
+    await gw.start();
+    await new Promise((r) => setTimeout(r, 5));
+
+    await gw.removeChannel("ag_a", "test");
+
+    const snap = gw.snapshot();
+    expect(Object.keys(snap.channels)).toEqual(["ag_b"]);
+    const a = channels.find((c) => c.id === "ag_a")!;
+    expect(a.stops.length).toBe(1);
+    expect(a.starts[0].abortSignal.aborted).toBe(true);
+    // ag_b untouched
+    const b = channels.find((c) => c.id === "ag_b")!;
+    expect(b.stops.length).toBe(0);
+
+    await gw.stop();
+  });
+
+  it("removeChannel is a no-op on unknown id", async () => {
+    const gw = new Gateway({
+      config: {
+        channels: [{ id: "ag_a", type: "stub", accountId: "ag_a" }],
+        defaultRoute: { runtime: "claude-code", cwd: "/tmp" },
+        routes: [],
+      },
+      sessionStorePath: await makeTempPath(),
+      createChannel: (cfg) => new StubChannel(cfg.id, cfg.accountId),
+      createRuntime: () => new StubRuntime(),
+      log: silentLogger(),
+    });
+    await gw.start();
+    await expect(gw.removeChannel("ag_nope")).resolves.toBeUndefined();
+    await gw.stop();
+  });
+});

package/src/gateway/__tests__/gateway-managed-routes.test.ts

@@ -0,0 +1,181 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { Gateway } from "../gateway.js";
+import { resolveRoute } from "../router.js";
+import type {
+  ChannelAdapter,
+  ChannelSendContext,
+  ChannelSendResult,
+  ChannelStartContext,
+  ChannelStopContext,
+  GatewayChannelConfig,
+  GatewayInboundMessage,
+  GatewayRoute,
+} from "../types.js";
+import type { GatewayLogger } from "../log.js";
+
+function silentLogger(): GatewayLogger {
+  return { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} };
+}
+
+class StubChannel implements ChannelAdapter {
+  readonly type = "stub";
+  constructor(public readonly id: string, public readonly accountId: string) {}
+  async start(ctx: ChannelStartContext): Promise<void> {
+    await new Promise<void>((resolve) => {
+      ctx.abortSignal.addEventListener("abort", () => resolve(), { once: true });
+    });
+  }
+  async stop(_ctx: ChannelStopContext): Promise<void> {}
+  async send(_ctx: ChannelSendContext): Promise<ChannelSendResult> {
+    return {};
+  }
+}
+
+function makeMessage(overrides: Partial<GatewayInboundMessage> = {}): GatewayInboundMessage {
+  return {
+    id: "m_1",
+    channel: "botcord",
+    accountId: "ag_1",
+    conversation: { id: "rm_1", kind: "group" },
+    sender: { id: "ag_sender", kind: "agent" },
+    text: "hi",
+    raw: {},
+    receivedAt: 0,
+    ...overrides,
+  };
+}
+
+function makeRoute(overrides: Partial<GatewayRoute> = {}): GatewayRoute {
+  return { runtime: "claude-code", cwd: "/tmp", ...overrides };
+}
+
+describe("Gateway managed-route API", () => {
+  const defaultRoute: GatewayRoute = makeRoute({ runtime: "default", cwd: "/default" });
+  let dirs: string[] = [];
+  let gateway: Gateway | null = null;
+
+  beforeEach(() => {
+    dirs = [];
+    gateway = null;
+  });
+
+  afterEach(async () => {
+    if (gateway) await gateway.stop("test");
+    for (const d of dirs) await rm(d, { recursive: true, force: true });
+  });
+
+  async function makeGateway(
+    channels: GatewayChannelConfig[] = [],
+    userRoutes: GatewayRoute[] = [],
+  ): Promise<Gateway> {
+    const dir = await mkdtemp(path.join(tmpdir(), "gw-mr-"));
+    dirs.push(dir);
+    const gw = new Gateway({
+      config: { channels, defaultRoute, routes: userRoutes },
+      sessionStorePath: path.join(dir, "sessions.json"),
+      createChannel: (cfg) => new StubChannel(cfg.id, cfg.accountId),
+      log: silentLogger(),
+    });
+    gateway = gw;
+    return gw;
+  }
+
+  it("upsertManagedRoute adds a route and listManagedRoutes reflects it", async () => {
+    const gw = await makeGateway();
+    const route = makeRoute({ runtime: "r1", cwd: "/ws/ag_1", match: { accountId: "ag_1" } });
+    gw.upsertManagedRoute("ag_1", route);
+    expect(gw.listManagedRoutes()).toEqual([route]);
+  });
+
+  it("upsertManagedRoute on existing accountId replaces (no duplicate)", async () => {
+    const gw = await makeGateway();
+    const first = makeRoute({ runtime: "r1", match: { accountId: "ag_1" } });
+    const second = makeRoute({ runtime: "r2", match: { accountId: "ag_1" } });
+    gw.upsertManagedRoute("ag_1", first);
+    gw.upsertManagedRoute("ag_1", second);
+    expect(gw.listManagedRoutes()).toEqual([second]);
+  });
+
+  it("removeManagedRoute drops the entry; cfg.routes with same accountId untouched", async () => {
+    const user = makeRoute({ runtime: "user", match: { accountId: "ag_1" } });
+    const gw = await makeGateway([], [user]);
+    gw.upsertManagedRoute("ag_1", makeRoute({ runtime: "managed", match: { accountId: "ag_1" } }));
+    gw.removeManagedRoute("ag_1");
+    expect(gw.listManagedRoutes()).toEqual([]);
+
+    const msg = makeMessage({ accountId: "ag_1" });
+    expect(resolveRoute(msg, { defaultRoute, routes: [user] }, gw.listManagedRoutes())).toBe(user);
+  });
+
+  it("removeManagedRoute on unknown accountId is a no-op", async () => {
+    const gw = await makeGateway();
+    expect(() => gw.removeManagedRoute("ag_missing")).not.toThrow();
+    expect(gw.listManagedRoutes()).toEqual([]);
+  });
+
+  it("replaceManagedRoutes(new Map()) wipes synthesized without touching cfg.routes", async () => {
+    const user = makeRoute({ runtime: "user", match: { accountId: "ag_2" } });
+    const gw = await makeGateway([], [user]);
+    gw.upsertManagedRoute("ag_1", makeRoute({ runtime: "m1" }));
+    gw.upsertManagedRoute("ag_9", makeRoute({ runtime: "m2" }));
+    gw.replaceManagedRoutes(new Map());
+    expect(gw.listManagedRoutes()).toEqual([]);
+
+    const msg = makeMessage({ accountId: "ag_2" });
+    expect(resolveRoute(msg, { defaultRoute, routes: [user] }, gw.listManagedRoutes())).toBe(user);
+  });
+
+  it("replaceManagedRoutes swaps contents atomically", async () => {
+    const gw = await makeGateway();
+    gw.upsertManagedRoute("ag_old", makeRoute({ runtime: "old" }));
+    const next = new Map<string, GatewayRoute>();
+    const newRoute = makeRoute({ runtime: "new", match: { accountId: "ag_new" } });
+    next.set("ag_new", newRoute);
+    gw.replaceManagedRoutes(next);
+    expect(gw.listManagedRoutes()).toEqual([newRoute]);
+  });
+
+  it("replaceManagedRoutes decouples from the caller's Map", async () => {
+    const gw = await makeGateway();
+    const src = new Map<string, GatewayRoute>();
+    src.set("ag_1", makeRoute({ runtime: "m1" }));
+    gw.replaceManagedRoutes(src);
+    src.clear();
+    expect(gw.listManagedRoutes()).toHaveLength(1);
+  });
+
+  it("ctor logs (not silently drops) seed managed routes missing accountId", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "gw-mr-bad-"));
+    dirs.push(dir);
+    const warnCalls: unknown[][] = [];
+    const log: GatewayLogger = {
+      info: () => {},
+      warn: (...args: unknown[]) => warnCalls.push(args),
+      error: () => {},
+      debug: () => {},
+    };
+    const gw = new Gateway({
+      config: {
+        channels: [],
+        defaultRoute,
+        routes: [],
+        managedRoutes: [
+          { match: { accountId: "ag_ok" }, runtime: "r", cwd: "/w/ok" },
+          // match.accountId missing — must not crash, must log
+          { match: {}, runtime: "r", cwd: "/w/bad" },
+          // match undefined — same
+          { runtime: "r", cwd: "/w/bad2" },
+        ],
+      },
+      sessionStorePath: path.join(dir, "sessions.json"),
+      createChannel: (cfg) => new StubChannel(cfg.id, cfg.accountId),
+      log,
+    });
+    gateway = gw;
+    expect(gw.listManagedRoutes()).toHaveLength(1);
+    expect(warnCalls.length).toBe(2);
+  });
+});

package/src/gateway/__tests__/gateway.test.ts

@@ -0,0 +1,222 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Gateway } from "../gateway.js";
+import type {
+  ChannelAdapter,
+  ChannelSendContext,
+  ChannelSendResult,
+  ChannelStartContext,
+  ChannelStopContext,
+  GatewayChannelConfig,
+  GatewayConfig,
+  GatewayInboundEnvelope,
+  RuntimeAdapter,
+  RuntimeRunResult,
+} from "../types.js";
+import type { GatewayLogger } from "../log.js";
+
+function silentLogger(): GatewayLogger {
+  return { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} };
+}
+
+interface StartCall {
+  ctx: ChannelStartContext;
+  resolve: () => void;
+  promise: Promise<void>;
+}
+
+class StubChannel implements ChannelAdapter {
+  readonly type = "stub";
+  readonly sends: ChannelSendContext[] = [];
+  readonly stops: ChannelStopContext[] = [];
+  starts: StartCall[] = [];
+
+  constructor(public readonly id: string, public readonly accountId: string) {}
+
+  async start(ctx: ChannelStartContext): Promise<void> {
+    let resolveFn!: () => void;
+    const p = new Promise<void>((r) => {
+      resolveFn = r;
+    });
+    const call: StartCall = { ctx, resolve: resolveFn, promise: p };
+    this.starts.push(call);
+    ctx.abortSignal.addEventListener("abort", () => call.resolve(), { once: true });
+    await p;
+  }
+
+  async stop(ctx: ChannelStopContext): Promise<void> {
+    this.stops.push(ctx);
+  }
+
+  async send(ctx: ChannelSendContext): Promise<ChannelSendResult> {
+    this.sends.push(ctx);
+    return {};
+  }
+
+  async emit(env: GatewayInboundEnvelope): Promise<void> {
+    await this.starts[this.starts.length - 1].ctx.emit(env);
+  }
+}
+
+class StubRuntime implements RuntimeAdapter {
+  constructor(public readonly id: string) {}
+  async run(): Promise<RuntimeRunResult> {
+    return { text: "runtime-reply", newSessionId: "sid-1" };
+  }
+}
+
+function baseConfig(): GatewayConfig {
+  return {
+    channels: [
+      { id: "botcord-main", type: "botcord", accountId: "ag_me" },
+      { id: "botcord-b", type: "botcord", accountId: "ag_b" },
+    ],
+    defaultRoute: { runtime: "claude-code", cwd: "/tmp/cwd" },
+    routes: [],
+  };
+}
+
+describe("Gateway", () => {
+  let dirs: string[] = [];
+
+  beforeEach(() => {
+    dirs = [];
+  });
+
+  afterEach(async () => {
+    for (const d of dirs) await rm(d, { recursive: true, force: true });
+  });
+
+  async function makeTempPath(): Promise<string> {
+    const dir = await mkdtemp(path.join(tmpdir(), "gw-gateway-"));
+    dirs.push(dir);
+    return path.join(dir, "sessions.json");
+  }
+
+  it("start() calls createChannel for each config entry, loads session store, starts ChannelManager", async () => {
+    const createChannel = vi.fn((cfg: GatewayChannelConfig) => new StubChannel(cfg.id, cfg.accountId));
+    const sessionStorePath = await makeTempPath();
+
+    const gw = new Gateway({
+      config: baseConfig(),
+      sessionStorePath,
+      createChannel,
+      createRuntime: (id) => new StubRuntime(id),
+      log: silentLogger(),
+    });
+
+    await gw.start();
+
+    expect(createChannel).toHaveBeenCalledTimes(2);
+    expect(createChannel.mock.calls[0][0].id).toBe("botcord-main");
+    expect(createChannel.mock.calls[1][0].id).toBe("botcord-b");
+
+    const snap = gw.snapshot();
+    expect(Object.keys(snap.channels).sort()).toEqual(["botcord-b", "botcord-main"]);
+    expect(snap.channels["botcord-main"].running).toBe(true);
+
+    await gw.stop("test");
+  });
+
+  it("inbound envelope from a channel reaches the runtime and a reply is sent via that channel", async () => {
+    const channels: StubChannel[] = [];
+    const createChannel = (cfg: GatewayChannelConfig) => {
+      const c = new StubChannel(cfg.id, cfg.accountId);
+      channels.push(c);
+      return c;
+    };
+    const runtime = new StubRuntime("claude-code");
+    const createRuntime = vi.fn(() => runtime);
+
+    const gw = new Gateway({
+      config: {
+        channels: [{ id: "botcord-main", type: "botcord", accountId: "ag_me" }],
+        defaultRoute: { runtime: "claude-code", cwd: "/tmp/cwd" },
+        routes: [],
+      },
+      sessionStorePath: await makeTempPath(),
+      createChannel,
+      createRuntime,
+      log: silentLogger(),
+    });
+
+    await gw.start();
+    const ch = channels[0];
+    // Wait for ChannelManager's microtask that transitions starting→running.
+    await new Promise((r) => setTimeout(r, 5));
+    expect(ch.starts.length).toBe(1);
+
+    const accept = vi.fn(async () => {});
+    await ch.emit({
+      message: {
+        id: "m1",
+        channel: "botcord-main",
+        accountId: "ag_me",
+        conversation: { id: "rm_oc_1", kind: "direct" },
+        sender: { id: "ag_peer", kind: "agent" },
+        text: "hi there",
+        raw: {},
+        receivedAt: Date.now(),
+      },
+      ack: { accept },
+    });
+
+    expect(accept).toHaveBeenCalledTimes(1);
+    expect(createRuntime).toHaveBeenCalledWith("claude-code", undefined);
+    expect(ch.sends.length).toBe(1);
+    expect(ch.sends[0].message.text).toBe("runtime-reply");
+    expect(ch.sends[0].message.replyTo).toBe("m1");
+
+    await gw.stop();
+  });
+
+  it("snapshot() returns { channels, turns } with expected shape", async () => {
+    const createChannel = (cfg: GatewayChannelConfig) => new StubChannel(cfg.id, cfg.accountId);
+    const gw = new Gateway({
+      config: baseConfig(),
+      sessionStorePath: await makeTempPath(),
+      createChannel,
+      createRuntime: (id) => new StubRuntime(id),
+      log: silentLogger(),
+    });
+
+    const snap0 = gw.snapshot();
+    expect(snap0).toHaveProperty("channels");
+    expect(snap0).toHaveProperty("turns");
+    expect(snap0.turns).toEqual({});
+
+    await gw.start();
+    const snap1 = gw.snapshot();
+    expect(Object.keys(snap1.channels).length).toBe(2);
+    await gw.stop();
+  });
+
+  it("stop() aborts running channels and is idempotent", async () => {
+    const channels: StubChannel[] = [];
+    const createChannel = (cfg: GatewayChannelConfig) => {
+      const c = new StubChannel(cfg.id, cfg.accountId);
+      channels.push(c);
+      return c;
+    };
+    const gw = new Gateway({
+      config: baseConfig(),
+      sessionStorePath: await makeTempPath(),
+      createChannel,
+      createRuntime: (id) => new StubRuntime(id),
+      log: silentLogger(),
+    });
+
+    await gw.start();
+    await new Promise((r) => setTimeout(r, 5));
+    await gw.stop("first");
+    await gw.stop("second"); // idempotent
+
+    for (const c of channels) {
+      expect(c.stops.length).toBe(1);
+      expect(c.starts[0].ctx.abortSignal.aborted).toBe(true);
+    }
+    expect(gw.snapshot().channels["botcord-main"].running).toBe(false);
+  });
+});