@dobby.ai/dobby 0.1.0 → 0.1.1

package/src/cli/shared/init-catalog.ts

@@ -1,44 +1,54 @@
-import type { RawBindingConfig, RawRouteProfile } from "./config-types.js";
+import type {
+  RawBindingConfig,
+  RawDefaultBindingConfig,
+  RawRouteDefaults,
+  RawRouteProfile,
+} from "./config-types.js";
 import {
+  DEFAULT_DISCORD_BOT_NAME,
   DEFAULT_DISCORD_CONNECTOR_INSTANCE_ID,
   DISCORD_CONNECTOR_CONTRIBUTION_ID,
 } from "./discord-config.js";
 
 export type InitProviderChoiceId = "provider.pi" | "provider.claude-cli";
-export type InitConnectorChoiceId = "connector.discord";
+export type InitConnectorChoiceId = "connector.discord" | "connector.feishu";
+
+export const DEFAULT_INIT_ROUTE_ID = "main";
+export const DEFAULT_INIT_PROJECT_ROOT = "./REPLACE_WITH_PROJECT_ROOT";
 
 interface ProviderCatalogEntry {
   id: InitProviderChoiceId;
   label: string;
-  extensionPackage: string;
+  package: string;
   instanceId: string;
   contributionId: string;
-  config: Record<string, unknown>;
+  defaultConfig: Record<string, unknown>;
+}
+
+interface ConnectorBindingTemplate {
+  sourceType: RawBindingConfig["source"]["type"];
+  sourceId: string;
 }
 
 interface ConnectorCatalogEntry {
   id: InitConnectorChoiceId;
   label: string;
-  extensionPackage: string;
+  package: string;
   instanceId: string;
   contributionId: string;
+  defaultConfig: Record<string, unknown>;
+  bindingTemplate: ConnectorBindingTemplate;
 }
 
 export interface InitSelectionContext {
-  routeId: string;
-  projectRoot: string;
-  allowAllMessages: boolean;
-  botName: string;
-  botToken: string;
-  channelId: string;
   routeProviderChoiceId: InitProviderChoiceId;
+  defaultProjectRoot?: string;
 }
 
 export interface InitSelectionResult {
   providerChoiceIds: InitProviderChoiceId[];
   routeProviderChoiceId: InitProviderChoiceId;
-  providerChoiceId: InitProviderChoiceId;
-  connectorChoiceId: InitConnectorChoiceId;
+  connectorChoiceIds: InitConnectorChoiceId[];
   extensionPackages: string[];
   providerInstances: Array<{
     choiceId: InitProviderChoiceId;
@@ -46,38 +56,43 @@ export interface InitSelectionResult {
     contributionId: string;
     config: Record<string, unknown>;
   }>;
+  connectorInstances: Array<{
+    choiceId: InitConnectorChoiceId;
+    instanceId: string;
+    contributionId: string;
+    config: Record<string, unknown>;
+  }>;
   providerInstanceId: string;
-  providerContributionId: string;
-  providerConfig: Record<string, unknown>;
-  connectorInstanceId: string;
-  connectorContributionId: string;
-  connectorConfig: Record<string, unknown>;
+  routeId: string;
+  routeDefaults: RawRouteDefaults;
   routeProfile: RawRouteProfile;
-  bindingId: string;
-  bindingConfig: RawBindingConfig;
+  defaultBinding?: RawDefaultBindingConfig;
+  bindings: Array<{
+    id: string;
+    config: RawBindingConfig;
+  }>;
 }
 
 const PROVIDER_CATALOG: Record<InitProviderChoiceId, ProviderCatalogEntry> = {
   "provider.pi": {
     id: "provider.pi",
     label: "Pi provider",
-    extensionPackage: "@dobby.ai/provider-pi",
+    package: "@dobby.ai/provider-pi",
     instanceId: "pi.main",
     contributionId: "provider.pi",
-    config: {
-      provider: "custom-openai",
-      model: "example-model",
-      thinkingLevel: "off",
-      modelsFile: "./models.custom.json",
+    defaultConfig: {
+      model: "REPLACE_WITH_PROVIDER_MODEL_ID",
+      baseUrl: "REPLACE_WITH_PROVIDER_BASE_URL",
+      apiKey: "REPLACE_WITH_PROVIDER_API_KEY_OR_ENV",
     },
   },
   "provider.claude-cli": {
     id: "provider.claude-cli",
     label: "Claude CLI provider",
-    extensionPackage: "@dobby.ai/provider-claude-cli",
+    package: "@dobby.ai/provider-claude-cli",
     instanceId: "claude-cli.main",
     contributionId: "provider.claude-cli",
-    config: {
+    defaultConfig: {
       model: "claude-sonnet-4-5",
       maxTurns: 20,
       command: "claude",
@@ -93,12 +108,56 @@ const CONNECTOR_CATALOG: Record<InitConnectorChoiceId, ConnectorCatalogEntry> =
   "connector.discord": {
     id: "connector.discord",
     label: "Discord connector",
-    extensionPackage: "@dobby.ai/connector-discord",
+    package: "@dobby.ai/connector-discord",
     instanceId: DEFAULT_DISCORD_CONNECTOR_INSTANCE_ID,
     contributionId: DISCORD_CONNECTOR_CONTRIBUTION_ID,
+    defaultConfig: {
+      botName: DEFAULT_DISCORD_BOT_NAME,
+      botToken: "REPLACE_WITH_DISCORD_BOT_TOKEN",
+      reconnectStaleMs: 60_000,
+      reconnectCheckIntervalMs: 10_000,
+    },
+    bindingTemplate: {
+      sourceType: "channel",
+      sourceId: "YOUR_DISCORD_CHANNEL_ID",
+    },
+  },
+  "connector.feishu": {
+    id: "connector.feishu",
+    label: "Feishu connector",
+    package: "@dobby.ai/connector-feishu",
+    instanceId: "feishu.main",
+    contributionId: "connector.feishu",
+    defaultConfig: {
+      appId: "REPLACE_WITH_FEISHU_APP_ID",
+      appSecret: "REPLACE_WITH_FEISHU_APP_SECRET",
+      domain: "feishu",
+      messageFormat: "card_markdown",
+      replyMode: "direct",
+      downloadAttachments: true,
+    },
+    bindingTemplate: {
+      sourceType: "chat",
+      sourceId: "YOUR_FEISHU_CHAT_ID",
+    },
   },
 };
 
+function dedupeChoiceIds<T extends string>(choiceIds: T[]): T[] {
+  const dedupedChoiceIds: T[] = [];
+  const seenChoiceIds = new Set<T>();
+
+  for (const choiceId of choiceIds) {
+    if (seenChoiceIds.has(choiceId)) {
+      continue;
+    }
+    seenChoiceIds.add(choiceId);
+    dedupedChoiceIds.push(choiceId);
+  }
+
+  return dedupedChoiceIds;
+}
+
 export function listInitProviderChoices(): ProviderCatalogEntry[] {
   return Object.values(PROVIDER_CATALOG);
 }
@@ -117,22 +176,19 @@ export function isInitConnectorChoiceId(value: string): value is InitConnectorCh
 
 export function createInitSelectionConfig(
   providerChoiceIds: InitProviderChoiceId[],
-  connectorChoiceId: InitConnectorChoiceId,
+  connectorChoiceIds: InitConnectorChoiceId[],
   context: InitSelectionContext,
 ): InitSelectionResult {
-  const dedupedProviderChoiceIds: InitProviderChoiceId[] = [];
-  const seenProviderChoiceIds = new Set<InitProviderChoiceId>();
-  for (const providerChoiceId of providerChoiceIds) {
-    if (!seenProviderChoiceIds.has(providerChoiceId)) {
-      seenProviderChoiceIds.add(providerChoiceId);
-      dedupedProviderChoiceIds.push(providerChoiceId);
-    }
-  }
-
+  const dedupedProviderChoiceIds = dedupeChoiceIds(providerChoiceIds);
   if (dedupedProviderChoiceIds.length === 0) {
     throw new Error("At least one provider choice is required");
   }
 
+  const dedupedConnectorChoiceIds = dedupeChoiceIds(connectorChoiceIds);
+  if (dedupedConnectorChoiceIds.length === 0) {
+    throw new Error("At least one connector choice is required");
+  }
+
   if (!dedupedProviderChoiceIds.includes(context.routeProviderChoiceId)) {
     throw new Error(
       `route provider choice '${context.routeProviderChoiceId}' must be one of selected providers: ${dedupedProviderChoiceIds.join(", ")}`,
@@ -140,50 +196,54 @@ export function createInitSelectionConfig(
   }
 
   const providerChoices = dedupedProviderChoiceIds.map((providerChoiceId) => PROVIDER_CATALOG[providerChoiceId]);
+  const connectorChoices = dedupedConnectorChoiceIds.map((connectorChoiceId) => CONNECTOR_CATALOG[connectorChoiceId]);
   const primaryProviderChoice = PROVIDER_CATALOG[context.routeProviderChoiceId];
-  const connectorChoice = CONNECTOR_CATALOG[connectorChoiceId];
 
   return {
     providerChoiceIds: dedupedProviderChoiceIds,
     routeProviderChoiceId: primaryProviderChoice.id,
-    providerChoiceId: primaryProviderChoice.id,
-    connectorChoiceId,
+    connectorChoiceIds: dedupedConnectorChoiceIds,
     extensionPackages: [
-      ...new Set([...providerChoices.map((item) => item.extensionPackage), connectorChoice.extensionPackage]),
+      ...new Set([
+        ...providerChoices.map((item) => item.package),
+        ...connectorChoices.map((item) => item.package),
+      ]),
     ],
     providerInstances: providerChoices.map((providerChoice) => ({
       choiceId: providerChoice.id,
       instanceId: providerChoice.instanceId,
       contributionId: providerChoice.contributionId,
-      config: structuredClone(providerChoice.config),
+      config: structuredClone(providerChoice.defaultConfig),
+    })),
+    connectorInstances: connectorChoices.map((connectorChoice) => ({
+      choiceId: connectorChoice.id,
+      instanceId: connectorChoice.instanceId,
+      contributionId: connectorChoice.contributionId,
+      config: structuredClone(connectorChoice.defaultConfig),
     })),
     providerInstanceId: primaryProviderChoice.instanceId,
-    providerContributionId: primaryProviderChoice.contributionId,
-    providerConfig: structuredClone(primaryProviderChoice.config),
-    connectorInstanceId: connectorChoice.instanceId,
-    connectorContributionId: connectorChoice.contributionId,
-    connectorConfig: {
-      botName: context.botName,
-      botToken: context.botToken,
-      reconnectStaleMs: 60_000,
-      reconnectCheckIntervalMs: 10_000,
-    },
-    routeProfile: {
-      projectRoot: context.projectRoot,
+    routeId: DEFAULT_INIT_ROUTE_ID,
+    routeDefaults: {
+      projectRoot: context.defaultProjectRoot ?? DEFAULT_INIT_PROJECT_ROOT,
       tools: "full",
-      systemPromptFile: "",
-      mentions: context.allowAllMessages ? "optional" : "required",
+      mentions: "required",
       provider: primaryProviderChoice.instanceId,
       sandbox: "host.builtin",
     },
-    bindingId: `${connectorChoice.instanceId}.${context.routeId}`,
-    bindingConfig: {
-      connector: connectorChoice.instanceId,
-      source: {
-        type: "channel",
-        id: context.channelId,
-      },
-      route: context.routeId,
+    routeProfile: {},
+    defaultBinding: {
+      route: DEFAULT_INIT_ROUTE_ID,
     },
+    bindings: connectorChoices.map((connectorChoice) => ({
+      id: `${connectorChoice.instanceId}.${DEFAULT_INIT_ROUTE_ID}`,
+      config: {
+        connector: connectorChoice.instanceId,
+        source: {
+          type: connectorChoice.bindingTemplate.sourceType,
+          id: connectorChoice.bindingTemplate.sourceId,
+        },
+        route: DEFAULT_INIT_ROUTE_ID,
+      },
+    })),
   };
 }

package/src/cli/shared/local-extension-specs.ts

@@ -0,0 +1,108 @@
+import { access, readFile } from "node:fs/promises";
+import { readdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import { findDobbyRepoRoot } from "../../shared/dobby-repo.js";
+
+interface LocalExtensionPackage {
+  packageName: string;
+  packageDir: string;
+}
+
+function isExplicitInstallSpec(value: string): boolean {
+  return value.startsWith("file:")
+    || value.startsWith("git+")
+    || value.startsWith("http://")
+    || value.startsWith("https://")
+    || value.startsWith("./")
+    || value.startsWith("../")
+    || value.startsWith("/");
+}
+
+async function listRepoLocalExtensionPackages(repoRoot: string): Promise<Map<string, LocalExtensionPackage>> {
+  const pluginsRoot = resolve(repoRoot, "plugins");
+  const entries = await readdir(pluginsRoot, { withFileTypes: true });
+  const packages = new Map<string, LocalExtensionPackage>();
+
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name === "plugin-sdk") {
+      continue;
+    }
+
+    const packageDir = resolve(pluginsRoot, entry.name);
+    const packageJsonPath = resolve(packageDir, "package.json");
+    const manifestPath = resolve(packageDir, "dobby.manifest.json");
+
+    try {
+      await access(packageJsonPath);
+      await access(manifestPath);
+      const raw = await readFile(packageJsonPath, "utf-8");
+      const parsed = JSON.parse(raw) as { name?: unknown };
+      if (typeof parsed.name !== "string" || parsed.name.trim().length === 0) {
+        continue;
+      }
+
+      packages.set(parsed.name, {
+        packageName: parsed.name,
+        packageDir,
+      });
+    } catch {
+      continue;
+    }
+  }
+
+  return packages;
+}
+
+async function assertLocalExtensionBuildReady(localPackage: LocalExtensionPackage): Promise<void> {
+  const manifestPath = resolve(localPackage.packageDir, "dobby.manifest.json");
+  const rawManifest = await readFile(manifestPath, "utf-8");
+  const parsed = JSON.parse(rawManifest) as {
+    contributions?: Array<{ id?: unknown; entry?: unknown }>;
+  };
+
+  for (const contribution of parsed.contributions ?? []) {
+    if (typeof contribution.entry !== "string" || contribution.entry.trim().length === 0) {
+      continue;
+    }
+
+    const entryPath = resolve(localPackage.packageDir, contribution.entry);
+    try {
+      await access(entryPath);
+    } catch {
+      const contributionId = typeof contribution.id === "string" ? contribution.id : "unknown";
+      throw new Error(
+        `Local extension '${localPackage.packageName}' is not built for contribution '${contributionId}'. `
+        + `Missing '${entryPath}'. Run 'npm run build --prefix ${localPackage.packageDir}' first.`,
+      );
+    }
+  }
+}
+
+export async function resolveExtensionInstallSpecs(packageSpecs: string[], cwd = process.cwd()): Promise<string[]> {
+  const repoRoot = findDobbyRepoRoot(cwd);
+  if (!repoRoot) {
+    return packageSpecs;
+  }
+
+  const repoPackages = await listRepoLocalExtensionPackages(repoRoot);
+  const resolvedSpecs: string[] = [];
+
+  for (const rawSpec of packageSpecs) {
+    const packageSpec = rawSpec.trim();
+    if (packageSpec.length === 0 || isExplicitInstallSpec(packageSpec)) {
+      resolvedSpecs.push(packageSpec);
+      continue;
+    }
+
+    const localPackage = repoPackages.get(packageSpec);
+    if (!localPackage) {
+      resolvedSpecs.push(packageSpec);
+      continue;
+    }
+
+    await assertLocalExtensionBuildReady(localPackage);
+    resolvedSpecs.push(`file:${localPackage.packageDir}`);
+  }
+
+  return resolvedSpecs;
+}

package/src/cli/shared/schema-prompts.ts

@@ -4,6 +4,7 @@ import {
   isCancel,
   multiselect,
   note,
+  password,
   select,
   text,
 } from "@clack/prompts";
@@ -95,13 +96,17 @@ function shouldPromptInMinimalMode(field: FieldPromptDescriptor): boolean {
     return true;
   }
 
-  if (!field.hasDefault && field.existingValue === undefined) {
+  if (field.existingValue !== undefined) {
     return true;
   }
 
   return false;
 }
 
+function isSensitiveStringField(key: string): boolean {
+  return /(token|secret|api[-_]?key)$/i.test(key);
+}
+
 async function promptNumberField(params: {
   message: string;
   required: boolean;
@@ -306,6 +311,30 @@ async function promptFieldValue(params: {
     });
   }
 
+  if (isSensitiveStringField(key)) {
+    while (true) {
+      const result = await password({
+        message,
+        mask: "*",
+      });
+      if (isCancel(result)) {
+        cancel("Configuration cancelled.");
+        throw new Error("Configuration cancelled.");
+      }
+
+      const raw = String(result ?? "").trim();
+      if (raw.length === 0) {
+        if (required && existingValue === undefined) {
+          await note("This field is required.", "Validation");
+          continue;
+        }
+        return existingValue;
+      }
+
+      return raw;
+    }
+  }
+
   while (true) {
     const result = await text({
       message,

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

@@ -21,8 +21,8 @@ test("resolveConfigPath detects local dobby repository config path", async () =>
   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, "package.json"), JSON.stringify({ name: "@dobby.ai/dobby" }), "utf-8");
+  await writeFile(resolve(repoRoot, "config", "gateway.example.json"), "{}\n", "utf-8");
   await writeFile(resolve(repoRoot, "scripts", "local-extensions.mjs"), "#!/usr/bin/env node\n", "utf-8");
 
   assert.equal(
@@ -38,8 +38,8 @@ test("resolveConfigPath prioritizes DOBBY_CONFIG_PATH over repository detection"
   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, "package.json"), JSON.stringify({ name: "@dobby.ai/dobby" }), "utf-8");
+  await writeFile(resolve(repoRoot, "config", "gateway.example.json"), "{}\n", "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");
@@ -77,7 +77,7 @@ test("resolveDataRootDir uses repo root for repo-local config/gateway.json", asy
   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, "package.json"), JSON.stringify({ name: "@dobby.ai/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");
 

package/src/cli/tests/discord-mapper.test.ts

@@ -0,0 +1,128 @@
+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?: {
+  id?: string;
+  content?: string;
+  attachments?: Map<string, unknown>;
+}): unknown {
+  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: string): Promise<boolean> {
+  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 as never,
+    "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 as never,
+    "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 as never,
+    "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);
+});