@dobby.ai/dobby 0.1.0 → 0.1.2

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

@@ -1,199 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import test from "node:test";
-import { loadGatewayConfig } from "../../core/routing.js";
-async function writeTempConfig(payload) {
-    const dir = await mkdtemp(join(tmpdir(), "dobby-routing-"));
-    const configPath = join(dir, "gateway.json");
-    await writeFile(configPath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
-    return configPath;
-}
-async function writeRepoTempConfig(payload) {
-    const repoRoot = await mkdtemp(join(tmpdir(), "dobby-routing-repo-"));
-    const configDir = join(repoRoot, "config");
-    await mkdir(configDir, { recursive: true });
-    await mkdir(join(repoRoot, "scripts"), { recursive: true });
-    await writeFile(join(repoRoot, "package.json"), JSON.stringify({ name: "dobby" }), "utf-8");
-    await writeFile(join(repoRoot, "scripts", "local-extensions.mjs"), "#!/usr/bin/env node\n", "utf-8");
-    const configPath = join(configDir, "gateway.json");
-    await writeFile(configPath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
-    return { repoRoot, configPath };
-}
-function validConfig() {
-    return {
-        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: "./workspace/project-a",
-                    systemPromptFile: "./prompts/main.md",
-                },
-            },
-        },
-        bindings: {
-            items: {
-                "discord.main.main": {
-                    connector: "discord.main",
-                    source: {
-                        type: "channel",
-                        id: "123",
-                    },
-                    route: "main",
-                },
-            },
-        },
-        data: {
-            rootDir: "./data",
-            dedupTtlMs: 604800000,
-        },
-    };
-}
-test("loadGatewayConfig applies route defaults and resolves relative paths", async () => {
-    const payload = validConfig();
-    const configPath = await writeTempConfig(payload);
-    try {
-        const loaded = await loadGatewayConfig(configPath);
-        const configDir = dirname(configPath);
-        assert.equal(loaded.providers.default, "pi.main");
-        assert.deepEqual(loaded.routes.defaults, {
-            provider: "pi.main",
-            sandbox: "host.builtin",
-            tools: "full",
-            mentions: "required",
-        });
-        assert.deepEqual(loaded.routes.items.main, {
-            projectRoot: join(configDir, "workspace/project-a"),
-            systemPromptFile: join(configDir, "prompts/main.md"),
-            provider: "pi.main",
-            sandbox: "host.builtin",
-            tools: "full",
-            mentions: "required",
-        });
-        assert.equal(loaded.data.rootDir, join(configDir, "data"));
-        assert.deepEqual(loaded.bindings.items["discord.main.main"], {
-            connector: "discord.main",
-            source: {
-                type: "channel",
-                id: "123",
-            },
-            route: "main",
-        });
-    }
-    finally {
-        await rm(dirname(configPath), { recursive: true, force: true });
-    }
-});
-test("loadGatewayConfig resolves data.rootDir from repo root for repo-local config/gateway.json", async () => {
-    const payload = validConfig();
-    const { repoRoot, configPath } = await writeRepoTempConfig(payload);
-    try {
-        const loaded = await loadGatewayConfig(configPath);
-        const mainRoute = loaded.routes.items.main;
-        assert.ok(mainRoute);
-        assert.equal(loaded.data.rootDir, join(repoRoot, "data"));
-        assert.equal(mainRoute.projectRoot, join(repoRoot, "workspace/project-a"));
-    }
-    finally {
-        await rm(repoRoot, { recursive: true, force: true });
-    }
-});
-test("loadGatewayConfig rejects connector fields reserved by the host", async () => {
-    const payload = validConfig();
-    payload.connectors = {
-        items: {
-            "discord.main": {
-                type: "connector.discord",
-                botName: "dobby-main",
-                botToken: "token",
-                botChannelMap: {
-                    "123": "main",
-                },
-            },
-        },
-    };
-    const configPath = await writeTempConfig(payload);
-    try {
-        await assert.rejects(loadGatewayConfig(configPath), /must not include 'botChannelMap'/);
-    }
-    finally {
-        await rm(dirname(configPath), { recursive: true, force: true });
-    }
-});
-test("loadGatewayConfig rejects connector env indirection fields reserved by the host", async () => {
-    const payload = validConfig();
-    payload.connectors = {
-        items: {
-            "discord.main": {
-                type: "connector.discord",
-                botName: "dobby-main",
-                botTokenEnv: "DISCORD_BOT_TOKEN",
-            },
-        },
-    };
-    const configPath = await writeTempConfig(payload);
-    try {
-        await assert.rejects(loadGatewayConfig(configPath), /must not include 'botTokenEnv'/);
-    }
-    finally {
-        await rm(dirname(configPath), { recursive: true, force: true });
-    }
-});
-test("loadGatewayConfig fails fast on duplicate binding sources", async () => {
-    const payload = validConfig();
-    payload.bindings = {
-        items: {
-            "discord.main.main": {
-                connector: "discord.main",
-                source: {
-                    type: "channel",
-                    id: "123",
-                },
-                route: "main",
-            },
-            "discord.main.duplicate": {
-                connector: "discord.main",
-                source: {
-                    type: "channel",
-                    id: "123",
-                },
-                route: "main",
-            },
-        },
-    };
-    const configPath = await writeTempConfig(payload);
-    try {
-        await assert.rejects(loadGatewayConfig(configPath), /duplicates source 'discord\.main:channel:123'/);
-    }
-    finally {
-        await rm(dirname(configPath), { recursive: true, force: true });
-    }
-});

