@dobby.ai/dobby 0.1.1 → 0.1.2

package/dist/plugins/connector-discord/src/mapper.js

@@ -1,75 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-function stripBotMention(text, botUserId) {
-    const mentionRegex = new RegExp(`<@!?${botUserId}>`, "g");
-    return text.replace(mentionRegex, "").trim();
-}
-function sanitizeFileName(value) {
-    return value.replaceAll(/[^a-zA-Z0-9._-]/g, "_");
-}
-async function downloadAttachment(url, targetPath) {
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to download attachment from ${url}: ${response.status}`);
-    }
-    const data = await response.arrayBuffer();
-    await mkdir(dirname(targetPath), { recursive: true });
-    await writeFile(targetPath, Buffer.from(data));
-}
-function mapAttachmentBase(messageAttachment) {
-    return {
-        id: messageAttachment.id,
-        size: messageAttachment.size,
-        remoteUrl: messageAttachment.url,
-        ...(messageAttachment.name ? { fileName: messageAttachment.name } : {}),
-        ...(messageAttachment.contentType ? { mimeType: messageAttachment.contentType } : {}),
-    };
-}
-export async function mapDiscordMessage(message, connectorId, botUserId, sourceId, attachmentsRoot, logger) {
-    if (message.author.bot)
-        return null;
-    const isDirectMessage = message.guildId == null;
-    const mentionedBot = message.mentions.users.has(botUserId);
-    const chatId = message.channelId;
-    const threadId = message.channel.isThread() ? message.channelId : undefined;
-    const cleanedText = stripBotMention(message.content ?? "", botUserId);
-    const attachments = [];
-    for (const attachment of message.attachments.values()) {
-        const base = mapAttachmentBase(attachment);
-        const attachmentDir = join(attachmentsRoot, sourceId, message.id);
-        const fileName = sanitizeFileName(attachment.name ?? attachment.id);
-        const localPath = join(attachmentDir, fileName);
-        try {
-            await downloadAttachment(attachment.url, localPath);
-            attachments.push({
-                ...base,
-                localPath,
-            });
-        }
-        catch (error) {
-            logger.warn({ err: error, attachmentUrl: attachment.url }, "Failed to download Discord attachment; keeping metadata only");
-            attachments.push(base);
-        }
-    }
-    return {
-        connectorId,
-        platform: "discord",
-        accountId: botUserId,
-        source: {
-            type: "channel",
-            id: sourceId,
-        },
-        chatId,
-        messageId: message.id,
-        userId: message.author.id,
-        userName: message.author.username,
-        text: cleanedText,
-        attachments,
-        timestampMs: message.createdTimestamp,
-        raw: message.toJSON(),
-        isDirectMessage,
-        mentionedBot,
-        ...(message.guildId ? { guildId: message.guildId } : {}),
-        ...(threadId ? { threadId } : {}),
-    };
-}

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\"",
-        },
-    ]);
-});

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

@@ -1,64 +0,0 @@
-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.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(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.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");
-    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.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");
-    assert.equal(resolveDataRootDir(resolve(repoRoot, "config", "gateway.json"), {
-        data: {
-            rootDir: "./data",
-        },
-    }), resolve(repoRoot, "data"));
-});

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

@@ -1,47 +0,0 @@
-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/discord-mapper.test.js

@@ -1,90 +0,0 @@
-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) {
-    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) {
-    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, "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, "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, "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);
-});

package/dist/src/cli/tests/doctor.test.js

@@ -1,252 +0,0 @@
-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, payload) {
-    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, configPath) {
-    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 });
-    }
-});
-test("doctor reports invalid default binding route references", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "dobby-doctor-default-binding-"));
-    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: {
-                    projectRoot: process.cwd(),
-                    provider: "pi.main",
-                    sandbox: "host.builtin",
-                    tools: "full",
-                    mentions: "required",
-                },
-                items: {
-                    main: {},
-                },
-            },
-            bindings: {
-                default: {
-                    route: "missing-route",
-                },
-                items: {},
-            },
-            data: {
-                rootDir: "./data",
-                dedupTtlMs: 604800000,
-            },
-        });
-        const result = await runDoctorWithHome(homeDir, configPath);
-        assert.equal(result.code, 1);
-        assert.equal(result.output.includes("bindings.default.route") && result.output.includes("missing-route"), true);
-    }
-    finally {
-        await rm(homeDir, { recursive: true, force: true });
-    }
-});
-test("doctor reports init template placeholders as errors and warnings", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "dobby-doctor-placeholders-"));
-    try {
-        const configPath = await writeTempHomeConfig(homeDir, {
-            extensions: { allowList: [] },
-            providers: {
-                default: "pi.main",
-                items: {
-                    "pi.main": {
-                        type: "provider.pi",
-                        model: "REPLACE_WITH_PROVIDER_MODEL_ID",
-                        baseUrl: "REPLACE_WITH_PROVIDER_BASE_URL",
-                        apiKey: "REPLACE_WITH_PROVIDER_API_KEY_OR_ENV",
-                    },
-                },
-            },
-            connectors: {
-                items: {
-                    "discord.main": {
-                        type: "connector.discord",
-                        botName: "dobby-main",
-                        botToken: "REPLACE_WITH_DISCORD_BOT_TOKEN",
-                    },
-                    "feishu.main": {
-                        type: "connector.feishu",
-                        appId: "REPLACE_WITH_FEISHU_APP_ID",
-                        appSecret: "REPLACE_WITH_FEISHU_APP_SECRET",
-                    },
-                },
-            },
-            sandboxes: {
-                default: "host.builtin",
-                items: {},
-            },
-            routes: {
-                defaults: {
-                    provider: "pi.main",
-                    sandbox: "host.builtin",
-                    tools: "full",
-                    mentions: "required",
-                },
-                items: {
-                    main: {
-                        projectRoot: "./REPLACE_WITH_PROJECT_ROOT",
-                    },
-                },
-            },
-            bindings: {
-                items: {
-                    "discord.main.main": {
-                        connector: "discord.main",
-                        source: {
-                            type: "channel",
-                            id: "YOUR_DISCORD_CHANNEL_ID",
-                        },
-                        route: "main",
-                    },
-                    "feishu.main.main": {
-                        connector: "feishu.main",
-                        source: {
-                            type: "chat",
-                            id: "YOUR_FEISHU_CHAT_ID",
-                        },
-                        route: "main",
-                    },
-                },
-            },
-            data: {
-                rootDir: "./data",
-                dedupTtlMs: 604800000,
-            },
-        });
-        const result = await runDoctorWithHome(homeDir, configPath);
-        assert.equal(result.code, 1);
-        assert.equal(result.output.includes("providers.items['pi.main'].model still uses placeholder value"), true);
-        assert.equal(result.output.includes("providers.items['pi.main'].baseUrl still uses placeholder value"), true);
-        assert.equal(result.output.includes("providers.items['pi.main'].apiKey still uses placeholder value"), true);
-        assert.equal(result.output.includes("connectors.items['discord.main'].botToken still uses placeholder value"), true);
-        assert.equal(result.output.includes("connectors.items['feishu.main'].appId still uses placeholder value"), true);
-        assert.equal(result.output.includes("connectors.items['feishu.main'].appSecret still uses placeholder value"), true);
-        assert.equal(result.output.includes("routes.items['main'].projectRoot still uses placeholder value"), true);
-        assert.equal(result.output.includes("bindings.items['discord.main.main'].source.id still uses placeholder value"), true);
-        assert.equal(result.output.includes("bindings.items['feishu.main.main'].source.id still uses placeholder value"), true);
-    }
-    finally {
-        await rm(homeDir, { recursive: true, force: true });
-    }
-});