@dobby.ai/dobby 0.1.0 → 0.1.1

package/src/cli/tests/doctor.test.ts

@@ -118,3 +118,152 @@ 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/src/cli/tests/init-catalog.test.ts

@@ -2,95 +2,143 @@ 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",
+    defaultProjectRoot: "/Users/oolong/workspace/dobby",
   });
 
-  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.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",
+    defaultProjectRoot: "/Users/oolong/workspace/dobby",
   });
 
-  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.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",
+  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,
     },
-    route: "support",
-  });
+  }]);
+  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",
-    routeProviderChoiceId: "provider.claude-cli",
-  });
+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/src/cli/tests/program-options.test.ts

@@ -38,7 +38,7 @@ test("init help has no merge/overwrite flags", () => {
   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);
@@ -46,8 +46,8 @@ test("config help shows show/list/edit and schema", () => {
   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);
@@ -79,35 +79,17 @@ test("cron help shows core subcommands", () => {
   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/src/cli/tests/routing-config.test.ts

@@ -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: unknown): Promise<string> {
   const dir = await mkdtemp(join(tmpdir(), "dobby-routing-"));
@@ -17,7 +17,7 @@ async function writeRepoTempConfig(payload: unknown): Promise<{ repoRoot: string
   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");
@@ -50,7 +50,7 @@ function validConfig(): Record<string, unknown> {
       items: {},
     },
     routes: {
-      defaults: {
+      default: {
         provider: "pi.main",
         sandbox: "host.builtin",
         tools: "full",
@@ -91,7 +91,7 @@ test("loadGatewayConfig applies route defaults and resolves relative paths", asy
     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",
@@ -134,6 +134,78 @@ test("loadGatewayConfig resolves data.rootDir from repo root for repo-local conf
   }
 });
 
+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/src/core/gateway.ts

@@ -229,7 +229,9 @@ export class Gateway {
       };
     }
 
-    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(