@dobby.ai/dobby 0.1.0 → 0.1.2

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

@@ -1,64 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { tmpdir } from "node:os";
-import { resolve } from "node:path";
-import test from "node:test";
-import { DEFAULT_CONFIG_PATH, resolveConfigPath, resolveDataRootDir } from "../shared/config-io.js";
-test("resolveConfigPath defaults to $HOME/.dobby/gateway.json", () => {
-    assert.equal(DEFAULT_CONFIG_PATH, resolve(homedir(), ".dobby", "gateway.json"));
-});
-test("resolveConfigPath falls back to default path outside dobby repository", async () => {
-    const cwd = await mkdtemp(resolve(tmpdir(), "dobby-config-path-default-"));
-    assert.equal(resolveConfigPath({ cwd, env: {} }), DEFAULT_CONFIG_PATH);
-});
-test("resolveConfigPath detects local dobby repository config path", async () => {
-    const repoRoot = await mkdtemp(resolve(tmpdir(), "dobby-config-path-repo-"));
-    await mkdir(resolve(repoRoot, "config"), { recursive: true });
-    await mkdir(resolve(repoRoot, "scripts"), { recursive: true });
-    await mkdir(resolve(repoRoot, "src", "cli"), { recursive: true });
-    await writeFile(resolve(repoRoot, "package.json"), JSON.stringify({ name: "dobby" }), "utf-8");
-    await writeFile(resolve(repoRoot, "config", "gateway.json"), "{}", "utf-8");
-    await writeFile(resolve(repoRoot, "scripts", "local-extensions.mjs"), "#!/usr/bin/env node\n", "utf-8");
-    assert.equal(resolveConfigPath({
-        cwd: resolve(repoRoot, "src", "cli"),
-        env: {},
-    }), resolve(repoRoot, "config", "gateway.json"));
-});
-test("resolveConfigPath prioritizes DOBBY_CONFIG_PATH over repository detection", async () => {
-    const repoRoot = await mkdtemp(resolve(tmpdir(), "dobby-config-path-env-priority-"));
-    await mkdir(resolve(repoRoot, "config"), { recursive: true });
-    await mkdir(resolve(repoRoot, "scripts"), { recursive: true });
-    await writeFile(resolve(repoRoot, "package.json"), JSON.stringify({ name: "dobby" }), "utf-8");
-    await writeFile(resolve(repoRoot, "config", "gateway.json"), "{}", "utf-8");
-    await writeFile(resolve(repoRoot, "scripts", "local-extensions.mjs"), "#!/usr/bin/env node\n", "utf-8");
-    const customPath = resolve(tmpdir(), "dobby-custom-gateway.json");
-    assert.equal(resolveConfigPath({
-        cwd: repoRoot,
-        env: { DOBBY_CONFIG_PATH: customPath },
-    }), customPath);
-});
-test("resolveConfigPath supports relative and home-prefixed DOBBY_CONFIG_PATH", async () => {
-    const cwd = await mkdtemp(resolve(tmpdir(), "dobby-config-path-env-expand-"));
-    assert.equal(resolveConfigPath({
-        cwd,
-        env: { DOBBY_CONFIG_PATH: "config/local-gateway.json" },
-    }), resolve(cwd, "config/local-gateway.json"));
-    assert.equal(resolveConfigPath({
-        cwd,
-        env: { DOBBY_CONFIG_PATH: "~/custom-gateway.json" },
-    }), resolve(homedir(), "custom-gateway.json"));
-});
-test("resolveDataRootDir uses repo root for repo-local config/gateway.json", async () => {
-    const repoRoot = await mkdtemp(resolve(tmpdir(), "dobby-data-root-repo-"));
-    await mkdir(resolve(repoRoot, "config"), { recursive: true });
-    await mkdir(resolve(repoRoot, "scripts"), { recursive: true });
-    await writeFile(resolve(repoRoot, "package.json"), JSON.stringify({ name: "dobby" }), "utf-8");
-    await writeFile(resolve(repoRoot, "config", "gateway.json"), "{}", "utf-8");
-    await writeFile(resolve(repoRoot, "scripts", "local-extensions.mjs"), "#!/usr/bin/env node\n", "utf-8");
-    assert.equal(resolveDataRootDir(resolve(repoRoot, "config", "gateway.json"), {
-        data: {
-            rootDir: "./data",
-        },
-    }), resolve(repoRoot, "data"));
-});

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

