@dobby.ai/dobby 0.1.0

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

@@ -0,0 +1,345 @@
+const DEFAULT_DEDUP_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function asItemMap(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    const result = {};
+    for (const [instanceId, raw] of Object.entries(value)) {
+        if (!isRecord(raw) || typeof raw.type !== "string" || raw.type.trim().length === 0) {
+            continue;
+        }
+        result[instanceId] = {
+            ...raw,
+            type: raw.type,
+        };
+    }
+    return result;
+}
+function asAllowList(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const normalized = [];
+    for (const item of value) {
+        if (!isRecord(item) || typeof item.package !== "string" || item.package.trim().length === 0) {
+            continue;
+        }
+        normalized.push({
+            package: item.package,
+            enabled: item.enabled !== false,
+        });
+    }
+    return normalized;
+}
+function asRouteDefaults(value) {
+    if (!isRecord(value)) {
+        return {
+            tools: "full",
+            mentions: "required",
+        };
+    }
+    return {
+        ...(typeof value.provider === "string" && value.provider.trim().length > 0 ? { provider: value.provider } : {}),
+        ...(typeof value.sandbox === "string" && value.sandbox.trim().length > 0 ? { sandbox: value.sandbox } : {}),
+        tools: value.tools === "readonly" ? "readonly" : "full",
+        mentions: value.mentions === "optional" ? "optional" : "required",
+    };
+}
+function asRoutes(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    const normalized = {};
+    for (const [routeId, route] of Object.entries(value)) {
+        if (!isRecord(route) || typeof route.projectRoot !== "string" || route.projectRoot.trim().length === 0) {
+            continue;
+        }
+        normalized[routeId] = {
+            ...route,
+            projectRoot: route.projectRoot,
+            ...(route.tools === "readonly" ? { tools: "readonly" } : {}),
+            ...(route.mentions === "optional" ? { mentions: "optional" } : {}),
+            ...(typeof route.provider === "string" && route.provider.trim().length > 0 ? { provider: route.provider } : {}),
+            ...(typeof route.sandbox === "string" && route.sandbox.trim().length > 0 ? { sandbox: route.sandbox } : {}),
+            ...(typeof route.systemPromptFile === "string" ? { systemPromptFile: route.systemPromptFile } : {}),
+        };
+    }
+    return normalized;
+}
+function asBindings(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    const normalized = {};
+    for (const [bindingId, binding] of Object.entries(value)) {
+        if (!isRecord(binding)) {
+            continue;
+        }
+        const rawSource = binding.source;
+        if (typeof binding.connector !== "string"
+            || binding.connector.trim().length === 0
+            || typeof binding.route !== "string"
+            || binding.route.trim().length === 0
+            || !isRecord(rawSource)
+            || (rawSource.type !== "channel" && rawSource.type !== "chat")
+            || typeof rawSource.id !== "string"
+            || rawSource.id.trim().length === 0) {
+            continue;
+        }
+        normalized[bindingId] = {
+            ...binding,
+            connector: binding.connector,
+            route: binding.route,
+            source: {
+                ...rawSource,
+                type: rawSource.type,
+                id: rawSource.id,
+            },
+        };
+    }
+    return normalized;
+}
+export function ensureGatewayConfigShape(config) {
+    const normalizedProvidersDefault = typeof config.providers?.default === "string" && config.providers.default.trim().length > 0
+        ? config.providers.default
+        : "";
+    const normalizedSandboxesDefault = typeof config.sandboxes?.default === "string" && config.sandboxes.default.trim().length > 0
+        ? config.sandboxes.default
+        : "host.builtin";
+    const routeDefaults = asRouteDefaults(config.routes?.defaults);
+    if (!routeDefaults.provider && normalizedProvidersDefault) {
+        routeDefaults.provider = normalizedProvidersDefault;
+    }
+    if (!routeDefaults.sandbox && normalizedSandboxesDefault) {
+        routeDefaults.sandbox = normalizedSandboxesDefault;
+    }
+    return {
+        ...config,
+        extensions: {
+            ...(isRecord(config.extensions) ? config.extensions : {}),
+            allowList: asAllowList(config.extensions?.allowList),
+        },
+        providers: {
+            ...(isRecord(config.providers) ? config.providers : {}),
+            default: normalizedProvidersDefault,
+            items: asItemMap(config.providers?.items),
+        },
+        connectors: {
+            ...(isRecord(config.connectors) ? config.connectors : {}),
+            items: asItemMap(config.connectors?.items),
+        },
+        sandboxes: {
+            ...(isRecord(config.sandboxes) ? config.sandboxes : {}),
+            default: normalizedSandboxesDefault,
+            items: asItemMap(config.sandboxes?.items),
+        },
+        routes: {
+            ...(isRecord(config.routes) ? config.routes : {}),
+            defaults: routeDefaults,
+            items: asRoutes(config.routes?.items),
+        },
+        bindings: {
+            ...(isRecord(config.bindings) ? config.bindings : {}),
+            items: asBindings(config.bindings?.items),
+        },
+        data: {
+            ...(isRecord(config.data) ? config.data : {}),
+            rootDir: typeof config.data?.rootDir === "string" && config.data.rootDir.trim().length > 0 ? config.data.rootDir : "./data",
+            dedupTtlMs: typeof config.data?.dedupTtlMs === "number" && Number.isFinite(config.data.dedupTtlMs) && config.data.dedupTtlMs > 0
+                ? config.data.dedupTtlMs
+                : DEFAULT_DEDUP_TTL_MS,
+        },
+    };
+}
+export function upsertAllowListPackage(config, packageName, enabled = true) {
+    const next = ensureGatewayConfigShape(config);
+    const allowList = next.extensions.allowList;
+    const existing = allowList.find((item) => item.package === packageName);
+    if (existing) {
+        existing.enabled = enabled;
+        config.extensions = next.extensions;
+        return;
+    }
+    allowList.push({ package: packageName, enabled });
+    config.extensions = {
+        ...next.extensions,
+        allowList,
+    };
+}
+function buildTemplateInstanceId(contributionId) {
+    const segments = contributionId.split(".");
+    const suffix = segments.length > 1 ? segments.slice(1).join("-") : contributionId;
+    return `${suffix}.main`;
+}
+export function buildContributionTemplates(contributions) {
+    const templates = {
+        providers: [],
+        connectors: [],
+        sandboxes: [],
+    };
+    for (const contribution of contributions) {
+        const template = {
+            id: buildTemplateInstanceId(contribution.id),
+            type: contribution.id,
+            config: {},
+        };
+        if (contribution.kind === "provider") {
+            templates.providers.push(template);
+            continue;
+        }
+        if (contribution.kind === "connector") {
+            templates.connectors.push(template);
+            continue;
+        }
+        templates.sandboxes.push(template);
+    }
+    return templates;
+}
+function upsertTemplateInstances(items, templates) {
+    const byType = new Set(Object.values(items).map((instance) => instance.type));
+    const addedIds = [];
+    for (const template of templates) {
+        if (byType.has(template.type)) {
+            continue;
+        }
+        let candidateId = template.id;
+        let suffix = 2;
+        while (items[candidateId]) {
+            candidateId = `${template.id}-${suffix}`;
+            suffix += 1;
+        }
+        items[candidateId] = {
+            type: template.type,
+            ...structuredClone(template.config),
+        };
+        byType.add(template.type);
+        addedIds.push(candidateId);
+    }
+    return addedIds;
+}
+export function applyContributionTemplates(config, templates) {
+    const next = ensureGatewayConfigShape(config);
+    const providerItems = next.providers.items;
+    const connectorItems = next.connectors.items;
+    const sandboxItems = next.sandboxes.items;
+    const added = {
+        providers: upsertTemplateInstances(providerItems, templates.providers),
+        connectors: upsertTemplateInstances(connectorItems, templates.connectors),
+        sandboxes: upsertTemplateInstances(sandboxItems, templates.sandboxes),
+    };
+    config.providers = {
+        ...next.providers,
+        items: providerItems,
+    };
+    config.connectors = {
+        ...next.connectors,
+        items: connectorItems,
+    };
+    config.sandboxes = {
+        ...next.sandboxes,
+        items: sandboxItems,
+    };
+    return added;
+}
+export function upsertProviderInstance(config, instanceId, type, instanceConfig) {
+    const next = ensureGatewayConfigShape(config);
+    next.providers.items[instanceId] = {
+        type,
+        ...structuredClone(instanceConfig),
+    };
+    config.providers = {
+        ...next.providers,
+        items: next.providers.items,
+    };
+}
+export function upsertConnectorInstance(config, instanceId, type, instanceConfig) {
+    const next = ensureGatewayConfigShape(config);
+    next.connectors.items[instanceId] = {
+        type,
+        ...structuredClone(instanceConfig),
+    };
+    config.connectors = {
+        ...next.connectors,
+        items: next.connectors.items,
+    };
+}
+export function upsertSandboxInstance(config, instanceId, type, instanceConfig) {
+    const next = ensureGatewayConfigShape(config);
+    next.sandboxes.items[instanceId] = {
+        type,
+        ...structuredClone(instanceConfig),
+    };
+    config.sandboxes = {
+        ...next.sandboxes,
+        items: next.sandboxes.items,
+    };
+}
+export function setDefaultProviderIfMissingOrInvalid(config) {
+    const next = ensureGatewayConfigShape(config);
+    const items = next.providers.items;
+    const defaultProvider = next.providers.default;
+    if (defaultProvider && items[defaultProvider]) {
+        config.providers = next.providers;
+        if (!next.routes.defaults.provider) {
+            config.routes = {
+                ...next.routes,
+                defaults: {
+                    ...next.routes.defaults,
+                    provider: defaultProvider,
+                },
+            };
+        }
+        return;
+    }
+    const candidates = Object.keys(items).sort((a, b) => a.localeCompare(b));
+    if (candidates.length === 0) {
+        config.providers = next.providers;
+        return;
+    }
+    config.providers = {
+        ...next.providers,
+        default: candidates[0],
+        items,
+    };
+    config.routes = {
+        ...next.routes,
+        defaults: {
+            ...next.routes.defaults,
+            provider: candidates[0],
+        },
+    };
+}
+export function upsertRoute(config, routeId, profile) {
+    const next = ensureGatewayConfigShape(config);
+    next.routes.items[routeId] = {
+        projectRoot: profile.projectRoot,
+        ...(profile.tools ? { tools: profile.tools } : {}),
+        ...(profile.mentions ? { mentions: profile.mentions } : {}),
+        ...(profile.provider ? { provider: profile.provider } : {}),
+        ...(profile.sandbox ? { sandbox: profile.sandbox } : {}),
+        ...(typeof profile.systemPromptFile === "string" ? { systemPromptFile: profile.systemPromptFile } : {}),
+    };
+    config.routes = {
+        ...next.routes,
+        items: next.routes.items,
+    };
+}
+export function upsertBinding(config, bindingId, binding) {
+    const next = ensureGatewayConfigShape(config);
+    next.bindings.items[bindingId] = structuredClone(binding);
+    config.bindings = {
+        ...next.bindings,
+        items: next.bindings.items,
+    };
+}
+export function listContributionIds(config) {
+    const next = ensureGatewayConfigShape(config);
+    return {
+        providers: Object.values(next.providers.items).map((instance) => instance.type),
+        connectors: Object.values(next.connectors.items).map((instance) => instance.type),
+        sandboxes: Object.values(next.sandboxes.items).map((instance) => instance.type),
+    };
+}

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

