@dobby.ai/dobby 0.1.0

package/dist/src/cli/tests/doctor.test.js

@@ -0,0 +1,107 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+/**
+ * Writes a temporary default config under HOME/.dobby/gateway.json.
+ */
+async function writeTempHomeConfig(homeDir, payload) {
+    const dobbyDir = join(homeDir, ".dobby");
+    await mkdir(dobbyDir, { recursive: true });
+    const configPath = join(dobbyDir, "gateway.json");
+    await writeFile(configPath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+    return configPath;
+}
+/**
+ * Runs `dobby doctor` in a child process with an isolated HOME directory.
+ */
+async function runDoctorWithHome(homeDir, configPath) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, ["--import", "tsx", "src/main.ts", "doctor"], {
+            cwd: process.cwd(),
+            env: {
+                ...process.env,
+                HOME: homeDir,
+                DOBBY_CONFIG_PATH: configPath,
+            },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let output = "";
+        child.stdout.on("data", (chunk) => {
+            output += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            output += String(chunk);
+        });
+        child.once("error", (error) => reject(error));
+        child.once("close", (code) => {
+            resolve({ code, output });
+        });
+    });
+}
+test("doctor reports invalid binding route references", async () => {
+    const homeDir = await mkdtemp(join(tmpdir(), "dobby-doctor-home-"));
+    try {
+        const configPath = await writeTempHomeConfig(homeDir, {
+            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: process.cwd(),
+                    },
+                },
+            },
+            bindings: {
+                items: {
+                    "discord.main.123": {
+                        connector: "discord.main",
+                        source: {
+                            type: "channel",
+                            id: "123",
+                        },
+                        route: "missing-route",
+                    },
+                },
+            },
+            data: {
+                rootDir: "./data",
+                dedupTtlMs: 604800000,
+            },
+        });
+        const result = await runDoctorWithHome(homeDir, configPath);
+        assert.equal(result.code, 1);
+        assert.equal(result.output.includes("bindings.items['discord.main.123'].route") && result.output.includes("missing-route"), true);
+    }
+    finally {
+        await rm(homeDir, { recursive: true, force: true });
+    }
+});

package/dist/src/cli/tests/init-catalog.test.js

