@dobby.ai/dobby 0.1.0

package/dist/src/cli/tests/routing-legacy.test.js

@@ -0,0 +1,191 @@
+import assert from "node:assert/strict";
+import { 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) {
+    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;
+}
+function validConfig() {
+    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 fails fast on legacy top-level routing", async () => {
+    const payload = validConfig();
+    payload.routing = {
+        routes: {
+            main: {
+                projectRoot: process.cwd(),
+            },
+        },
+    };
+    const configPath = await writeTempConfig(payload);
+    try {
+        await assert.rejects(loadGatewayConfig(configPath), /top-level field 'routing'/);
+    }
+    finally {
+        await rm(dirname(configPath), { recursive: true, force: true });
+    }
+});
+test("loadGatewayConfig fails fast on legacy botTokenEnv", 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), /botTokenEnv/);
+    }
+    finally {
+        await rm(dirname(configPath), { recursive: true, force: true });
+    }
+});
+test("loadGatewayConfig fails fast on legacy connector route maps", 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), /botChannelMap/);
+    }
+    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/dist/src/core/control-command.js

@@ -0,0 +1,12 @@
+const CANCEL_COMMANDS = new Set(["stop", "/stop", "/cancel"]);
+const NEW_SESSION_COMMANDS = new Set(["/new", "/reset"]);
+export function parseControlCommand(text) {
+    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/dist/src/core/dedup-store.js

@@ -0,0 +1,92 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+export class DedupStore {
+    filePath;
+    ttlMs;
+    logger;
+    entries = new Map();
+    dirty = false;
+    flushTimer = null;
+    constructor(filePath, ttlMs, logger) {
+        this.filePath = filePath;
+        this.ttlMs = ttlMs;
+        this.logger = logger;
+    }
+    async load() {
+        try {
+            const raw = await readFile(this.filePath, "utf-8");
+            const snapshot = JSON.parse(raw);
+            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) {
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setInterval(() => {
+            void this.flush();
+        }, intervalMs);
+    }
+    stopAutoFlush() {
+        if (!this.flushTimer)
+            return;
+        clearInterval(this.flushTimer);
+        this.flushTimer = null;
+    }
+    has(key) {
+        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) {
+        const expiresAt = Date.now() + this.ttlMs;
+        this.entries.set(key, expiresAt);
+        this.dirty = true;
+        if (this.entries.size % 100 === 0) {
+            this.sweepExpired();
+        }
+    }
+    sweepExpired() {
+        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() {
+        if (!this.dirty)
+            return;
+        const snapshot = {
+            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");
+        }
+    }
+}