@@ -0,0 +1,207 @@
+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/config-schema.js

@@ -0,0 +1,159 @@
+import { Ajv } from "ajv";
+import { join } from "node:path";
+import pino from "pino";
+import { ExtensionLoader } from "../../extension/loader.js";
+import { ExtensionRegistry } from "../../extension/registry.js";
+import { ensureGatewayConfigShape } from "./config-mutators.js";
+import { resolveDataRootDir } from "./config-io.js";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function decodeJsonPointerSegment(value) {
+    return value.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+function normalizeSchemaForValidation(schema) {
+    const cloned = structuredClone(schema);
+    if (isRecord(cloned) && typeof cloned.$schema === "string") {
+        delete cloned.$schema;
+    }
+    return cloned;
+}
+function formatErrorPath(instancePath) {
+    if (!instancePath) {
+        return "";
+    }
+    const segments = instancePath
+        .split("/")
+        .slice(1)
+        .map((segment) => decodeJsonPointerSegment(segment))
+        .filter((segment) => segment.length > 0);
+    if (segments.length === 0) {
+        return "";
+    }
+    let formatted = "";
+    for (const segment of segments) {
+        if (/^\d+$/.test(segment)) {
+            formatted += `[${segment}]`;
+            continue;
+        }
+        if (/^[a-zA-Z_$][\w$]*$/.test(segment)) {
+            formatted += `.${segment}`;
+            continue;
+        }
+        formatted += `['${segment.replaceAll("'", "\\'")}']`;
+    }
+    return formatted;
+}
+function buildValidationErrorMessage(task, contributionId, errors) {
+    const details = (errors ?? [])
+        .slice(0, 5)
+        .map((error) => {
+        const suffix = formatErrorPath(error.instancePath);
+        return `${task.section}.items['${task.instanceId}']${suffix}: ${error.message ?? "invalid"}`;
+    })
+        .join("; ");
+    return (`Invalid config for instance '${task.instanceId}' (contribution '${contributionId}'). `
+        + (details.length > 0 ? details : "Schema validation failed."));
+}
+async function loadRegistryForConfig(configPath, rawConfig) {
+    const normalized = ensureGatewayConfigShape(structuredClone(rawConfig));
+    const rootDir = resolveDataRootDir(configPath, normalized);
+    const loader = new ExtensionLoader(pino({ name: "dobby.config-schema", level: "silent" }), {
+        extensionsDir: join(rootDir, "extensions"),
+    });
+    const loadedPackages = await loader.loadAllowList(normalized.extensions.allowList);
+    const registry = new ExtensionRegistry();
+    registry.registerPackages(loadedPackages);
+    return registry;
+}
+/**
+ * Loads contribution-level JSON Schema catalog from installed/allow-listed extensions.
+ */
+export async function loadContributionSchemaCatalog(configPath, rawConfig) {
+    const registry = await loadRegistryForConfig(configPath, rawConfig);
+    return registry.listContributionSchemas();
+}
+/**
+ * Lists available contribution schemas with lightweight flags for CLI display.
+ */
+export async function listContributionSchemas(configPath, rawConfig) {
+    const catalog = await loadContributionSchemaCatalog(configPath, rawConfig);
+    return catalog.map((item) => ({
+        contributionId: item.contributionId,
+        packageName: item.packageName,
+        kind: item.kind,
+        hasSchema: Boolean(item.configSchema),
+    }));
+}
+/**
+ * Returns one contribution schema entry, or null when not found.
+ */
+export async function getContributionSchema(configPath, rawConfig, contributionId) {
+    const catalog = await loadContributionSchemaCatalog(configPath, rawConfig);
+    return catalog.find((item) => item.contributionId === contributionId) ?? null;
+}
+/**
+ * Applies extension config defaults and validates provider/connector/sandbox instance configs with Ajv.
+ */
+export async function applyAndValidateContributionSchemas(configPath, rawConfig) {
+    const next = ensureGatewayConfigShape(structuredClone(rawConfig));
+    const catalog = await loadContributionSchemaCatalog(configPath, next);
+    const schemaByContribution = new Map();
+    for (const entry of catalog) {
+        if (!entry.configSchema) {
+            continue;
+        }
+        schemaByContribution.set(entry.contributionId, normalizeSchemaForValidation(entry.configSchema));
+    }
+    const ajv = new Ajv({
+        allErrors: true,
+        strict: false,
+        useDefaults: true,
+    });
+    const validators = new Map();
+    const tasks = [
+        ...Object.entries(next.providers.items).map(([instanceId, instance]) => ({
+            section: "providers",
+            instanceId,
+            instance,
+        })),
+        ...Object.entries(next.connectors.items).map(([instanceId, instance]) => ({
+            section: "connectors",
+            instanceId,
+            instance,
+        })),
+        ...Object.entries(next.sandboxes.items).map(([instanceId, instance]) => ({
+            section: "sandboxes",
+            instanceId,
+            instance,
+        })),
+    ];
+    for (const task of tasks) {
+        const contributionId = task.instance.type;
+        const schema = schemaByContribution.get(contributionId);
+        if (!schema) {
+            continue;
+        }
+        let validate = validators.get(contributionId);
+        if (!validate) {
+            const compiled = ajv.compile(schema);
+            validators.set(contributionId, compiled);
+            validate = compiled;
+        }
+        const { type: _type, ...instanceConfig } = task.instance;
+        const valid = validate(instanceConfig);
+        if (!valid) {
+            throw new Error(buildValidationErrorMessage(task, contributionId, validate.errors));
+        }
+        for (const key of Object.keys(task.instance)) {
+            if (key !== "type") {
+                delete task.instance[key];
+            }
+        }
+        Object.assign(task.instance, {
+            type: contributionId,
+            ...instanceConfig,
+        });
+    }
+    return next;
+}