@dobby.ai/dobby 0.1.0

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

@@ -0,0 +1,189 @@
+import type { RawBindingConfig, RawRouteProfile } from "./config-types.js";
+import {
+  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";
+
+interface ProviderCatalogEntry {
+  id: InitProviderChoiceId;
+  label: string;
+  extensionPackage: string;
+  instanceId: string;
+  contributionId: string;
+  config: Record<string, unknown>;
+}
+
+interface ConnectorCatalogEntry {
+  id: InitConnectorChoiceId;
+  label: string;
+  extensionPackage: string;
+  instanceId: string;
+  contributionId: string;
+}
+
+export interface InitSelectionContext {
+  routeId: string;
+  projectRoot: string;
+  allowAllMessages: boolean;
+  botName: string;
+  botToken: string;
+  channelId: string;
+  routeProviderChoiceId: InitProviderChoiceId;
+}
+
+export interface InitSelectionResult {
+  providerChoiceIds: InitProviderChoiceId[];
+  routeProviderChoiceId: InitProviderChoiceId;
+  providerChoiceId: InitProviderChoiceId;
+  connectorChoiceId: InitConnectorChoiceId;
+  extensionPackages: string[];
+  providerInstances: Array<{
+    choiceId: InitProviderChoiceId;
+    instanceId: string;
+    contributionId: string;
+    config: Record<string, unknown>;
+  }>;
+  providerInstanceId: string;
+  providerContributionId: string;
+  providerConfig: Record<string, unknown>;
+  connectorInstanceId: string;
+  connectorContributionId: string;
+  connectorConfig: Record<string, unknown>;
+  routeProfile: RawRouteProfile;
+  bindingId: string;
+  bindingConfig: RawBindingConfig;
+}
+
+const PROVIDER_CATALOG: Record<InitProviderChoiceId, ProviderCatalogEntry> = {
+  "provider.pi": {
+    id: "provider.pi",
+    label: "Pi provider",
+    extensionPackage: "@dobby.ai/provider-pi",
+    instanceId: "pi.main",
+    contributionId: "provider.pi",
+    config: {
+      provider: "custom-openai",
+      model: "example-model",
+      thinkingLevel: "off",
+      modelsFile: "./models.custom.json",
+    },
+  },
+  "provider.claude-cli": {
+    id: "provider.claude-cli",
+    label: "Claude CLI provider",
+    extensionPackage: "@dobby.ai/provider-claude-cli",
+    instanceId: "claude-cli.main",
+    contributionId: "provider.claude-cli",
+    config: {
+      model: "claude-sonnet-4-5",
+      maxTurns: 20,
+      command: "claude",
+      commandArgs: [],
+      authMode: "auto",
+      permissionMode: "bypassPermissions",
+      streamVerbose: true,
+    },
+  },
+};
+
+const CONNECTOR_CATALOG: Record<InitConnectorChoiceId, ConnectorCatalogEntry> = {
+  "connector.discord": {
+    id: "connector.discord",
+    label: "Discord connector",
+    extensionPackage: "@dobby.ai/connector-discord",
+    instanceId: DEFAULT_DISCORD_CONNECTOR_INSTANCE_ID,
+    contributionId: DISCORD_CONNECTOR_CONTRIBUTION_ID,
+  },
+};
+
+export function listInitProviderChoices(): ProviderCatalogEntry[] {
+  return Object.values(PROVIDER_CATALOG);
+}
+
+export function listInitConnectorChoices(): ConnectorCatalogEntry[] {
+  return Object.values(CONNECTOR_CATALOG);
+}
+
+export function isInitProviderChoiceId(value: string): value is InitProviderChoiceId {
+  return Object.prototype.hasOwnProperty.call(PROVIDER_CATALOG, value);
+}
+
+export function isInitConnectorChoiceId(value: string): value is InitConnectorChoiceId {
+  return Object.prototype.hasOwnProperty.call(CONNECTOR_CATALOG, value);
+}
+
+export function createInitSelectionConfig(
+  providerChoiceIds: InitProviderChoiceId[],
+  connectorChoiceId: 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);
+    }
+  }
+
+  if (dedupedProviderChoiceIds.length === 0) {
+    throw new Error("At least one provider choice is required");
+  }
+
+  if (!dedupedProviderChoiceIds.includes(context.routeProviderChoiceId)) {
+    throw new Error(
+      `route provider choice '${context.routeProviderChoiceId}' must be one of selected providers: ${dedupedProviderChoiceIds.join(", ")}`,
+    );
+  }
+
+  const providerChoices = dedupedProviderChoiceIds.map((providerChoiceId) => PROVIDER_CATALOG[providerChoiceId]);
+  const primaryProviderChoice = PROVIDER_CATALOG[context.routeProviderChoiceId];
+  const connectorChoice = CONNECTOR_CATALOG[connectorChoiceId];
+
+  return {
+    providerChoiceIds: dedupedProviderChoiceIds,
+    routeProviderChoiceId: primaryProviderChoice.id,
+    providerChoiceId: primaryProviderChoice.id,
+    connectorChoiceId,
+    extensionPackages: [
+      ...new Set([...providerChoices.map((item) => item.extensionPackage), connectorChoice.extensionPackage]),
+    ],
+    providerInstances: providerChoices.map((providerChoice) => ({
+      choiceId: providerChoice.id,
+      instanceId: providerChoice.instanceId,
+      contributionId: providerChoice.contributionId,
+      config: structuredClone(providerChoice.config),
+    })),
+    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,
+      tools: "full",
+      systemPromptFile: "",
+      mentions: context.allowAllMessages ? "optional" : "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,
+    },
+  };
+}

