@dobby.ai/dobby 0.1.0

package/src/cli/tests/routing-config.test.ts

@@ -0,0 +1,209 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { loadGatewayConfig } from "../../core/routing.js";
+
+async function writeTempConfig(payload: unknown): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "dobby-routing-"));
+  const configPath = join(dir, "gateway.json");
+  await writeFile(configPath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+  return configPath;
+}
+
+async function writeRepoTempConfig(payload: unknown): Promise<{ repoRoot: string; configPath: string }> {
+  const repoRoot = await mkdtemp(join(tmpdir(), "dobby-routing-repo-"));
+  const configDir = join(repoRoot, "config");
+  await mkdir(configDir, { recursive: true });
+  await mkdir(join(repoRoot, "scripts"), { recursive: true });
+  await writeFile(join(repoRoot, "package.json"), JSON.stringify({ name: "dobby" }), "utf-8");
+  await writeFile(join(repoRoot, "scripts", "local-extensions.mjs"), "#!/usr/bin/env node\n", "utf-8");
+
+  const configPath = join(configDir, "gateway.json");
+  await writeFile(configPath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+  return { repoRoot, configPath };
+}
+
+function validConfig(): Record<string, unknown> {
+  return {
+    extensions: { allowList: [] },
+    providers: {
+      default: "pi.main",
+      items: {
+        "pi.main": {
+          type: "provider.pi",
+        },
+      },
+    },
+    connectors: {
+      items: {
+        "discord.main": {
+          type: "connector.discord",
+          botName: "dobby-main",
+          botToken: "token",
+        },
+      },
+    },
+    sandboxes: {
+      default: "host.builtin",
+      items: {},
+    },
+    routes: {
+      defaults: {
+        provider: "pi.main",
+        sandbox: "host.builtin",
+        tools: "full",
+        mentions: "required",
+      },
+      items: {
+        main: {
+          projectRoot: "./workspace/project-a",
+          systemPromptFile: "./prompts/main.md",
+        },
+      },
+    },
+    bindings: {
+      items: {
+        "discord.main.main": {
+          connector: "discord.main",
+          source: {
+            type: "channel",
+            id: "123",
+          },
+          route: "main",
+        },
+      },
+    },
+    data: {
+      rootDir: "./data",
+      dedupTtlMs: 604800000,
+    },
+  };
+}
+
+test("loadGatewayConfig applies route defaults and resolves relative paths", async () => {
+  const payload = validConfig();
+  const configPath = await writeTempConfig(payload);
+
+  try {
+    const loaded = await loadGatewayConfig(configPath);
+    const configDir = dirname(configPath);
+
+    assert.equal(loaded.providers.default, "pi.main");
+    assert.deepEqual(loaded.routes.defaults, {
+      provider: "pi.main",
+      sandbox: "host.builtin",
+      tools: "full",
+      mentions: "required",
+    });
+    assert.deepEqual(loaded.routes.items.main, {
+      projectRoot: join(configDir, "workspace/project-a"),
+      systemPromptFile: join(configDir, "prompts/main.md"),
+      provider: "pi.main",
+      sandbox: "host.builtin",
+      tools: "full",
+      mentions: "required",
+    });
+    assert.equal(loaded.data.rootDir, join(configDir, "data"));
+    assert.deepEqual(loaded.bindings.items["discord.main.main"], {
+      connector: "discord.main",
+      source: {
+        type: "channel",
+        id: "123",
+      },
+      route: "main",
+    });
+  } finally {
+    await rm(dirname(configPath), { recursive: true, force: true });
+  }
+});
+
+test("loadGatewayConfig resolves data.rootDir from repo root for repo-local config/gateway.json", async () => {
+  const payload = validConfig();
+  const { repoRoot, configPath } = await writeRepoTempConfig(payload);
+
+  try {
+    const loaded = await loadGatewayConfig(configPath);
+    const mainRoute = loaded.routes.items.main;
+    assert.ok(mainRoute);
+    assert.equal(loaded.data.rootDir, join(repoRoot, "data"));
+    assert.equal(mainRoute.projectRoot, join(repoRoot, "workspace/project-a"));
+  } finally {
+    await rm(repoRoot, { recursive: true, force: true });
+  }
+});
+
+test("loadGatewayConfig rejects connector fields reserved by the host", async () => {
+  const payload = validConfig();
+  payload.connectors = {
+    items: {
+      "discord.main": {
+        type: "connector.discord",
+        botName: "dobby-main",
+        botToken: "token",
+        botChannelMap: {
+          "123": "main",
+        },
+      },
+    },
+  };
+
+  const configPath = await writeTempConfig(payload);
+  try {
+    await assert.rejects(loadGatewayConfig(configPath), /must not include 'botChannelMap'/);
+  } finally {
+    await rm(dirname(configPath), { recursive: true, force: true });
+  }
+});
+
+test("loadGatewayConfig rejects connector env indirection fields reserved by the host", async () => {
+  const payload = validConfig();
+  payload.connectors = {
+    items: {
+      "discord.main": {
+        type: "connector.discord",
+        botName: "dobby-main",
+        botTokenEnv: "DISCORD_BOT_TOKEN",
+      },
+    },
+  };
+
+  const configPath = await writeTempConfig(payload);
+  try {
+    await assert.rejects(loadGatewayConfig(configPath), /must not include 'botTokenEnv'/);
+  } finally {
+    await rm(dirname(configPath), { recursive: true, force: true });
+  }
+});
+
+test("loadGatewayConfig fails fast on duplicate binding sources", async () => {
+  const payload = validConfig();
+  payload.bindings = {
+    items: {
+      "discord.main.main": {
+        connector: "discord.main",
+        source: {
+          type: "channel",
+          id: "123",
+        },
+        route: "main",
+      },
+      "discord.main.duplicate": {
+        connector: "discord.main",
+        source: {
+          type: "channel",
+          id: "123",
+        },
+        route: "main",
+      },
+    },
+  };
+
+  const configPath = await writeTempConfig(payload);
+  try {
+    await assert.rejects(loadGatewayConfig(configPath), /duplicates source 'discord\.main:channel:123'/);
+  } finally {
+    await rm(dirname(configPath), { recursive: true, force: true });
+  }
+});

package/src/core/control-command.ts

@@ -0,0 +1,12 @@
+export type ControlCommand = "cancel" | "new_session";
+
+const CANCEL_COMMANDS = new Set(["stop", "/stop", "/cancel"]);
+const NEW_SESSION_COMMANDS = new Set(["/new", "/reset"]);
+
+export function parseControlCommand(text: string): ControlCommand | null {
+  const normalized = text.trim().toLowerCase();
+  if (normalized.length === 0) return null;
+  if (CANCEL_COMMANDS.has(normalized)) return "cancel";
+  if (NEW_SESSION_COMMANDS.has(normalized)) return "new_session";
+  return null;
+}

package/src/core/dedup-store.ts

@@ -0,0 +1,103 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import type { GatewayLogger } from "./types.js";
+
+interface DedupSnapshot {
+  version: 1;
+  entries: Record<string, number>;
+}
+
+export class DedupStore {
+  private readonly entries = new Map<string, number>();
+  private dirty = false;
+  private flushTimer: NodeJS.Timeout | null = null;
+
+  constructor(
+    private readonly filePath: string,
+    private readonly ttlMs: number,
+    private readonly logger: GatewayLogger,
+  ) {}
+
+  async load(): Promise<void> {
+    try {
+      const raw = await readFile(this.filePath, "utf-8");
+      const snapshot = JSON.parse(raw) as DedupSnapshot;
+      const now = Date.now();
+      for (const [key, expiresAt] of Object.entries(snapshot.entries ?? {})) {
+        if (expiresAt > now) {
+          this.entries.set(key, expiresAt);
+        }
+      }
+    } catch {
+      // First start or malformed file; start clean.
+    }
+  }
+
+  startAutoFlush(intervalMs = 15000): void {
+    if (this.flushTimer) return;
+    this.flushTimer = setInterval(() => {
+      void this.flush();
+    }, intervalMs);
+  }
+
+  stopAutoFlush(): void {
+    if (!this.flushTimer) return;
+    clearInterval(this.flushTimer);
+    this.flushTimer = null;
+  }
+
+  has(key: string): boolean {
+    const now = Date.now();
+    const expiresAt = this.entries.get(key);
+    if (!expiresAt) return false;
+    if (expiresAt <= now) {
+      this.entries.delete(key);
+      this.dirty = true;
+      return false;
+    }
+    return true;
+  }
+
+  add(key: string): void {
+    const expiresAt = Date.now() + this.ttlMs;
+    this.entries.set(key, expiresAt);
+    this.dirty = true;
+
+    if (this.entries.size % 100 === 0) {
+      this.sweepExpired();
+    }
+  }
+
+  sweepExpired(): void {
+    const now = Date.now();
+    let removed = 0;
+
+    for (const [key, expiresAt] of this.entries.entries()) {
+      if (expiresAt <= now) {
+        this.entries.delete(key);
+        removed += 1;
+      }
+    }
+
+    if (removed > 0) {
+      this.dirty = true;
+    }
+  }
+
+  async flush(): Promise<void> {
+    if (!this.dirty) return;
+
+    const snapshot: DedupSnapshot = {
+      version: 1,
+      entries: Object.fromEntries(this.entries.entries()),
+    };
+
+    try {
+      await mkdir(dirname(this.filePath), { recursive: true });
+      await writeFile(this.filePath, JSON.stringify(snapshot, null, 2), "utf-8");
+      this.dirty = false;
+    } catch (error) {
+      this.logger.error({ err: error, filePath: this.filePath }, "Failed to flush dedup store");
+    }
+  }
+}