@@ -0,0 +1,87 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createInitSelectionConfig } from "../shared/init-catalog.js";
+test("createInitSelectionConfig wires explicit Discord bot config for provider.pi", () => {
+    const selected = createInitSelectionConfig(["provider.pi"], "connector.discord", {
+        routeId: "main",
+        projectRoot: "/tmp/project",
+        allowAllMessages: false,
+        botName: "dobby-main",
+        botToken: "token-abc",
+        channelId: "123",
+        routeProviderChoiceId: "provider.pi",
+    });
+    assert.deepEqual(selected.connectorConfig, {
+        botName: "dobby-main",
+        botToken: "token-abc",
+        reconnectStaleMs: 60_000,
+        reconnectCheckIntervalMs: 10_000,
+    });
+    assert.deepEqual(selected.providerChoiceIds, ["provider.pi"]);
+    assert.equal(selected.providerInstances.length, 1);
+    assert.equal(selected.providerInstanceId, "pi.main");
+    assert.equal(selected.providerContributionId, "provider.pi");
+    assert.equal(selected.routeProfile.provider, "pi.main");
+    assert.equal(selected.routeProfile.mentions, "required");
+    assert.equal(selected.bindingId, "discord.main.main");
+    assert.deepEqual(selected.bindingConfig, {
+        connector: "discord.main",
+        source: {
+            type: "channel",
+            id: "123",
+        },
+        route: "main",
+    });
+});
+test("createInitSelectionConfig wires explicit Discord bot config for provider.claude-cli", () => {
+    const selected = createInitSelectionConfig(["provider.claude-cli"], "connector.discord", {
+        routeId: "support",
+        projectRoot: "/tmp/project",
+        allowAllMessages: true,
+        botName: "ops-bot",
+        botToken: "token-xyz",
+        channelId: "999",
+        routeProviderChoiceId: "provider.claude-cli",
+    });
+    assert.deepEqual(selected.connectorConfig, {
+        botName: "ops-bot",
+        botToken: "token-xyz",
+        reconnectStaleMs: 60_000,
+        reconnectCheckIntervalMs: 10_000,
+    });
+    assert.deepEqual(selected.providerChoiceIds, ["provider.claude-cli"]);
+    assert.equal(selected.providerInstances.length, 1);
+    assert.equal(selected.providerInstanceId, "claude-cli.main");
+    assert.equal(selected.providerContributionId, "provider.claude-cli");
+    assert.equal(selected.routeProfile.provider, "claude-cli.main");
+    assert.equal(selected.routeProfile.mentions, "optional");
+    assert.deepEqual(selected.bindingConfig, {
+        connector: "discord.main",
+        source: {
+            type: "channel",
+            id: "999",
+        },
+        route: "support",
+    });
+});
+test("createInitSelectionConfig supports multiple providers and uses explicit route provider", () => {
+    const selected = createInitSelectionConfig(["provider.pi", "provider.claude-cli"], "connector.discord", {
+        routeId: "ops",
+        projectRoot: "/tmp/project",
+        allowAllMessages: false,
+        botName: "dobby-multi",
+        botToken: "token-multi",
+        channelId: "777",
+        routeProviderChoiceId: "provider.claude-cli",
+    });
+    assert.deepEqual(selected.providerChoiceIds, ["provider.pi", "provider.claude-cli"]);
+    assert.deepEqual(selected.providerInstances.map((item) => item.instanceId), ["pi.main", "claude-cli.main"]);
+    assert.deepEqual(selected.extensionPackages, [
+        "@dobby.ai/provider-pi",
+        "@dobby.ai/provider-claude-cli",
+        "@dobby.ai/connector-discord",
+    ]);
+    assert.equal(selected.providerInstanceId, "claude-cli.main");
+    assert.equal(selected.routeProfile.provider, "claude-cli.main");
+    assert.equal(selected.routeProviderChoiceId, "provider.claude-cli");
+});

package/dist/src/cli/tests/presets.test.js

@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createPresetConfig } from "../shared/presets.js";
+test("createPresetConfig wires explicit Discord bot config for discord-pi", () => {
+    const preset = createPresetConfig("discord-pi", {
+        routeId: "main",
+        projectRoot: "/tmp/project",
+        allowAllMessages: false,
+        botName: "dobby-main",
+        botToken: "token-abc",
+        channelId: "123",
+    });
+    assert.deepEqual(preset.connectorConfig, {
+        botName: "dobby-main",
+        botToken: "token-abc",
+        botChannelMap: {
+            "123": "main",
+        },
+        reconnectStaleMs: 60_000,
+        reconnectCheckIntervalMs: 10_000,
+    });
+});
+test("createPresetConfig wires explicit Discord bot config for discord-claude-cli", () => {
+    const preset = createPresetConfig("discord-claude-cli", {
+        routeId: "support",
+        projectRoot: "/tmp/project",
+        allowAllMessages: true,
+        botName: "ops-bot",
+        botToken: "token-xyz",
+        channelId: "999",
+    });
+    assert.deepEqual(preset.connectorConfig, {
+        botName: "ops-bot",
+        botToken: "token-xyz",
+        botChannelMap: {
+            "999": "support",
+        },
+        reconnectStaleMs: 60_000,
+        reconnectCheckIntervalMs: 10_000,
+    });
+});

package/dist/src/cli/tests/program-options.test.js

