@dobby.ai/dobby 0.1.0 → 0.1.2

package/config/gateway.example.json

@@ -1,128 +0,0 @@
-{
-  "extensions": {
-    "allowList": [
-      {
-        "package": "@dobby.ai/provider-pi",
-        "enabled": true
-      },
-      {
-        "package": "@dobby.ai/connector-discord",
-        "enabled": true
-      },
-      {
-        "package": "@dobby.ai/connector-feishu",
-        "enabled": false
-      },
-      {
-        "package": "@dobby.ai/provider-claude-cli",
-        "enabled": false
-      }
-    ]
-  },
-  "providers": {
-    "default": "pi.main",
-    "items": {
-      "pi.main": {
-        "type": "provider.pi",
-        "provider": "custom-openai",
-        "model": "example-model",
-        "thinkingLevel": "off",
-        "modelsFile": "./models.custom.json"
-      }
-    }
-  },
-  "connectors": {
-    "items": {
-      "discord.main": {
-        "type": "connector.discord",
-        "botName": "dobby-main",
-        "botToken": "REPLACE_WITH_DISCORD_BOT_TOKEN",
-        "reconnectStaleMs": 60000,
-        "reconnectCheckIntervalMs": 10000
-      }
-    }
-  },
-  "sandboxes": {
-    "default": "host.builtin",
-    "items": {}
-  },
-  "routes": {
-    "defaults": {
-      "provider": "pi.main",
-      "sandbox": "host.builtin",
-      "tools": "full",
-      "mentions": "required"
-    },
-    "items": {
-      "projectA": {
-        "projectRoot": "/Users/you/workspace/project-a"
-      }
-    }
-  },
-  "bindings": {
-    "items": {
-      "discord.main.projectA": {
-        "connector": "discord.main",
-        "source": {
-          "type": "channel",
-          "id": "YOUR_DISCORD_CHANNEL_ID_A"
-        },
-        "route": "projectA"
-      }
-    }
-  },
-  "_examples": {
-    "connectors": {
-      "items": {
-        "feishu.main": {
-          "type": "connector.feishu",
-          "appId": "cli_xxx",
-          "appSecret": "REPLACE_WITH_FEISHU_APP_SECRET",
-          "domain": "feishu",
-          "botName": "dobby-feishu",
-          "messageFormat": "card_markdown",
-          "replyMode": "direct",
-          "cardTitle": "Dobby",
-          "downloadAttachments": true
-        }
-      }
-    },
-    "providers": {
-      "items": {
-        "claude-cli.main": {
-          "type": "provider.claude-cli",
-          "model": "claude-sonnet-4-5",
-          "maxTurns": 20,
-          "command": "claude",
-          "commandArgs": [],
-          "authMode": "auto",
-          "permissionMode": "bypassPermissions",
-          "streamVerbose": true
-        }
-      }
-    },
-    "routes": {
-      "items": {
-        "projectA": {
-          "provider": "claude-cli.main"
-        }
-      }
-    },
-    "bindings": {
-      "items": {
-        "feishu.main.projectA": {
-          "connector": "feishu.main",
-          "source": {
-            "type": "chat",
-            "id": "oc_xxx"
-          },
-          "route": "projectA"
-        }
-      }
-    }
-  },
-  "data": {
-    "rootDir": "./data",
-    "dedupTtlMs": 604800000
-  }
-}

package/config/models.custom.example.json

@@ -1,27 +0,0 @@
-{
-  "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
-          }
-        }
-      ]
-    }
-  }
-}

package/dist/src/agent/tests/event-forwarder.test.js