package/src/cli/shared/init-models-file.ts

@@ -0,0 +1,77 @@
+import { access, mkdir, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { homedir } from "node:os";
+
+const DEFAULT_PROVIDER_PI_MODELS_FILE = "./models.custom.json";
+
+const PROVIDER_PI_MODELS_TEMPLATE = {
+  providers: {
+    "custom-openai": {
+      baseUrl: "https://api.example.com/v1",
+      api: "openai-completions",
+      apiKey: "CUSTOM_PROVIDER_AUTH_TOKEN",
+      models: [
+        {
+          id: "example-model",
+          name: "example-model",
+          reasoning: false,
+          input: ["text"],
+          contextWindow: 128000,
+          maxTokens: 8192,
+          cost: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+          },
+        },
+      ],
+    },
+  },
+} as const;
+
+function expandHome(value: string): string {
+  if (value === "~") {
+    return homedir();
+  }
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return resolve(homedir(), value.slice(2));
+  }
+
+  return value;
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function resolveModelsFilePath(configPath: string, value: string | undefined): string {
+  const configDir = dirname(resolve(configPath));
+  const resolvedValue = expandHome(value && value.trim().length > 0 ? value.trim() : DEFAULT_PROVIDER_PI_MODELS_FILE);
+  return isAbsolute(resolvedValue) ? resolve(resolvedValue) : resolve(configDir, resolvedValue);
+}
+
+/**
+ * Creates provider.pi models file only when missing.
+ */
+export async function ensureProviderPiModelsFile(
+  configPath: string,
+  providerConfig: Record<string, unknown>,
+): Promise<{ created: boolean; path: string }> {
+  const modelsFile = typeof providerConfig.modelsFile === "string" ? providerConfig.modelsFile : undefined;
+  const targetPath = resolveModelsFilePath(configPath, modelsFile);
+
+  if (await fileExists(targetPath)) {
+    return { created: false, path: targetPath };
+  }
+
+  await mkdir(dirname(targetPath), { recursive: true });
+  await writeFile(targetPath, `${JSON.stringify(PROVIDER_PI_MODELS_TEMPLATE, null, 2)}\n`, "utf-8");
+  return { created: true, path: targetPath };
+}
+

package/src/cli/shared/runtime.ts

