@dobby.ai/dobby 0.1.0 → 0.1.1

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

@@ -0,0 +1,90 @@
+import assert from "node:assert/strict";
+import { access, mkdtemp, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import pino from "pino";
+import { mapDiscordMessage } from "../../../plugins/connector-discord/src/mapper.js";
+function createMessage(overrides) {
+    return {
+        id: overrides?.id ?? "msg-1",
+        content: overrides?.content ?? "hello",
+        author: {
+            id: "user-1",
+            username: "alice",
+            bot: false,
+        },
+        attachments: overrides?.attachments ?? new Map(),
+        mentions: {
+            users: {
+                has: () => false,
+            },
+        },
+        guildId: "guild-1",
+        channelId: "channel-1",
+        channel: {
+            isThread: () => false,
+        },
+        createdTimestamp: 1_700_000_000_000,
+        toJSON: () => ({ ok: true }),
+    };
+}
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const logger = pino({ enabled: false });
+test("mapDiscordMessage does not create attachment directory when message has no attachments", async () => {
+    const root = await mkdtemp(join(tmpdir(), "dobby-discord-mapper-empty-"));
+    const message = createMessage();
+    const envelope = await mapDiscordMessage(message, "discord.main", "bot-1", "source-1", root, logger);
+    assert.ok(envelope);
+    assert.deepEqual(envelope.attachments, []);
+    assert.equal(await pathExists(join(root, "source-1", "msg-1")), false);
+});
+test("mapDiscordMessage only creates attachment directory when a download succeeds", async (t) => {
+    t.mock.method(globalThis, "fetch", async () => new Response("file-body", { status: 200 }));
+    const root = await mkdtemp(join(tmpdir(), "dobby-discord-mapper-file-"));
+    const message = createMessage({
+        attachments: new Map([
+            ["att-1", {
+                    id: "att-1",
+                    name: "hello.png",
+                    contentType: "image/png",
+                    size: 9,
+                    url: "https://example.test/hello.png",
+                }],
+        ]),
+    });
+    const envelope = await mapDiscordMessage(message, "discord.main", "bot-1", "source-1", root, logger);
+    assert.ok(envelope);
+    assert.equal(envelope.attachments.length, 1);
+    assert.equal(await pathExists(join(root, "source-1", "msg-1")), true);
+    assert.equal(envelope.attachments[0]?.localPath, join(root, "source-1", "msg-1", "hello.png"));
+    assert.equal(await readFile(join(root, "source-1", "msg-1", "hello.png"), "utf-8"), "file-body");
+});
+test("mapDiscordMessage does not leave an empty attachment directory when download fails", async (t) => {
+    t.mock.method(globalThis, "fetch", async () => new Response("nope", { status: 500 }));
+    const root = await mkdtemp(join(tmpdir(), "dobby-discord-mapper-fail-"));
+    const message = createMessage({
+        attachments: new Map([
+            ["att-1", {
+                    id: "att-1",
+                    name: "broken.png",
+                    contentType: "image/png",
+                    size: 9,
+                    url: "https://example.test/broken.png",
+                }],
+        ]),
+    });
+    const envelope = await mapDiscordMessage(message, "discord.main", "bot-1", "source-1", root, logger);
+    assert.ok(envelope);
+    assert.equal(envelope.attachments.length, 1);
+    assert.equal(envelope.attachments[0]?.localPath, undefined);
+    assert.equal(await pathExists(join(root, "source-1", "msg-1")), false);
+});

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

@@ -105,3 +105,148 @@ test("doctor reports invalid binding route references", async () => {
         await rm(homeDir, { recursive: true, force: true });
     }
 });