package/dist/src/cli/tests/routing-legacy.test.js

@@ -1,191 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import test from "node:test";
-import { loadGatewayConfig } from "../../core/routing.js";
-async function writeTempConfig(payload) {
-    const dir = await mkdtemp(join(tmpdir(), "dobby-routing-"));
-    const configPath = join(dir, "gateway.json");
-    await writeFile(configPath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
-    return configPath;
-}
-function validConfig() {
-    return {
-        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: "./workspace/project-a",
-                    systemPromptFile: "./prompts/main.md",
-                },
-            },
-        },
-        bindings: {
-            items: {
-                "discord.main.main": {
-                    connector: "discord.main",
-                    source: {
-                        type: "channel",
-                        id: "123",
-                    },
-                    route: "main",
-                },
-            },
-        },
-        data: {
-            rootDir: "./data",
-            dedupTtlMs: 604800000,
-        },
-    };
-}
-test("loadGatewayConfig applies route defaults and resolves relative paths", async () => {
-    const payload = validConfig();
-    const configPath = await writeTempConfig(payload);
-    try {
-        const loaded = await loadGatewayConfig(configPath);
-        const configDir = dirname(configPath);
-        assert.equal(loaded.providers.default, "pi.main");
-        assert.deepEqual(loaded.routes.defaults, {
-            provider: "pi.main",
-            sandbox: "host.builtin",
-            tools: "full",
-            mentions: "required",
-        });
-        assert.deepEqual(loaded.routes.items.main, {
-            projectRoot: join(configDir, "workspace/project-a"),
-            systemPromptFile: join(configDir, "prompts/main.md"),
-            provider: "pi.main",
-            sandbox: "host.builtin",
-            tools: "full",
-            mentions: "required",
-        });
-        assert.equal(loaded.data.rootDir, join(configDir, "data"));
-        assert.deepEqual(loaded.bindings.items["discord.main.main"], {
-            connector: "discord.main",
-            source: {
-                type: "channel",
-                id: "123",
-            },
-            route: "main",
-        });
-    }
-    finally {
-        await rm(dirname(configPath), { recursive: true, force: true });
-    }
-});
-test("loadGatewayConfig fails fast on legacy top-level routing", async () => {
-    const payload = validConfig();
-    payload.routing = {
-        routes: {
-            main: {
-                projectRoot: process.cwd(),
-            },
-        },
-    };
-    const configPath = await writeTempConfig(payload);
-    try {
-        await assert.rejects(loadGatewayConfig(configPath), /top-level field 'routing'/);
-    }
-    finally {
-        await rm(dirname(configPath), { recursive: true, force: true });
-    }
-});
-test("loadGatewayConfig fails fast on legacy botTokenEnv", async () => {
-    const payload = validConfig();
-    payload.connectors = {
-        items: {
-            "discord.main": {
-                type: "connector.discord",
-                botName: "dobby-main",
-                botTokenEnv: "DISCORD_BOT_TOKEN",
-            },
-        },
-    };
-    const configPath = await writeTempConfig(payload);
-    try {
-        await assert.rejects(loadGatewayConfig(configPath), /botTokenEnv/);
-    }
-    finally {
-        await rm(dirname(configPath), { recursive: true, force: true });
-    }
-});
-test("loadGatewayConfig fails fast on legacy connector route maps", async () => {
-    const payload = validConfig();
-    payload.connectors = {
-        items: {
-            "discord.main": {
-                type: "connector.discord",
-                botName: "dobby-main",
-                botToken: "token",
-                botChannelMap: {
-                    "123": "main",
-                },
-            },
-        },
-    };
-    const configPath = await writeTempConfig(payload);
-    try {
-        await assert.rejects(loadGatewayConfig(configPath), /botChannelMap/);
-    }
-    finally {
-        await rm(dirname(configPath), { recursive: true, force: true });
-    }
-});
-test("loadGatewayConfig fails fast on duplicate binding sources", async () => {
-    const payload = validConfig();
-    payload.bindings = {
-        items: {
-            "discord.main.main": {
-                connector: "discord.main",
-                source: {
-                    type: "channel",
-                    id: "123",
-                },
-                route: "main",
-            },
-            "discord.main.duplicate": {
-                connector: "discord.main",
-                source: {
-                    type: "channel",
-                    id: "123",
-                },
-                route: "main",
-            },
-        },
-    };
-    const configPath = await writeTempConfig(payload);
-    try {
-        await assert.rejects(loadGatewayConfig(configPath), /duplicates source 'discord\.main:channel:123'/);
-    }
-    finally {
-        await rm(dirname(configPath), { recursive: true, force: true });
-    }
-});