@@ -1,113 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { EventForwarder } from "../event-forwarder.js";
-class FakeConnector {
-    id = "connector.test";
-    platform = "test";
-    name = "test";
-    capabilities;
-    sent = [];
-    sentCount = 0;
-    constructor(updateStrategy, maxTextLength) {
-        this.capabilities = {
-            updateStrategy,
-            supportsThread: false,
-            supportsTyping: false,
-            supportsFileUpload: false,
-            ...(maxTextLength !== undefined ? { maxTextLength } : {}),
-        };
-    }
-    async start(_ctx) { }
-    async send(message) {
-        this.sent.push(message);
-        this.sentCount += 1;
-        return { messageId: `msg-${this.sentCount}` };
-    }
-    async stop() { }
-}
-const noopLogger = {
-    info: () => { },
-    warn: () => { },
-    error: () => { },
-    debug: () => { },
-};
-function createInbound() {
-    return {
-        connectorId: "connector.test",
-        platform: "test",
-        accountId: "bot",
-        routeId: "route.main",
-        routeChannelId: "route.main",
-        chatId: "chat.main",
-        messageId: "inbound-1",
-        userId: "user-1",
-        text: "hello",
-        attachments: [],
-        timestampMs: Date.now(),
-        raw: {},
-        isDirectMessage: false,
-        mentionedBot: true,
-    };
-}
-function sleep(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
-test("edit strategy keeps create+update flow", async () => {
-    const connector = new FakeConnector("edit");
-    const forwarder = new EventForwarder(connector, createInbound(), null, noopLogger, {
-        updateIntervalMs: 1,
-    });
-    forwarder.handleEvent({ type: "message_complete", text: "hello" });
-    await sleep(5);
-    forwarder.handleEvent({ type: "message_complete", text: "hello world" });
-    await sleep(5);
-    await forwarder.finalize();
-    assert.equal(connector.sent.length, 2);
-    assert.equal(connector.sent[0]?.mode, "create");
-    assert.equal(connector.sent[0]?.text, "hello");
-    assert.equal(connector.sent[1]?.mode, "update");
-    assert.equal(connector.sent[1]?.text, "hello world");
-});
-test("final_only suppresses tool/status outbound messages", async () => {
-    const connector = new FakeConnector("final_only");
-    const forwarder = new EventForwarder(connector, createInbound(), null, noopLogger, {
-        toolMessageMode: "all",
-        updateIntervalMs: 1,
-    });
-    forwarder.handleEvent({ type: "status", message: "starting" });
-    forwarder.handleEvent({ type: "tool_start", toolName: "bash" });
-    forwarder.handleEvent({ type: "message_delta", delta: "hello " });
-    forwarder.handleEvent({ type: "tool_end", toolName: "bash", isError: false, output: "ok" });
-    forwarder.handleEvent({ type: "message_delta", delta: "world" });
-    await forwarder.finalize();
-    assert.equal(connector.sent.length, 1);
-    assert.equal(connector.sent[0]?.mode, "create");
-    assert.equal(connector.sent[0]?.text, "hello world");
-});
-test("final_only splits long final text into multiple create messages", async () => {
-    const connector = new FakeConnector("final_only", 5);
-    const forwarder = new EventForwarder(connector, createInbound(), null, noopLogger);
-    forwarder.handleEvent({ type: "message_complete", text: "12345678901" });
-    await forwarder.finalize();
-    assert.equal(connector.sent.length, 3);
-    assert.deepEqual(connector.sent.map((message) => ({ mode: message.mode, text: message.text })), [
-        { mode: "create", text: "12345" },
-        { mode: "create", text: "67890" },
-        { mode: "create", text: "1" },
-    ]);
-});
-test("append sends streaming increments as create messages only", async () => {
-    const connector = new FakeConnector("append");
-    const forwarder = new EventForwarder(connector, createInbound(), null, noopLogger, {
-        updateIntervalMs: 5,
-    });
-    forwarder.handleEvent({ type: "message_delta", delta: "hello" });
-    await sleep(20);
-    forwarder.handleEvent({ type: "message_delta", delta: " world" });
-    await sleep(20);
-    await forwarder.finalize();
-    assert.deepEqual(connector.sent.map((message) => message.mode), ["create", "create"]);
-    assert.deepEqual(connector.sent.map((message) => message.text), ["hello", " world"]);
-});

package/dist/src/cli/shared/config-path.js

@@ -1,207 +0,0 @@
-const BLOCKED_OBJECT_KEYS = new Set(["__proto__", "prototype", "constructor"]);
-/**
- * Returns true when a path segment represents an array index.
- */
-function isIndexSegment(raw) {
-    return /^[0-9]+$/.test(raw);
-}
-/**
- * Rejects dangerous object keys that could enable prototype pollution.
- */
-function validatePathSegments(path) {
-    for (const segment of path) {
-        if (!isIndexSegment(segment) && BLOCKED_OBJECT_KEYS.has(segment)) {
-            throw new Error(`Invalid path segment: ${segment}`);
-        }
-    }
-}
-/**
- * Parses dot/bracket path syntax into normalized path segments.
- */
-export function parsePath(rawPath) {
-    const trimmed = rawPath.trim();
-    if (!trimmed) {
-        return [];
-    }
-    const segments = [];
-    let current = "";
-    let index = 0;
-    while (index < trimmed.length) {
-        const char = trimmed[index];
-        if (char === "\\") {
-            const next = trimmed[index + 1];
-            if (next) {
-                current += next;
-            }
-            index += 2;
-            continue;
-        }
-        if (char === ".") {
-            if (current) {
-                segments.push(current);
-            }
-            current = "";
-            index += 1;
-            continue;
-        }
-        if (char === "[") {
-            if (current) {
-                segments.push(current);
-            }
-            current = "";
-            const closeIndex = trimmed.indexOf("]", index);
-            if (closeIndex === -1) {
-                throw new Error(`Invalid path (missing ']'): ${rawPath}`);
-            }
-            const inside = trimmed.slice(index + 1, closeIndex).trim();
-            if (!inside) {
-                throw new Error(`Invalid path (empty '[]'): ${rawPath}`);
-            }
-            segments.push(inside);
-            index = closeIndex + 1;
-            continue;
-        }
-        current += char;
-        index += 1;
-    }
-    if (current) {
-        segments.push(current);
-    }
-    const normalized = segments.map((segment) => segment.trim()).filter(Boolean);
-    validatePathSegments(normalized);
-    return normalized;
-}
-/**
- * Safe own-property check wrapper.
- */
-function hasOwnKey(value, key) {
-    return Object.prototype.hasOwnProperty.call(value, key);
-}
-/**
- * Reads a value from object/array structures by parsed path segments.
- */
-export function getAtPath(root, path) {
-    let current = root;
-    for (const segment of path) {
-        if (!current || typeof current !== "object") {
-            return { found: false };
-        }
-        if (Array.isArray(current)) {
-            if (!isIndexSegment(segment)) {
-                return { found: false };
-            }
-            const index = Number.parseInt(segment, 10);
-            if (!Number.isFinite(index) || index < 0 || index >= current.length) {
-                return { found: false };
-            }
-            current = current[index];
-            continue;
-        }
-        const record = current;
-        if (!hasOwnKey(record, segment)) {
-            return { found: false };
-        }
-        current = record[segment];
-    }
-    return { found: true, value: current };
-}
-/**
- * Sets a value at path, creating intermediate objects/arrays as needed.
- */
-export function setAtPath(root, path, value) {
-    if (path.length === 0) {
-        throw new Error("Path is empty.");
-    }
-    let current = root;
-    for (let i = 0; i < path.length - 1; i += 1) {
-        const segment = path[i];
-        const next = path[i + 1];
-        const nextIsIndex = Boolean(next && isIndexSegment(next));
-        if (Array.isArray(current)) {
-            if (!isIndexSegment(segment)) {
-                throw new Error(`Expected numeric index for array segment '${segment}'`);
-            }
-            const index = Number.parseInt(segment, 10);
-            const existing = current[index];
-            if (!existing || typeof existing !== "object") {
-                current[index] = nextIsIndex ? [] : {};
-            }
-            current = current[index];
-            continue;
-        }
-        if (!current || typeof current !== "object") {
-            throw new Error(`Cannot traverse into '${segment}' (not an object)`);
-        }
-        const record = current;
-        const existing = hasOwnKey(record, segment) ? record[segment] : undefined;
-        if (!existing || typeof existing !== "object") {
-            record[segment] = nextIsIndex ? [] : {};
-        }
-        current = record[segment];
-    }
-    const tail = path[path.length - 1];
-    if (Array.isArray(current)) {
-        if (!isIndexSegment(tail)) {
-            throw new Error(`Expected numeric index for array segment '${tail}'`);
-        }
-        const index = Number.parseInt(tail, 10);
-        current[index] = value;
-        return;
-    }
-    if (!current || typeof current !== "object") {
-        throw new Error(`Cannot set '${tail}' (parent is not an object)`);
-    }
-    current[tail] = value;
-}
-/**
- * Removes a value at path and returns whether the target existed.
- */
-export function unsetAtPath(root, path) {
-    if (path.length === 0) {
-        return false;
-    }
-    let current = root;
-    for (let i = 0; i < path.length - 1; i += 1) {
-        const segment = path[i];
-        if (!current || typeof current !== "object") {
-            return false;
-        }
-        if (Array.isArray(current)) {
-            if (!isIndexSegment(segment)) {
-                return false;
-            }
-            const index = Number.parseInt(segment, 10);
-            if (!Number.isFinite(index) || index < 0 || index >= current.length) {
-                return false;
-            }
-            current = current[index];
-            continue;
-        }
-        const record = current;
-        if (!hasOwnKey(record, segment)) {
-            return false;
-        }
-        current = record[segment];
-    }
-    const tail = path[path.length - 1];
-    if (Array.isArray(current)) {
-        if (!isIndexSegment(tail)) {
-            return false;
-        }
-        const index = Number.parseInt(tail, 10);
-        if (!Number.isFinite(index) || index < 0 || index >= current.length) {
-            return false;
-        }
-        current.splice(index, 1);
-        return true;
-    }
-    if (!current || typeof current !== "object") {
-        return false;
-    }
-    const record = current;
-    if (!hasOwnKey(record, tail)) {
-        return false;
-    }
-    delete record[tail];
-    return true;
-}

package/dist/src/cli/shared/init-models-file.js

@@ -1,65 +0,0 @@
-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,
-                    },
-                },
-            ],
-        },
-    },
-};
-function expandHome(value) {
-    if (value === "~") {
-        return homedir();
-    }
-    if (value.startsWith("~/") || value.startsWith("~\\")) {
-        return resolve(homedir(), value.slice(2));
-    }
-    return value;
-}
-async function fileExists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function resolveModelsFilePath(configPath, value) {
-    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, providerConfig) {
-    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/dist/src/cli/shared/presets.js

@@ -1,86 +0,0 @@
-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/tests/config-command.test.js

@@ -1,42 +0,0 @@
-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\"",
-        },
-    ]);
-});