+test("doctor reports invalid default binding route references", async () => {
+    const homeDir = await mkdtemp(join(tmpdir(), "dobby-doctor-default-binding-"));
+    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: {
+                    projectRoot: process.cwd(),
+                    provider: "pi.main",
+                    sandbox: "host.builtin",
+                    tools: "full",
+                    mentions: "required",
+                },
+                items: {
+                    main: {},
+                },
+            },
+            bindings: {
+                default: {
+                    route: "missing-route",
+                },
+                items: {},
+            },
+            data: {
+                rootDir: "./data",
+                dedupTtlMs: 604800000,
+            },
+        });
+        const result = await runDoctorWithHome(homeDir, configPath);
+        assert.equal(result.code, 1);
+        assert.equal(result.output.includes("bindings.default.route") && result.output.includes("missing-route"), true);
+    }
+    finally {
+        await rm(homeDir, { recursive: true, force: true });
+    }
+});
+test("doctor reports init template placeholders as errors and warnings", async () => {
+    const homeDir = await mkdtemp(join(tmpdir(), "dobby-doctor-placeholders-"));
+    try {
+        const configPath = await writeTempHomeConfig(homeDir, {
+            extensions: { allowList: [] },
+            providers: {
+                default: "pi.main",
+                items: {
+                    "pi.main": {
+                        type: "provider.pi",
+                        model: "REPLACE_WITH_PROVIDER_MODEL_ID",
+                        baseUrl: "REPLACE_WITH_PROVIDER_BASE_URL",
+                        apiKey: "REPLACE_WITH_PROVIDER_API_KEY_OR_ENV",
+                    },
+                },
+            },
+            connectors: {
+                items: {
+                    "discord.main": {
+                        type: "connector.discord",
+                        botName: "dobby-main",
+                        botToken: "REPLACE_WITH_DISCORD_BOT_TOKEN",
+                    },
+                    "feishu.main": {
+                        type: "connector.feishu",
+                        appId: "REPLACE_WITH_FEISHU_APP_ID",
+                        appSecret: "REPLACE_WITH_FEISHU_APP_SECRET",
+                    },
+                },
+            },
+            sandboxes: {
+                default: "host.builtin",
+                items: {},
+            },
+            routes: {
+                defaults: {
+                    provider: "pi.main",
+                    sandbox: "host.builtin",
+                    tools: "full",
+                    mentions: "required",
+                },
+                items: {
+                    main: {
+                        projectRoot: "./REPLACE_WITH_PROJECT_ROOT",
+                    },
+                },
+            },
+            bindings: {
+                items: {
+                    "discord.main.main": {
+                        connector: "discord.main",
+                        source: {
+                            type: "channel",
+                            id: "YOUR_DISCORD_CHANNEL_ID",
+                        },
+                        route: "main",
+                    },
+                    "feishu.main.main": {
+                        connector: "feishu.main",
+                        source: {
+                            type: "chat",
+                            id: "YOUR_FEISHU_CHAT_ID",
+                        },
+                        route: "main",
+                    },
+                },
+            },
+            data: {
+                rootDir: "./data",
+                dedupTtlMs: 604800000,
+            },
+        });
+        const result = await runDoctorWithHome(homeDir, configPath);
+        assert.equal(result.code, 1);
+        assert.equal(result.output.includes("providers.items['pi.main'].model still uses placeholder value"), true);
+        assert.equal(result.output.includes("providers.items['pi.main'].baseUrl still uses placeholder value"), true);
+        assert.equal(result.output.includes("providers.items['pi.main'].apiKey still uses placeholder value"), true);
+        assert.equal(result.output.includes("connectors.items['discord.main'].botToken still uses placeholder value"), true);
+        assert.equal(result.output.includes("connectors.items['feishu.main'].appId still uses placeholder value"), true);
+        assert.equal(result.output.includes("connectors.items['feishu.main'].appSecret still uses placeholder value"), true);
+        assert.equal(result.output.includes("routes.items['main'].projectRoot still uses placeholder value"), true);
+        assert.equal(result.output.includes("bindings.items['discord.main.main'].source.id still uses placeholder value"), true);
+        assert.equal(result.output.includes("bindings.items['feishu.main.main'].source.id still uses placeholder value"), true);
+    }
+    finally {
+        await rm(homeDir, { recursive: true, force: true });
+    }
+});

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

@@ -1,87 +1,134 @@
 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",