@@ -0,0 +1,33 @@
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import pino from "pino";
+import type { GatewayConfig } from "../../core/types.js";
+
+/**
+ * Creates the shared gateway logger instance used across CLI commands.
+ */
+export function createLogger() {
+  return pino({
+    name: "dobby",
+    level: process.env.LOG_LEVEL ?? "info",
+  });
+}
+
+/**
+ * Returns the extension store directory from normalized gateway config.
+ */
+export function extensionStoreDir(config: GatewayConfig): string {
+  return join(config.data.rootDir, "extensions");
+}
+
+/**
+ * Ensures required runtime data directories exist before start/doctor operations.
+ */
+export async function ensureDataDirs(rootDir: string): Promise<void> {
+  await mkdir(rootDir, { recursive: true });
+  await mkdir(join(rootDir, "sessions"), { recursive: true });
+  await mkdir(join(rootDir, "attachments"), { recursive: true });
+  await mkdir(join(rootDir, "logs"), { recursive: true });
+  await mkdir(join(rootDir, "state"), { recursive: true });
+  await mkdir(join(rootDir, "extensions"), { recursive: true });
+}

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

@@ -0,0 +1,414 @@
+import {
+  cancel,
+  confirm,
+  isCancel,
+  multiselect,
+  note,
+  select,
+  text,
+} from "@clack/prompts";
+import JSON5 from "json5";
+
+interface PromptConfigFromSchemaOptions {
+  title?: string;
+  promptDefaultedFields?: boolean;
+}
+
+interface FieldPromptDescriptor {
+  key: string;
+  schema: Record<string, unknown>;
+  required: boolean;
+  hasDefault: boolean;
+  existingValue: unknown;
+  initialValue: unknown;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function isPrimitive(value: unknown): value is string | number | boolean {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+
+function stringifyPreview(value: unknown): string {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (isPrimitive(value)) {
+    return String(value);
+  }
+  if (value === undefined) {
+    return "";
+  }
+  return JSON.stringify(value);
+}
+
+function schemaType(schema: Record<string, unknown>): string | undefined {
+  const raw = schema.type;
+  if (typeof raw === "string") {
+    return raw;
+  }
+  if (Array.isArray(raw)) {
+    const firstStringType = raw.find((item) => typeof item === "string");
+    return typeof firstStringType === "string" ? firstStringType : undefined;
+  }
+  return undefined;
+}
+
+function schemaEnum(schema: Record<string, unknown>): Array<string | number | boolean> | null {
+  if (!Array.isArray(schema.enum)) {
+    return null;
+  }
+
+  const normalized = schema.enum.filter((item) => isPrimitive(item)) as Array<string | number | boolean>;
+  return normalized.length > 0 ? normalized : null;
+}
+
+function schemaRequiredSet(schema: Record<string, unknown>): Set<string> {
+  if (!Array.isArray(schema.required)) {
+    return new Set<string>();
+  }
+  return new Set(schema.required.filter((item) => typeof item === "string"));
+}
+
+function schemaProperties(schema: Record<string, unknown>): Record<string, Record<string, unknown>> {
+  if (!isRecord(schema.properties)) {
+    return {};
+  }
+
+  const result: Record<string, Record<string, unknown>> = {};
+  for (const [key, value] of Object.entries(schema.properties)) {
+    if (isRecord(value)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+function hasSchemaDefault(schema: Record<string, unknown>): boolean {
+  return Object.prototype.hasOwnProperty.call(schema, "default");
+}
+
+function shouldPromptInMinimalMode(field: FieldPromptDescriptor): boolean {
+  if (!field.hasDefault && field.required) {
+    return true;
+  }
+
+  if (!field.hasDefault && field.existingValue === undefined) {
+    return true;
+  }
+
+  return false;
+}
+
+async function promptNumberField(params: {
+  message: string;
+  required: boolean;
+  initialValue: unknown;
+  integer: boolean;
+  existingValue: unknown;
+}): Promise<number | undefined> {
+  while (true) {
+    const result = await text({
+      message: params.message,
+      initialValue: stringifyPreview(params.initialValue),
+      placeholder: params.integer ? "integer" : "number",
+    });
+    if (isCancel(result)) {
+      cancel("Configuration cancelled.");
+      throw new Error("Configuration cancelled.");
+    }
+
+    const raw = String(result ?? "").trim();
+    if (raw.length === 0) {
+      if (params.required && params.existingValue === undefined) {
+        await note("This field is required.", "Validation");
+        continue;
+      }
+      return typeof params.existingValue === "number" ? params.existingValue : undefined;
+    }
+
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed)) {
+      await note("Please enter a valid number.", "Validation");
+      continue;
+    }
+    if (params.integer && !Number.isInteger(parsed)) {
+      await note("Please enter an integer.", "Validation");
+      continue;
+    }
+    return parsed;
+  }
+}
+
+async function promptJsonField(params: {
+  message: string;
+  required: boolean;
+  initialValue: unknown;
+  expected: "object" | "array";
+  existingValue: unknown;
+}): Promise<unknown> {
+  while (true) {
+    const result = await text({
+      message: params.message,
+      initialValue: stringifyPreview(params.initialValue),
+      placeholder: params.expected === "object" ? '{"key":"value"}' : '["value"]',
+    });
+    if (isCancel(result)) {
+      cancel("Configuration cancelled.");
+      throw new Error("Configuration cancelled.");
+    }
+
+    const raw = String(result ?? "").trim();
+    if (raw.length === 0) {
+      if (params.required && params.existingValue === undefined) {
+        await note("This field is required.", "Validation");
+        continue;
+      }
+      return params.existingValue;
+    }
+
+    try {
+      const parsed = JSON5.parse(raw);
+      if (params.expected === "object" && (!parsed || typeof parsed !== "object" || Array.isArray(parsed))) {
+        await note("Please enter a JSON object.", "Validation");
+        continue;
+      }
+      if (params.expected === "array" && !Array.isArray(parsed)) {
+        await note("Please enter a JSON array.", "Validation");
+        continue;
+      }
+      return parsed;
+    } catch (error) {
+      await note(`Invalid JSON: ${error instanceof Error ? error.message : String(error)}`, "Validation");
+    }
+  }
+}
+
+async function promptArrayField(params: {
+  key: string;
+  schema: Record<string, unknown>;
+  required: boolean;
+  initialValue: unknown;
+  existingValue: unknown;
+}): Promise<unknown> {
+  const itemSchema = isRecord(params.schema.items) ? params.schema.items : {};
+  const itemEnum = schemaEnum(itemSchema);
+  if (itemEnum && itemEnum.length > 0) {
+    const current = Array.isArray(params.initialValue) ? params.initialValue : [];
+    const initialValues = current.filter((item) => itemEnum.includes(item as string | number | boolean))
+      .map((item) => String(item));
+    const result = await multiselect({
+      message: `${params.key}${params.required ? " (required)" : ""}`,
+      options: itemEnum.map((item) => ({
+        value: String(item),
+        label: String(item),
+      })),
+      initialValues,
+      required: params.required,
+    });
+    if (isCancel(result)) {
+      cancel("Configuration cancelled.");
+      throw new Error("Configuration cancelled.");
+    }
+
+    return (result as string[]).map((value) => itemEnum.find((candidate) => String(candidate) === value) ?? value);
+  }
+
+  return promptJsonField({
+    message: `${params.key}${params.required ? " (required)" : ""} (JSON array)`,
+    required: params.required,
+    initialValue: params.initialValue,
+    expected: "array",
+    existingValue: params.existingValue,
+  });
+}
+
+async function promptFieldValue(params: {
+  key: string;
+  schema: Record<string, unknown>;
+  required: boolean;
+  initialValue: unknown;
+  existingValue: unknown;
+}): Promise<unknown> {
+  const { key, schema, required, initialValue, existingValue } = params;
+  const enumValues = schemaEnum(schema);
+  const type = schemaType(schema);
+  const description = typeof schema.description === "string" ? schema.description.trim() : "";
+  const message = `${key}${required ? " (required)" : ""}${description ? ` - ${description}` : ""}`;
+
+  if (enumValues && enumValues.length > 0) {
+    const fallback = enumValues[0]!;
+    const initialCandidate = enumValues.includes(initialValue as string | number | boolean)
+      ? (initialValue as string | number | boolean)
+      : enumValues.includes(existingValue as string | number | boolean)
+        ? (existingValue as string | number | boolean)
+        : fallback;
+    const result = await select({
+      message,
+      options: enumValues.map((value) => ({
+        value: String(value),
+        label: String(value),
+      })),
+      initialValue: String(initialCandidate),
+    });
+    if (isCancel(result)) {
+      cancel("Configuration cancelled.");
+      throw new Error("Configuration cancelled.");
+    }
+    return enumValues.find((value) => String(value) === String(result)) ?? result;
+  }
+
+  if (type === "boolean") {
+    const result = await confirm({
+      message,
+      initialValue: typeof initialValue === "boolean"
+        ? initialValue
+        : typeof existingValue === "boolean"
+          ? existingValue
+          : false,
+    });
+    if (isCancel(result)) {
+      cancel("Configuration cancelled.");
+      throw new Error("Configuration cancelled.");
+    }
+    return result === true;
+  }
+
+  if (type === "integer" || type === "number") {
+    return promptNumberField({
+      message,
+      required,
+      initialValue,
+      integer: type === "integer",
+      existingValue,
+    });
+  }
+
+  if (type === "array") {
+    return promptArrayField({
+      key,
+      schema,
+      required,
+      initialValue,
+      existingValue,
+    });
+  }
+
+  if (type === "object") {
+    return promptJsonField({
+      message: `${message} (JSON object)`,
+      required,
+      initialValue,
+      expected: "object",
+      existingValue,
+    });
+  }
+
+  while (true) {
+    const result = await text({
+      message,
+      initialValue: stringifyPreview(initialValue),
+    });
+    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;
+  }
+}
+
+/**
+ * Prompts one extension config object from a contribution JSON Schema.
+ * Currently supports top-level schema properties and falls back to JSON input for complex fields.
+ */
+export async function promptConfigFromSchema(
+  schema: Record<string, unknown>,
+  currentConfig: Record<string, unknown>,
+  options?: PromptConfigFromSchemaOptions,
+): Promise<Record<string, unknown>> {
+  const properties = schemaProperties(schema);
+  const required = schemaRequiredSet(schema);
+
+  if (options?.title) {
+    await note(options.title, "Configure");
+  }
+
+  if (Object.keys(properties).length === 0) {
+    return structuredClone(currentConfig);
+  }
+
+  const next = structuredClone(currentConfig);
+  const fieldDescriptors: FieldPromptDescriptor[] = Object.entries(properties).map(([key, fieldSchema]) => {
+    const existingValue = next[key];
+    const defaultValue = fieldSchema.default;
+    const initialValue = existingValue !== undefined ? existingValue : defaultValue;
+    return {
+      key,
+      schema: fieldSchema,
+      required: required.has(key),
+      hasDefault: hasSchemaDefault(fieldSchema),
+      existingValue,
+      initialValue,
+    };
+  });
+
+  const minimalFields = fieldDescriptors.filter((field) => shouldPromptInMinimalMode(field));
+  const advancedFields = fieldDescriptors.filter((field) => !minimalFields.includes(field));
+
+  for (const field of minimalFields) {
+    const value = await promptFieldValue({
+      key: field.key,
+      schema: field.schema,
+      required: field.required,
+      initialValue: field.initialValue,
+      existingValue: field.existingValue,
+    });
+    if (value === undefined) {
+      continue;
+    }
+    next[field.key] = value;
+  }
+
+  if (advancedFields.length > 0) {
+    const shouldPromptAdvanced = options?.promptDefaultedFields === true
+      ? true
+      : await confirm({
+        message: "Configure advanced options (defaults can be kept)?",
+        initialValue: false,
+      });
+    if (isCancel(shouldPromptAdvanced)) {
+      cancel("Configuration cancelled.");
+      throw new Error("Configuration cancelled.");
+    }
+
+    if (shouldPromptAdvanced === true) {
+      for (const field of advancedFields) {
+        const value = await promptFieldValue({
+          key: field.key,
+          schema: field.schema,
+          required: field.required,
+          initialValue: field.initialValue,
+          existingValue: field.existingValue,
+        });
+        if (value === undefined) {
+          continue;
+        }
+        next[field.key] = value;
+      }
+    }
+  }
+
+  return next;
+}