@@ -0,0 +1,92 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { CommanderError } from "commander";
+import { buildProgram } from "../program.js";
+test("CLI rejects --config option", async () => {
+    const program = buildProgram();
+    program.configureOutput({
+        writeErr: () => { },
+        writeOut: () => { },
+    });
+    program.exitOverride();
+    await assert.rejects(program.parseAsync(["node", "dobby", "--config", "./config/gateway.json"]), (error) => {
+        assert.equal(error instanceof CommanderError, true);
+        assert.equal(error.code, "commander.unknownOption");
+        assert.match(String(error.message), /unknown option '--config'/i);
+        return true;
+    });
+});
+test("init help has no merge/overwrite flags", () => {
+    const program = buildProgram();
+    const initCommand = program.commands.find((command) => command.name() === "init");
+    assert.ok(initCommand);
+    const help = initCommand.helpInformation();
+    assert.equal(help.includes("--merge"), false);
+    assert.equal(help.includes("--merge-strategy"), false);
+    assert.equal(help.includes("--overwrite"), false);
+    assert.equal(help.includes("--preset"), false);
+    assert.equal(help.includes("--non-interactive"), false);
+    assert.equal(help.includes("--yes"), false);
+    assert.equal(help.includes("--config"), false);
+});
+test("config help shows show/list/edit and schema", () => {
+    const program = buildProgram();
+    const configCommand = program.commands.find((command) => command.name() === "config");
+    assert.ok(configCommand);
+    const help = configCommand.helpInformation();
+    assert.match(help, /show \[options\] \[section\]/);
+    assert.match(help, /list \[options\] \[section\]/);
+    assert.match(help, /edit \[options\]/);
+    assert.match(help, /schema/);
+    assert.equal(help.includes("get"), false);
+    assert.equal(help.includes("set"), false);
+    assert.equal(help.includes("unset"), false);
+});
+test("config schema help shows list/show subcommands", () => {
+    const program = buildProgram();
+    const configCommand = program.commands.find((command) => command.name() === "config");
+    assert.ok(configCommand);
+    const schemaCommand = configCommand.commands.find((command) => command.name() === "schema");
+    assert.ok(schemaCommand);
+    const help = schemaCommand.helpInformation();
+    assert.match(help, /list \[options\]/);
+    assert.match(help, /show \[options\] <contributionId>/);
+});
+test("cron help shows core subcommands", () => {
+    const program = buildProgram();
+    const cronCommand = program.commands.find((command) => command.name() === "cron");
+    assert.ok(cronCommand);
+    const help = cronCommand.helpInformation();
+    assert.match(help, /add \[options\] <name>/);
+    assert.match(help, /list \[options\]/);
+    assert.match(help, /run \[options\] <jobId>/);
+    assert.match(help, /remove \[options\] <jobId>/);
+});
+test("binding help shows list, set, and remove subcommands", () => {
+    const program = buildProgram();
+    const bindingCommand = program.commands.find((command) => command.name() === "binding");
+    assert.ok(bindingCommand);
+    const help = bindingCommand.helpInformation();
+    assert.match(help, /list \[options\]/);
+    assert.match(help, /set \[options\] <bindingId>/);
+    assert.match(help, /remove <bindingId>/);
+});
+test("route help reflects provider, sandbox, mentions, and cascade-bindings options", () => {
+    const program = buildProgram();
+    const routeCommand = program.commands.find((command) => command.name() === "route");
+    assert.ok(routeCommand);
+    const setCommand = routeCommand.commands.find((command) => command.name() === "set");
+    const removeCommand = routeCommand.commands.find((command) => command.name() === "remove");
+    assert.ok(setCommand);
+    assert.ok(removeCommand);
+    const setHelp = setCommand.helpInformation();
+    const removeHelp = removeCommand.helpInformation();
+    assert.match(setHelp, /--provider <id>/);
+    assert.match(setHelp, /--sandbox <id>/);
+    assert.match(setHelp, /--mentions <policy>/);
+    assert.equal(setHelp.includes("--provider-id"), false);
+    assert.equal(setHelp.includes("--sandbox-id"), false);
+    assert.equal(setHelp.includes("--mentions-only"), false);
+    assert.equal(setHelp.includes("--default"), false);
+    assert.match(removeHelp, /--cascade-bindings/);
+});

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

@@ -0,0 +1,199 @@
+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) {
+    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) {
+    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() {
+    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 });
+    }
+});