@@ -1,47 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { applyContributionTemplates, ensureGatewayConfigShape, setDefaultProviderIfMissingOrInvalid, upsertAllowListPackage, } from "../shared/config-mutators.js";
-test("upsertAllowListPackage is idempotent", () => {
-    const config = ensureGatewayConfigShape({});
-    upsertAllowListPackage(config, "@dobby.ai/provider-pi", true);
-    upsertAllowListPackage(config, "@dobby.ai/provider-pi", true);
-    assert.equal(config.extensions?.allowList?.length, 1);
-    assert.equal(config.extensions?.allowList?.[0]?.package, "@dobby.ai/provider-pi");
-    assert.equal(config.extensions?.allowList?.[0]?.enabled, true);
-});
-test("applyContributionTemplates allocates new instance IDs when needed", () => {
-    const config = ensureGatewayConfigShape({
-        providers: {
-            default: "pi.main",
-            items: {
-                "pi.main": {
-                    type: "provider.pi",
-                },
-            },
-        },
-    });
-    const added = applyContributionTemplates(config, {
-        providers: [
-            { id: "pi.main", type: "provider.another", config: {} },
-            { id: "pi.main", type: "provider.third", config: {} },
-        ],
-        connectors: [],
-        sandboxes: [],
-    });
-    assert.deepEqual(added.providers, ["pi.main-2", "pi.main-3"]);
-    assert.equal(config.providers.items["pi.main-2"]?.type, "provider.another");
-    assert.equal(config.providers.items["pi.main-3"]?.type, "provider.third");
-});
-test("setDefaultProviderIfMissingOrInvalid picks lexicographically first provider", () => {
-    const config = ensureGatewayConfigShape({
-        providers: {
-            default: "missing",
-            items: {
-                "z.main": { type: "provider.z" },
-                "a.main": { type: "provider.a" },
-            },
-        },
-    });
-    setDefaultProviderIfMissingOrInvalid(config);
-    assert.equal(config.providers.default, "a.main");
-});

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

@@ -1,21 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { getAtPath, parsePath, setAtPath, unsetAtPath } from "../shared/config-path.js";
-test("parsePath handles dot and bracket notation", () => {
-    assert.deepEqual(parsePath("routing.routes.main.projectRoot"), ["routing", "routes", "main", "projectRoot"]);
-    assert.deepEqual(parsePath("connectors.instances[discord.main].config.botChannelMap[12345]"), ["connectors", "instances", "discord.main", "config", "botChannelMap", "12345"]);
-});
-test("setAtPath and getAtPath support nested objects", () => {
-    const payload = {};
-    setAtPath(payload, parsePath("a.b.c"), 42);
-    const read = getAtPath(payload, parsePath("a.b.c"));
-    assert.equal(read.found, true);
-    assert.equal(read.value, 42);
-});
-test("unsetAtPath removes keys", () => {
-    const payload = { a: { b: { c: 1 } } };
-    const removed = unsetAtPath(payload, parsePath("a.b.c"));
-    assert.equal(removed, true);
-    const read = getAtPath(payload, parsePath("a.b.c"));
-    assert.equal(read.found, false);
-});

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

@@ -1,23 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { normalizeDiscordBotChannelMap } from "../shared/discord-config.js";
-test("normalizeDiscordBotChannelMap keeps valid channel->route entries", () => {
-    const normalized = normalizeDiscordBotChannelMap({
-        "123": "projectA",
-        "456": "projectB",
-    });
-    assert.deepEqual(normalized, {
-        "123": "projectA",
-        "456": "projectB",
-    });
-});
-test("normalizeDiscordBotChannelMap drops invalid values", () => {
-    const normalized = normalizeDiscordBotChannelMap({
-        "123": "projectA",
-        "456": "",
-        "789": 1,
-    });
-    assert.deepEqual(normalized, {
-        "123": "projectA",
-    });
-});

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

@@ -1,107 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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/);
-});