@dobby.ai/dobby 0.1.0

package/dist/src/core/routing.js

@@ -0,0 +1,306 @@
+import { existsSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { z } from "zod";
+import { BUILTIN_HOST_SANDBOX_ID } from "./types.js";
+const extensionItemSchema = z.object({
+    type: z.string().trim().min(1),
+}).catchall(z.unknown());
+const routeDefaultsSchema = z.object({
+    provider: z.string().trim().min(1).optional(),
+    sandbox: z.string().trim().min(1).optional(),
+    tools: z.enum(["full", "readonly"]).optional(),
+    mentions: z.enum(["required", "optional"]).optional(),
+}).strict();
+const routeItemSchema = z.object({
+    projectRoot: z.string().trim().min(1),
+    tools: z.enum(["full", "readonly"]).optional(),
+    mentions: z.enum(["required", "optional"]).optional(),
+    provider: z.string().trim().min(1).optional(),
+    sandbox: z.string().trim().min(1).optional(),
+    systemPromptFile: z
+        .string()
+        .optional()
+        .transform((value) => (value && value.trim().length > 0 ? value : undefined)),
+}).strict();
+const bindingSourceSchema = z.object({
+    type: z.enum(["channel", "chat"]),
+    id: z.string().trim().min(1),
+}).strict();
+const bindingItemSchema = z.object({
+    connector: z.string().trim().min(1),
+    source: bindingSourceSchema,
+    route: z.string().trim().min(1),
+}).strict();
+const gatewayConfigSchema = z.object({
+    extensions: z.object({
+        allowList: z
+            .array(z.object({
+            package: z.string().trim().min(1),
+            enabled: z.boolean().default(true),
+        }).strict())
+            .default([]),
+    }).strict(),
+    providers: z.object({
+        default: z.string().trim().min(1),
+        items: z.record(z.string(), extensionItemSchema),
+    }).strict(),
+    connectors: z.object({
+        items: z.record(z.string(), extensionItemSchema),
+    }).strict(),
+    sandboxes: z.object({
+        default: z.string().trim().min(1).optional(),
+        items: z.record(z.string(), extensionItemSchema).default({}),
+    }).strict(),
+    routes: z.object({
+        defaults: routeDefaultsSchema.default({}),
+        items: z.record(z.string(), routeItemSchema),
+    }).strict(),
+    bindings: z.object({
+        items: z.record(z.string(), bindingItemSchema).default({}),
+    }).strict(),
+    data: z.object({
+        rootDir: z.string().default("./data"),
+        dedupTtlMs: z.number().int().positive().default(7 * 24 * 60 * 60 * 1000),
+    }).strict(),
+}).strict();
+const FORBIDDEN_CONNECTOR_CONFIG_KEYS = {
+    botChannelMap: "Use bindings.items to map connector sources to routes.",
+    chatRouteMap: "Use bindings.items to map connector sources to routes.",
+    botTokenEnv: "Set botToken directly in connector config or inject it before the config is loaded.",
+};
+function isDobbyRepoRoot(candidateDir) {
+    const packageJsonPath = resolve(candidateDir, "package.json");
+    const repoConfigPath = resolve(candidateDir, "config", "gateway.json");
+    const localExtensionsScriptPath = resolve(candidateDir, "scripts", "local-extensions.mjs");
+    if (!existsSync(packageJsonPath) || !existsSync(repoConfigPath) || !existsSync(localExtensionsScriptPath)) {
+        return false;
+    }
+    try {
+        const packageJsonRaw = readFileSync(packageJsonPath, "utf-8");
+        const parsed = JSON.parse(packageJsonRaw);
+        return parsed.name === "dobby";
+    }
+    catch {
+        return false;
+    }
+}
+function resolveConfigBaseDir(configPath) {
+    const absoluteConfigPath = resolve(configPath);
+    const configDir = dirname(absoluteConfigPath);
+    const repoRoot = dirname(configDir);
+    if (absoluteConfigPath === resolve(repoRoot, "config", "gateway.json") && isDobbyRepoRoot(repoRoot)) {
+        return repoRoot;
+    }
+    return configDir;
+}
+function resolveMaybeAbsolute(baseDir, value) {
+    const expanded = expandHome(value);
+    return isAbsolute(expanded) ? resolve(expanded) : resolve(baseDir, expanded);
+}
+function expandHome(value) {
+    if (value === "~") {
+        return homedir();
+    }
+    if (value.startsWith("~/") || value.startsWith("~\\")) {
+        return resolve(homedir(), value.slice(2));
+    }
+    return value;
+}
+function normalizeInstanceItem(item) {
+    const { type, ...config } = item;
+    return {
+        type,
+        config,
+    };
+}
+function normalizeInstances(parsedItems) {
+    const normalized = {};
+    for (const [id, item] of Object.entries(parsedItems)) {
+        normalized[id] = normalizeInstanceItem(item);
+    }
+    return normalized;
+}
+function normalizeExtensions(parsed) {
+    return {
+        allowList: parsed.allowList.map((item) => ({
+            package: item.package,
+            enabled: item.enabled,
+        })),
+    };
+}
+function normalizeProviders(parsed) {
+    return {
+        default: parsed.default,
+        items: normalizeInstances(parsed.items),
+    };
+}
+function normalizeConnectors(parsed) {
+    return {
+        items: normalizeInstances(parsed.items),
+    };
+}
+function normalizeSandboxes(parsed) {
+    return {
+        ...(parsed.default ? { default: parsed.default } : {}),
+        items: normalizeInstances(parsed.items),
+    };
+}
+function normalizeRouteProfile(baseDir, profile, defaults) {
+    const normalized = {
+        projectRoot: resolveMaybeAbsolute(baseDir, profile.projectRoot),
+        tools: profile.tools ?? defaults.tools,
+        mentions: profile.mentions ?? defaults.mentions,
+        provider: profile.provider ?? defaults.provider,
+        sandbox: profile.sandbox ?? defaults.sandbox,
+    };
+    if (profile.systemPromptFile) {
+        normalized.systemPromptFile = resolveMaybeAbsolute(baseDir, profile.systemPromptFile);
+    }
+    return normalized;
+}
+function normalizeRoutes(parsed, baseDir, defaults) {
+    const items = {};
+    for (const [routeId, profile] of Object.entries(parsed.items)) {
+        items[routeId] = normalizeRouteProfile(baseDir, profile, defaults);
+    }
+    return {
+        defaults,
+        items,
+    };
+}
+function normalizeBindings(parsed) {
+    const items = {};
+    for (const [bindingId, binding] of Object.entries(parsed.items)) {
+        items[bindingId] = {
+            connector: binding.connector,
+            source: {
+                type: binding.source.type,
+                id: binding.source.id,
+            },
+            route: binding.route,
+        };
+    }
+    return { items };
+}
+function validateConnectorConfigKeys(parsed) {
+    for (const [instanceId, item] of Object.entries(parsed.items)) {
+        for (const [key, message] of Object.entries(FORBIDDEN_CONNECTOR_CONFIG_KEYS)) {
+            if (Object.prototype.hasOwnProperty.call(item, key)) {
+                throw new Error(`connectors.items['${instanceId}'] must not include '${key}'. ${message}`);
+            }
+        }
+    }
+}
+function validateReferences(parsed, normalizedRoutes) {
+    if (!parsed.providers.items[parsed.providers.default]) {
+        throw new Error(`providers.default '${parsed.providers.default}' does not exist in providers.items`);
+    }
+    const defaultSandbox = parsed.sandboxes.default ?? BUILTIN_HOST_SANDBOX_ID;
+    if (defaultSandbox !== BUILTIN_HOST_SANDBOX_ID && !parsed.sandboxes.items[defaultSandbox]) {
+        throw new Error(`sandboxes.default '${defaultSandbox}' does not exist in sandboxes.items`);
+    }
+    const resolvedDefaults = {
+        provider: parsed.routes.defaults.provider ?? parsed.providers.default,
+        sandbox: parsed.routes.defaults.sandbox ?? parsed.sandboxes.default ?? BUILTIN_HOST_SANDBOX_ID,
+        tools: parsed.routes.defaults.tools ?? "full",
+        mentions: parsed.routes.defaults.mentions ?? "required",
+    };
+    if (!parsed.providers.items[resolvedDefaults.provider]) {
+        throw new Error(`routes.defaults.provider references unknown provider '${resolvedDefaults.provider}'`);
+    }
+    if (resolvedDefaults.sandbox !== BUILTIN_HOST_SANDBOX_ID && !parsed.sandboxes.items[resolvedDefaults.sandbox]) {
+        throw new Error(`routes.defaults.sandbox references unknown sandbox '${resolvedDefaults.sandbox}'`);
+    }
+    for (const [routeId, profile] of Object.entries(normalizedRoutes.items)) {
+        if (!parsed.providers.items[profile.provider]) {
+            throw new Error(`routes.items['${routeId}'].provider references unknown provider '${profile.provider}'`);
+        }
+        if (profile.sandbox !== BUILTIN_HOST_SANDBOX_ID && !parsed.sandboxes.items[profile.sandbox]) {
+            throw new Error(`routes.items['${routeId}'].sandbox references unknown sandbox '${profile.sandbox}'`);
+        }
+    }
+    const seenSources = new Map();
+    for (const [bindingId, binding] of Object.entries(parsed.bindings.items)) {
+        if (!parsed.connectors.items[binding.connector]) {
+            throw new Error(`bindings.items['${bindingId}'].connector references unknown connector '${binding.connector}'`);
+        }
+        if (!normalizedRoutes.items[binding.route]) {
+            throw new Error(`bindings.items['${bindingId}'].route references unknown route '${binding.route}'`);
+        }
+        const bindingKey = `${binding.connector}:${binding.source.type}:${binding.source.id}`;
+        const existingBindingId = seenSources.get(bindingKey);
+        if (existingBindingId) {
+            throw new Error(`bindings.items['${bindingId}'] duplicates source '${bindingKey}' already used by bindings.items['${existingBindingId}']`);
+        }
+        seenSources.set(bindingKey, bindingId);
+    }
+}
+export async function loadGatewayConfig(configPath) {
+    const absoluteConfigPath = resolve(configPath);
+    const configBaseDir = resolveConfigBaseDir(absoluteConfigPath);
+    const raw = await readFile(absoluteConfigPath, "utf-8");
+    const parsed = gatewayConfigSchema.parse(JSON.parse(raw));
+    validateConnectorConfigKeys(parsed.connectors);
+    const routeDefaults = {
+        provider: parsed.routes.defaults.provider ?? parsed.providers.default,
+        sandbox: parsed.routes.defaults.sandbox ?? parsed.sandboxes.default ?? BUILTIN_HOST_SANDBOX_ID,
+        tools: parsed.routes.defaults.tools ?? "full",
+        mentions: parsed.routes.defaults.mentions ?? "required",
+    };
+    const normalizedRoutes = normalizeRoutes(parsed.routes, configBaseDir, routeDefaults);
+    validateReferences(parsed, normalizedRoutes);
+    const rootDir = resolveMaybeAbsolute(configBaseDir, parsed.data.rootDir);
+    return {
+        extensions: normalizeExtensions(parsed.extensions),
+        providers: normalizeProviders(parsed.providers),
+        connectors: normalizeConnectors(parsed.connectors),
+        sandboxes: normalizeSandboxes(parsed.sandboxes),
+        routes: normalizedRoutes,
+        bindings: normalizeBindings(parsed.bindings),
+        data: {
+            rootDir,
+            sessionsDir: resolve(rootDir, "sessions"),
+            attachmentsDir: resolve(rootDir, "attachments"),
+            logsDir: resolve(rootDir, "logs"),
+            stateDir: resolve(rootDir, "state"),
+            dedupTtlMs: parsed.data.dedupTtlMs,
+        },
+    };
+}
+export class RouteResolver {
+    routes;
+    constructor(routes) {
+        this.routes = routes;
+    }
+    resolve(routeId) {
+        const normalizedRouteId = routeId.trim();
+        if (!normalizedRouteId)
+            return null;
+        const profile = this.routes.items[normalizedRouteId];
+        if (!profile)
+            return null;
+        return { routeId: normalizedRouteId, profile };
+    }
+}
+export class BindingResolver {
+    bindingsBySource = new Map();
+    constructor(bindings) {
+        for (const [bindingId, binding] of Object.entries(bindings.items)) {
+            this.bindingsBySource.set(this.buildKey(binding.connector, binding.source), {
+                bindingId,
+                config: binding,
+            });
+        }
+    }
+    resolve(connectorId, source) {
+        if (!connectorId.trim() || !source.id.trim()) {
+            return null;
+        }
+        return this.bindingsBySource.get(this.buildKey(connectorId, source)) ?? null;
+    }
+    buildKey(connectorId, source) {
+        return `${connectorId.trim()}:${source.type}:${source.id.trim()}`;
+    }
+}

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

@@ -0,0 +1,119 @@
+export class RuntimeRegistry {
+    logger;
+    entries = new Map();
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async run(key, createFn, task) {
+        const entry = this.getOrCreateEntry(key);
+        const scheduledEpoch = entry.epoch;
+        entry.scheduledTasks += 1;
+        const run = entry.tail.then(async () => {
+            if (scheduledEpoch !== entry.epoch)
+                return;
+            let runtime = entry.runtime;
+            if (!runtime) {
+                const created = await createFn();
+                if (scheduledEpoch !== entry.epoch) {
+                    await this.closeRuntime(key, created, "Discarding runtime created for stale queued task");
+                    return;
+                }
+                entry.runtime = created;
+                runtime = created;
+            }
+            await task(runtime);
+        });
+        const managedRun = run.finally(() => {
+            entry.scheduledTasks = Math.max(0, entry.scheduledTasks - 1);
+        });
+        this.attachTail(key, entry, managedRun, "Queued task failed");
+        await managedRun;
+    }
+    async abort(key) {
+        const entry = this.entries.get(key);
+        if (!entry?.runtime)
+            return false;
+        return this.abortRuntime(key, entry.runtime, "Failed to abort runtime");
+    }
+    async cancel(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return false;
+        if (entry.scheduledTasks === 0)
+            return false;
+        entry.epoch += 1;
+        if (!entry.runtime)
+            return true;
+        return this.abortRuntime(key, entry.runtime, "Failed to cancel runtime");
+    }
+    async reset(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return false;
+        entry.epoch += 1;
+        if (entry.runtime) {
+            await this.abortRuntime(key, entry.runtime, "Failed to abort runtime during reset");
+        }
+        const close = entry.tail.then(async () => {
+            const runtime = entry.runtime;
+            entry.runtime = undefined;
+            if (!runtime)
+                return;
+            await this.closeRuntime(key, runtime, "Failed to close runtime during reset");
+        });
+        this.attachTail(key, entry, close);
+        await close;
+        return true;
+    }
+    async closeAll() {
+        const keys = [...this.entries.keys()];
+        await Promise.all(keys.map((key) => this.reset(key)));
+        this.entries.clear();
+    }
+    getOrCreateEntry(key) {
+        const existing = this.entries.get(key);
+        if (existing)
+            return existing;
+        const entry = {
+            runtime: undefined,
+            tail: Promise.resolve(),
+            epoch: 0,
+            scheduledTasks: 0,
+        };
+        this.entries.set(key, entry);
+        return entry;
+    }
+    attachTail(key, entry, run, errorMessage = "Queued task failed") {
+        const nextTail = run.catch((error) => {
+            this.logger.error({ err: error, conversationKey: key }, errorMessage);
+        });
+        entry.tail = nextTail;
+        void nextTail.finally(() => {
+            if (this.entries.get(key) !== entry)
+                return;
+            if (entry.runtime !== undefined)
+                return;
+            if (entry.tail !== nextTail)
+                return;
+            this.entries.delete(key);
+        });
+    }
+    async abortRuntime(key, runtime, errorMessage) {
+        try {
+            await runtime.runtime.abort();
+            return true;
+        }
+        catch (error) {
+            this.logger.error({ err: error, conversationKey: key }, errorMessage);
+            return false;
+        }
+    }
+    async closeRuntime(key, runtime, errorMessage) {
+        try {
+            await runtime.close();
+        }
+        catch (error) {
+            this.logger.error({ err: error, conversationKey: key }, errorMessage);
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+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

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