@dobby.ai/dobby 0.1.0

package/src/cli/tests/config-command.test.ts

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  buildConfigListEntries,
+  CONFIG_SECTION_VALUES,
+  isConfigSection,
+  previewConfigValue,
+} from "../commands/config.js";
+
+test("isConfigSection accepts only supported top-level config sections", () => {
+  for (const section of CONFIG_SECTION_VALUES) {
+    assert.equal(isConfigSection(section), true);
+  }
+
+  assert.equal(isConfigSection("provider"), false);
+  assert.equal(isConfigSection("bot"), false);
+});
+
+test("previewConfigValue returns stable compact previews", () => {
+  assert.equal(previewConfigValue("abc"), "\"abc\"");
+  assert.equal(previewConfigValue(123), "123");
+  assert.equal(previewConfigValue(true), "true");
+  assert.equal(previewConfigValue(null), "null");
+  assert.equal(previewConfigValue({ a: 1, b: 2, c: 3, d: 4 }), "{a, b, c, ...}");
+});
+
+test("buildConfigListEntries summarizes object values with type and child counts", () => {
+  const entries = buildConfigListEntries({
+    providers: {
+      default: "pi.main",
+      items: {
+        "pi.main": { type: "provider.pi" },
+      },
+    },
+    featureFlag: true,
+  });
+
+  assert.deepEqual(
+    entries.map((entry) => ({ key: entry.key, type: entry.type, children: entry.children })),
+    [
+      { key: "featureFlag", type: "boolean", children: undefined },
+      { key: "providers", type: "object", children: 2 },
+    ],
+  );
+});
+
+test("buildConfigListEntries handles primitive roots", () => {
+  const entries = buildConfigListEntries("plain");
+  assert.deepEqual(entries, [
+    {
+      key: "(value)",
+      type: "string",
+      preview: "\"plain\"",
+    },
+  ]);
+});

package/src/cli/tests/config-io.test.ts

@@ -0,0 +1,92 @@
+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/src/cli/tests/config-mutators.test.ts

@@ -0,0 +1,59 @@
+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/src/cli/tests/doctor.test.ts

@@ -0,0 +1,120 @@
+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: string, payload: unknown): Promise<string> {
+  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: string, configPath: string): Promise<{ code: number | null; output: string }> {
+  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/src/cli/tests/init-catalog.test.ts

@@ -0,0 +1,96 @@
+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/src/cli/tests/program-options.test.ts

@@ -0,0 +1,113 @@
+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 as CommanderError).code, "commander.unknownOption");
+      assert.match(String((error as CommanderError).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/);
+});