+test("createInitSelectionConfig writes Discord starter template for provider.pi", () => {
+    const selected = createInitSelectionConfig(["provider.pi"], ["connector.discord"], {
         routeProviderChoiceId: "provider.pi",
-    });
-    assert.deepEqual(selected.connectorConfig, {
-        botName: "dobby-main",
-        botToken: "token-abc",
-        reconnectStaleMs: 60_000,
-        reconnectCheckIntervalMs: 10_000,
+        defaultProjectRoot: "/Users/oolong/workspace/dobby",
     });
     assert.deepEqual(selected.providerChoiceIds, ["provider.pi"]);
-    assert.equal(selected.providerInstances.length, 1);
+    assert.deepEqual(selected.connectorChoiceIds, ["connector.discord"]);
+    assert.equal(selected.routeId, "main");
     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",
-        },
+    assert.deepEqual(selected.providerInstances, [{
+            choiceId: "provider.pi",
+            instanceId: "pi.main",
+            contributionId: "provider.pi",
+            config: {
+                model: "REPLACE_WITH_PROVIDER_MODEL_ID",
+                baseUrl: "REPLACE_WITH_PROVIDER_BASE_URL",
+                apiKey: "REPLACE_WITH_PROVIDER_API_KEY_OR_ENV",
+            },
+        }]);
+    assert.deepEqual(selected.connectorInstances, [{
+            choiceId: "connector.discord",
+            instanceId: "discord.main",
+            contributionId: "connector.discord",
+            config: {
+                botName: "dobby-main",
+                botToken: "REPLACE_WITH_DISCORD_BOT_TOKEN",
+                reconnectStaleMs: 60_000,
+                reconnectCheckIntervalMs: 10_000,
+            },
+        }]);
+    assert.deepEqual(selected.routeDefaults, {
+        projectRoot: "/Users/oolong/workspace/dobby",
+        tools: "full",
+        mentions: "required",
+        provider: "pi.main",
+        sandbox: "host.builtin",
+    });
+    assert.deepEqual(selected.routeProfile, {});
+    assert.deepEqual(selected.defaultBinding, {
         route: "main",
     });
+    assert.deepEqual(selected.bindings, [{
+            id: "discord.main.main",
+            config: {
+                connector: "discord.main",
+                source: {
+                    type: "channel",
+                    id: "YOUR_DISCORD_CHANNEL_ID",
+                },
+                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",
+test("createInitSelectionConfig writes Feishu starter template for provider.claude-cli", () => {
+    const selected = createInitSelectionConfig(["provider.claude-cli"], ["connector.feishu"], {
         routeProviderChoiceId: "provider.claude-cli",
-    });
-    assert.deepEqual(selected.connectorConfig, {
-        botName: "ops-bot",
-        botToken: "token-xyz",
-        reconnectStaleMs: 60_000,
-        reconnectCheckIntervalMs: 10_000,
+        defaultProjectRoot: "/Users/oolong/workspace/dobby",
     });
     assert.deepEqual(selected.providerChoiceIds, ["provider.claude-cli"]);
-    assert.equal(selected.providerInstances.length, 1);
+    assert.deepEqual(selected.connectorChoiceIds, ["connector.feishu"]);
+    assert.equal(selected.routeId, "main");
     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",
-    });
+    assert.deepEqual(selected.connectorInstances, [{
+            choiceId: "connector.feishu",
+            instanceId: "feishu.main",
+            contributionId: "connector.feishu",
+            config: {
+                appId: "REPLACE_WITH_FEISHU_APP_ID",
+                appSecret: "REPLACE_WITH_FEISHU_APP_SECRET",
+                domain: "feishu",
+                messageFormat: "card_markdown",
+                replyMode: "direct",
+                downloadAttachments: true,
+            },
+        }]);
+    assert.deepEqual(selected.bindings, [{
+            id: "feishu.main.main",
+            config: {
+                connector: "feishu.main",
+                source: {
+                    type: "chat",
+                    id: "YOUR_FEISHU_CHAT_ID",
+                },
+                route: "main",
+            },
+        }]);
 });
-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",
+test("createInitSelectionConfig supports multiple providers and connectors with one default provider", () => {
+    const selected = createInitSelectionConfig(["provider.pi", "provider.claude-cli"], ["connector.discord", "connector.feishu"], {
         routeProviderChoiceId: "provider.claude-cli",
+        defaultProjectRoot: "/Users/oolong/workspace/dobby",
     });
     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.connectorChoiceIds, ["connector.discord", "connector.feishu"]);
     assert.deepEqual(selected.extensionPackages, [
         "@dobby.ai/provider-pi",
         "@dobby.ai/provider-claude-cli",
         "@dobby.ai/connector-discord",
+        "@dobby.ai/connector-feishu",
     ]);
     assert.equal(selected.providerInstanceId, "claude-cli.main");
-    assert.equal(selected.routeProfile.provider, "claude-cli.main");
+    assert.equal(selected.routeDefaults.provider, "claude-cli.main");
     assert.equal(selected.routeProviderChoiceId, "provider.claude-cli");
+    assert.deepEqual(selected.defaultBinding, {
+        route: "main",
+    });
+    assert.deepEqual(selected.bindings, [
+        {
+            id: "discord.main.main",
+            config: {
+                connector: "discord.main",
+                source: {
+                    type: "channel",
+                    id: "YOUR_DISCORD_CHANNEL_ID",
+                },
+                route: "main",
+            },
+        },
+        {
+            id: "feishu.main.main",
+            config: {
+                connector: "feishu.main",
+                source: {
+                    type: "chat",
+                    id: "YOUR_FEISHU_CHAT_ID",
+                },
+                route: "main",
+            },
+        },
+    ]);
 });

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

@@ -29,15 +29,15 @@ test("init help has no merge/overwrite flags", () => {
     assert.equal(help.includes("--yes"), false);
     assert.equal(help.includes("--config"), false);
 });
-test("config help shows show/list/edit and schema", () => {
+test("config help shows read-only inspect commands 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("edit"), false);
     assert.equal(help.includes("get"), false);
     assert.equal(help.includes("set"), false);
     assert.equal(help.includes("unset"), false);
@@ -62,31 +62,17 @@ test("cron help shows core subcommands", () => {
     assert.match(help, /run \[options\] <jobId>/);
     assert.match(help, /remove \[options\] <jobId>/);
 });
-test("binding help shows list, set, and remove subcommands", () => {
+test("top-level help keeps bootstrap, inspect, install, validate, and ops commands only", () => {
     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/);
+    const help = program.helpInformation();
+    assert.match(help, /start/);
+    assert.match(help, /init/);
+    assert.match(help, /config/);
+    assert.match(help, /extension/);
+    assert.match(help, /doctor/);
+    assert.match(help, /cron/);
+    assert.equal(help.includes("configure"), false);
+    assert.equal(help.includes("bot"), false);
+    assert.equal(help.includes("binding"), false);
+    assert.equal(help.includes("route"), false);
 });

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

@@ -3,7 +3,7 @@ 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";
+import { BindingResolver, loadGatewayConfig } from "../../core/routing.js";
 async function writeTempConfig(payload) {
     const dir = await mkdtemp(join(tmpdir(), "dobby-routing-"));
     const configPath = join(dir, "gateway.json");
@@ -15,7 +15,7 @@ async function writeRepoTempConfig(payload) {
     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, "package.json"), JSON.stringify({ name: "@dobby.ai/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");
@@ -46,7 +46,7 @@ function validConfig() {
             items: {},
         },
         routes: {
-            defaults: {
+            default: {
                 provider: "pi.main",
                 sandbox: "host.builtin",
                 tools: "full",
@@ -84,7 +84,7 @@ test("loadGatewayConfig applies route defaults and resolves relative paths", asy
         const loaded = await loadGatewayConfig(configPath);
         const configDir = dirname(configPath);
         assert.equal(loaded.providers.default, "pi.main");
-        assert.deepEqual(loaded.routes.defaults, {
+        assert.deepEqual(loaded.routes.default, {
             provider: "pi.main",
             sandbox: "host.builtin",
             tools: "full",
@@ -126,6 +126,61 @@ test("loadGatewayConfig resolves data.rootDir from repo root for repo-local conf
         await rm(repoRoot, { recursive: true, force: true });
     }
 });
+test("loadGatewayConfig applies routes.default.projectRoot and bindings.default for direct messages", async () => {
+    const payload = validConfig();
+    payload.routes = {
+        default: {
+            projectRoot: "./workspace/default-root",
+            provider: "pi.main",
+            sandbox: "host.builtin",
+            tools: "full",
+            mentions: "required",
+        },
+        items: {
+            main: {},
+        },
+    };
+    payload.bindings = {
+        default: {
+            route: "main",
+        },
+        items: {},
+    };
+    const configPath = await writeTempConfig(payload);
+    try {
+        const loaded = await loadGatewayConfig(configPath);
+        const configDir = dirname(configPath);
+        const resolver = new BindingResolver(loaded.bindings);
+        assert.deepEqual(loaded.routes.default, {
+            projectRoot: join(configDir, "workspace/default-root"),
+            provider: "pi.main",
+            sandbox: "host.builtin",
+            tools: "full",
+            mentions: "required",
+        });
+        assert.deepEqual(loaded.routes.items.main, {
+            projectRoot: join(configDir, "workspace/default-root"),
+            provider: "pi.main",
+            sandbox: "host.builtin",
+            tools: "full",
+            mentions: "required",
+        });
+        assert.deepEqual(loaded.bindings.default, {
+            route: "main",
+        });
+        assert.equal(resolver.resolve("discord.main", {
+            type: "channel",
+            id: "dm-123",
+        }, { isDirectMessage: true })?.config.route, "main");
+        assert.equal(resolver.resolve("discord.main", {
+            type: "channel",
+            id: "dm-123",
+        }, { isDirectMessage: false }), null);
+    }
+    finally {
+        await rm(dirname(configPath), { recursive: true, force: true });
+    }
+});
 test("loadGatewayConfig rejects connector fields reserved by the host", async () => {
     const payload = validConfig();
     payload.connectors = {

package/dist/src/core/gateway.js

@@ -129,7 +129,9 @@ export class Gateway {
                 route,
             };
         }
-        const binding = this.options.bindingResolver.resolve(message.connectorId, message.source);
+        const binding = this.options.bindingResolver.resolve(message.connectorId, message.source, {
+            isDirectMessage: message.isDirectMessage,
+        });
         if (!binding) {
             if (handling.origin === "connector") {
                 this.options.logger.debug({