@dobby.ai/dobby 0.1.0

package/dist/src/cli/shared/presets.js

@@ -0,0 +1,86 @@
+import { DEFAULT_DISCORD_CONNECTOR_INSTANCE_ID, DISCORD_CONNECTOR_CONTRIBUTION_ID, } from "./discord-config.js";
+const PRESET_IDS = ["discord-pi", "discord-claude-cli"];
+/**
+ * Returns all preset identifiers supported by `dobby init`.
+ */
+export function listPresetIds() {
+    return [...PRESET_IDS];
+}
+/**
+ * Type guard for validating preset ids provided by users.
+ */
+export function isPresetId(value) {
+    return PRESET_IDS.includes(value);
+}
+/**
+ * Builds preset-specific extension, instance, and route defaults for init flow.
+ */
+export function createPresetConfig(presetId, context) {
+    const baseRoute = {
+        projectRoot: context.projectRoot,
+        tools: "full",
+        systemPromptFile: "",
+        allowMentionsOnly: !context.allowAllMessages,
+        maxConcurrentTurns: 1,
+        sandboxId: "host.builtin",
+    };
+    if (presetId === "discord-claude-cli") {
+        return {
+            id: presetId,
+            extensionPackages: ["@dobby/provider-claude-cli", "@dobby/connector-discord"],
+            providerInstanceId: "claude-cli.main",
+            providerContributionId: "provider.claude-cli",
+            providerConfig: {
+                model: "claude-sonnet-4-5",
+                maxTurns: 20,
+                command: "claude",
+                commandArgs: [],
+                authMode: "auto",
+                permissionMode: "bypassPermissions",
+                streamVerbose: true,
+            },
+            connectorInstanceId: DEFAULT_DISCORD_CONNECTOR_INSTANCE_ID,
+            connectorContributionId: DISCORD_CONNECTOR_CONTRIBUTION_ID,
+            connectorConfig: {
+                botName: context.botName,
+                botToken: context.botToken,
+                botChannelMap: {
+                    [context.channelId]: context.routeId,
+                },
+                reconnectStaleMs: 60_000,
+                reconnectCheckIntervalMs: 10_000,
+            },
+            routeProfile: {
+                ...baseRoute,
+                providerId: "claude-cli.main",
+            },
+        };
+    }
+    return {
+        id: "discord-pi",
+        extensionPackages: ["@dobby/provider-pi", "@dobby/connector-discord"],
+        providerInstanceId: "pi.main",
+        providerContributionId: "provider.pi",
+        providerConfig: {
+            provider: "custom-openai",
+            model: "example-model",
+            thinkingLevel: "off",
+            modelsFile: "./models.custom.json",
+        },
+        connectorInstanceId: DEFAULT_DISCORD_CONNECTOR_INSTANCE_ID,
+        connectorContributionId: DISCORD_CONNECTOR_CONTRIBUTION_ID,
+        connectorConfig: {
+            botName: context.botName,
+            botToken: context.botToken,
+            botChannelMap: {
+                [context.channelId]: context.routeId,
+            },
+            reconnectStaleMs: 60_000,
+            reconnectCheckIntervalMs: 10_000,
+        },
+        routeProfile: {
+            ...baseRoute,
+            providerId: "pi.main",
+        },
+    };
+}

package/dist/src/cli/shared/runtime.js

@@ -0,0 +1,29 @@
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import pino from "pino";
+/**
+ * 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) {
+    return join(config.data.rootDir, "extensions");
+}
+/**
+ * Ensures required runtime data directories exist before start/doctor operations.
+ */
+export async function ensureDataDirs(rootDir) {
+    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/dist/src/cli/shared/schema-prompts.js

@@ -0,0 +1,325 @@
+import { cancel, confirm, isCancel, multiselect, note, select, text, } from "@clack/prompts";
+import JSON5 from "json5";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isPrimitive(value) {
+    return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function stringifyPreview(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (isPrimitive(value)) {
+        return String(value);
+    }
+    if (value === undefined) {
+        return "";
+    }
+    return JSON.stringify(value);
+}
+function schemaType(schema) {
+    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) {
+    if (!Array.isArray(schema.enum)) {
+        return null;
+    }
+    const normalized = schema.enum.filter((item) => isPrimitive(item));
+    return normalized.length > 0 ? normalized : null;
+}
+function schemaRequiredSet(schema) {
+    if (!Array.isArray(schema.required)) {
+        return new Set();
+    }
+    return new Set(schema.required.filter((item) => typeof item === "string"));
+}
+function schemaProperties(schema) {
+    if (!isRecord(schema.properties)) {
+        return {};
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(schema.properties)) {
+        if (isRecord(value)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function hasSchemaDefault(schema) {
+    return Object.prototype.hasOwnProperty.call(schema, "default");
+}
+function shouldPromptInMinimalMode(field) {
+    if (!field.hasDefault && field.required) {
+        return true;
+    }
+    if (!field.hasDefault && field.existingValue === undefined) {
+        return true;
+    }
+    return false;
+}
+async function promptNumberField(params) {
+    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) {
+    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) {
+    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))
+            .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.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) {
+    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)
+            ? initialValue
+            : enumValues.includes(existingValue)
+                ? existingValue
+                : 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, currentConfig, options) {
+    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 = 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;
+}

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

@@ -0,0 +1,42 @@
+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/dist/src/cli/tests/config-io.test.js

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

@@ -0,0 +1,47 @@
+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/dist/src/cli/tests/config-path.test.js

@@ -0,0 +1,21 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { getAtPath, parsePath, setAtPath, unsetAtPath } from "../shared/config-path.js";
+test("parsePath handles dot and bracket notation", () => {
+    assert.deepEqual(parsePath("routing.routes.main.projectRoot"), ["routing", "routes", "main", "projectRoot"]);
+    assert.deepEqual(parsePath("connectors.instances[discord.main].config.botChannelMap[12345]"), ["connectors", "instances", "discord.main", "config", "botChannelMap", "12345"]);
+});
+test("setAtPath and getAtPath support nested objects", () => {
+    const payload = {};
+    setAtPath(payload, parsePath("a.b.c"), 42);
+    const read = getAtPath(payload, parsePath("a.b.c"));
+    assert.equal(read.found, true);
+    assert.equal(read.value, 42);
+});
+test("unsetAtPath removes keys", () => {
+    const payload = { a: { b: { c: 1 } } };
+    const removed = unsetAtPath(payload, parsePath("a.b.c"));
+    assert.equal(removed, true);
+    const read = getAtPath(payload, parsePath("a.b.c"));
+    assert.equal(read.found, false);
+});

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

@@ -0,0 +1,23 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { normalizeDiscordBotChannelMap } from "../shared/discord-config.js";
+test("normalizeDiscordBotChannelMap keeps valid channel->route entries", () => {
+    const normalized = normalizeDiscordBotChannelMap({
+        "123": "projectA",
+        "456": "projectB",
+    });
+    assert.deepEqual(normalized, {
+        "123": "projectA",
+        "456": "projectB",
+    });
+});
+test("normalizeDiscordBotChannelMap drops invalid values", () => {
+    const normalized = normalizeDiscordBotChannelMap({
+        "123": "projectA",
+        "456": "",
+        "789": 1,
+    });
+    assert.deepEqual(normalized, {
+        "123": "projectA",
+    });
+});