package/dist/src/core/tests/control-command.test.js

@@ -1,17 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { parseControlCommand } from "../control-command.js";
-test("parseControlCommand recognizes cancel aliases", () => {
-    assert.equal(parseControlCommand("stop"), "cancel");
-    assert.equal(parseControlCommand(" /STOP "), "cancel");
-    assert.equal(parseControlCommand("/cancel"), "cancel");
-});
-test("parseControlCommand recognizes new session aliases", () => {
-    assert.equal(parseControlCommand("/new"), "new_session");
-    assert.equal(parseControlCommand(" /reset "), "new_session");
-});
-test("parseControlCommand ignores regular messages", () => {
-    assert.equal(parseControlCommand("please /new"), null);
-    assert.equal(parseControlCommand(""), null);
-    assert.equal(parseControlCommand("hello"), null);
-});

package/dist/src/core/tests/gateway-update-strategy.test.js

@@ -1,167 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { Gateway } from "../gateway.js";
-class FakeConnector {
-    id = "connector.test";
-    platform = "test";
-    name = "test";
-    capabilities;
-    sent = [];
-    sentCount = 0;
-    constructor(updateStrategy) {
-        this.capabilities = {
-            updateStrategy,
-            supportsThread: false,
-            supportsTyping: false,
-            supportsFileUpload: false,
-        };
-    }
-    async start(_ctx) { }
-    async send(message) {
-        this.sent.push(message);
-        this.sentCount += 1;
-        return { messageId: `msg-${this.sentCount}` };
-    }
-    async stop() { }
-}
-class ThrowingRuntime {
-    listener = null;
-    subscribe(listener) {
-        this.listener = listener;
-        return () => {
-            this.listener = null;
-        };
-    }
-    async prompt() {
-        this.listener?.({ type: "message_complete", text: "partial output" });
-        throw new Error("boom");
-    }
-    async abort() { }
-    dispose() {
-        this.listener = null;
-    }
-}
-const route = {
-    routeId: "route.main",
-    profile: {
-        projectRoot: "/tmp/project",
-        tools: "readonly",
-        allowMentionsOnly: false,
-        maxConcurrentTurns: 1,
-    },
-};
-const noopLogger = {
-    info: () => { },
-    warn: () => { },
-    error: () => { },
-    debug: () => { },
-};
-const fakeExecutor = {
-    exec: async () => ({ stdout: "", stderr: "", code: 0, killed: false }),
-    spawn: () => {
-        throw new Error("spawn should not be called in this test");
-    },
-    close: async () => { },
-};
-const fakeDedupStore = {
-    has: () => false,
-    add: () => { },
-    load: async () => { },
-    startAutoFlush: () => { },
-    stopAutoFlush: () => { },
-    flush: async () => { },
-};
-const fakeRuntimeRegistry = {
-    getOrCreate: async () => {
-        throw new Error("getOrCreate should not be called for scheduled stateless runs");
-    },
-    enqueue: async () => {
-        throw new Error("enqueue should not be called for scheduled stateless runs");
-    },
-    abort: async () => false,
-    closeAll: async () => { },
-};
-function buildGateway(updateStrategy) {
-    const connector = new FakeConnector(updateStrategy);
-    const provider = {
-        id: "provider.main",
-        createRuntime: async () => new ThrowingRuntime(),
-    };
-    const config = {
-        extensions: { allowList: [] },
-        providers: {
-            defaultProviderId: "provider.main",
-            instances: {},
-        },
-        connectors: {
-            instances: {},
-        },
-        sandboxes: {
-            defaultSandboxId: "sandbox.main",
-            instances: {},
-        },
-        routing: {
-            routes: {
-                [route.routeId]: route.profile,
-            },
-        },
-        data: {
-            rootDir: "/tmp",
-            sessionsDir: "/tmp/sessions",
-            attachmentsDir: "/tmp/attachments",
-            logsDir: "/tmp/logs",
-            stateDir: "/tmp/state",
-            dedupTtlMs: 60_000,
-        },
-    };
-    const routeResolver = {
-        resolve: (routeId) => (routeId === route.routeId ? route : null),
-    };
-    const gateway = new Gateway({
-        config,
-        connectors: [connector],
-        providers: new Map([["provider.main", provider]]),
-        executors: new Map([["sandbox.main", fakeExecutor]]),
-        routeResolver,
-        dedupStore: fakeDedupStore,
-        runtimeRegistry: fakeRuntimeRegistry,
-        logger: noopLogger,
-    });
-    return { gateway, connector };
-}
-async function runScheduledAndCollect(updateStrategy) {
-    const { gateway, connector } = buildGateway(updateStrategy);
-    await gateway.handleScheduled({
-        jobId: "job-1",
-        runId: `run-${updateStrategy}`,
-        connectorId: connector.id,
-        routeId: route.routeId,
-        channelId: "chat-1",
-        prompt: "hello",
-    });
-    return connector;
-}
-test("gateway error path uses update for edit strategy", async () => {
-    const connector = await runScheduledAndCollect("edit");
-    assert.equal(connector.sent.length, 2);
-    assert.equal(connector.sent[0]?.mode, "create");
-    assert.equal(connector.sent[0]?.text, "partial output");
-    assert.equal(connector.sent[1]?.mode, "update");
-    assert.equal(connector.sent[1]?.targetMessageId, "msg-1");
-    assert.equal(connector.sent[1]?.text, "Error: boom");
-});
-test("gateway error path uses create for append strategy", async () => {
-    const connector = await runScheduledAndCollect("append");
-    assert.equal(connector.sent.length, 2);
-    assert.equal(connector.sent[0]?.mode, "create");
-    assert.equal(connector.sent[0]?.text, "partial output");
-    assert.equal(connector.sent[1]?.mode, "create");
-    assert.equal(connector.sent[1]?.replyToMessageId, "msg-1");
-    assert.equal(connector.sent[1]?.text, "Error: boom");
-});
-test("gateway error path uses create for final_only strategy", async () => {
-    const connector = await runScheduledAndCollect("final_only");
-    assert.equal(connector.sent.length, 1);
-    assert.equal(connector.sent[0]?.mode, "create");
-    assert.equal(connector.sent[0]?.text, "Error: boom");
-});

package/dist/src/core/tests/runtime-registry.test.js

@@ -1,116 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { RuntimeRegistry } from "../runtime-registry.js";
-function deferred() {
-    let resolve;
-    const promise = new Promise((res) => {
-        resolve = res;
-    });
-    return { promise, resolve };
-}
-function createLogger() {
-    return {
-        error() { },
-        warn() { },
-        info() { },
-        debug() { },
-    };
-}
-function createConversationRuntime(id, abortCalls, closeCalls) {
-    return {
-        key: id,
-        routeId: "route.main",
-        route: {
-            projectRoot: "/tmp/project",
-            tools: "full",
-            mentions: "required",
-            provider: "provider.main",
-            sandbox: "host.builtin",
-        },
-        providerId: "provider.main",
-        sandboxId: "host.builtin",
-        runtime: {
-            async prompt() { },
-            subscribe() {
-                return () => { };
-            },
-            async abort() {
-                abortCalls.push(id);
-            },
-            dispose() { },
-        },
-        async close() {
-            closeCalls.push(id);
-        },
-    };
-}
-test("cancel aborts the active run and drops queued turns", async () => {
-    const registry = new RuntimeRegistry(createLogger());
-    const abortCalls = [];
-    const closeCalls = [];
-    let runtimeCount = 0;
-    const createRuntime = async () => {
-        runtimeCount += 1;
-        return createConversationRuntime(`runtime-${runtimeCount}`, abortCalls, closeCalls);
-    };
-    const firstStarted = deferred();
-    const releaseFirst = deferred();
-    const started = [];
-    const firstTurn = registry.run("conversation", createRuntime, async (runtime) => {
-        started.push(runtime.key);
-        firstStarted.resolve(undefined);
-        await releaseFirst.promise;
-    });
-    await firstStarted.promise;
-    const secondTurn = registry.run("conversation", createRuntime, async (runtime) => {
-        started.push(runtime.key);
-    });
-    const thirdTurn = registry.run("conversation", createRuntime, async (runtime) => {
-        started.push(runtime.key);
-    });
-    assert.equal(await registry.cancel("conversation"), true);
-    assert.deepEqual(abortCalls, ["runtime-1"]);
-    releaseFirst.resolve(undefined);
-    await Promise.all([firstTurn, secondTurn, thirdTurn]);
-    assert.deepEqual(started, ["runtime-1"]);
-    assert.deepEqual(closeCalls, []);
-    await registry.run("conversation", createRuntime, async (runtime) => {
-        started.push(runtime.key);
-    });
-    assert.deepEqual(started, ["runtime-1", "runtime-1"]);
-    assert.equal(runtimeCount, 1);
-});
-test("reset closes the current runtime and recreates it on the next turn", async () => {
-    const registry = new RuntimeRegistry(createLogger());
-    const abortCalls = [];
-    const closeCalls = [];
-    let runtimeCount = 0;
-    const createRuntime = async () => {
-        runtimeCount += 1;
-        return createConversationRuntime(`runtime-${runtimeCount}`, abortCalls, closeCalls);
-    };
-    const firstStarted = deferred();
-    const releaseFirst = deferred();
-    const started = [];
-    const firstTurn = registry.run("conversation", createRuntime, async (runtime) => {
-        started.push(runtime.key);
-        firstStarted.resolve(undefined);
-        await releaseFirst.promise;
-    });
-    await firstStarted.promise;
-    const queuedTurn = registry.run("conversation", createRuntime, async (runtime) => {
-        started.push(runtime.key);
-    });
-    const resetPromise = registry.reset("conversation");
-    releaseFirst.resolve(undefined);
-    assert.equal(await resetPromise, true);
-    await Promise.all([firstTurn, queuedTurn]);
-    assert.deepEqual(abortCalls, ["runtime-1"]);
-    assert.deepEqual(closeCalls, ["runtime-1"]);
-    assert.deepEqual(started, ["runtime-1"]);
-    await registry.run("conversation", createRuntime, async (runtime) => {
-        started.push(runtime.key);
-    });
-    assert.deepEqual(started, ["runtime-1", "runtime-2"]);
-    assert.equal(runtimeCount, 2);
-});