@dobby.ai/dobby 0.1.0 → 0.1.2

package/dist/src/cli/shared/init-catalog.js

@@ -1,25 +1,26 @@
-import { DEFAULT_DISCORD_CONNECTOR_INSTANCE_ID, DISCORD_CONNECTOR_CONTRIBUTION_ID, } from "./discord-config.js";
+import { DEFAULT_DISCORD_BOT_NAME, DEFAULT_DISCORD_CONNECTOR_INSTANCE_ID, DISCORD_CONNECTOR_CONTRIBUTION_ID, } from "./discord-config.js";
+export const DEFAULT_INIT_ROUTE_ID = "main";
+export const DEFAULT_INIT_PROJECT_ROOT = "./REPLACE_WITH_PROJECT_ROOT";
 const PROVIDER_CATALOG = {
     "provider.pi": {
         id: "provider.pi",
         label: "Pi provider",
-        extensionPackage: "@dobby.ai/provider-pi",
+        package: "@dobby.ai/provider-pi",
         instanceId: "pi.main",
         contributionId: "provider.pi",
-        config: {
-            provider: "custom-openai",
-            model: "example-model",
-            thinkingLevel: "off",
-            modelsFile: "./models.custom.json",
+        defaultConfig: {
+            model: "REPLACE_WITH_PROVIDER_MODEL_ID",
+            baseUrl: "REPLACE_WITH_PROVIDER_BASE_URL",
+            apiKey: "REPLACE_WITH_PROVIDER_API_KEY_OR_ENV",
         },
     },
     "provider.claude-cli": {
         id: "provider.claude-cli",
         label: "Claude CLI provider",
-        extensionPackage: "@dobby.ai/provider-claude-cli",
+        package: "@dobby.ai/provider-claude-cli",
         instanceId: "claude-cli.main",
         contributionId: "provider.claude-cli",
-        config: {
+        defaultConfig: {
             model: "claude-sonnet-4-5",
             maxTurns: 20,
             command: "claude",
@@ -34,11 +35,52 @@ const CONNECTOR_CATALOG = {
     "connector.discord": {
         id: "connector.discord",
         label: "Discord connector",
-        extensionPackage: "@dobby.ai/connector-discord",
+        package: "@dobby.ai/connector-discord",
         instanceId: DEFAULT_DISCORD_CONNECTOR_INSTANCE_ID,
         contributionId: DISCORD_CONNECTOR_CONTRIBUTION_ID,
+        defaultConfig: {
+            botName: DEFAULT_DISCORD_BOT_NAME,
+            botToken: "REPLACE_WITH_DISCORD_BOT_TOKEN",
+            reconnectStaleMs: 60_000,
+            reconnectCheckIntervalMs: 10_000,
+        },
+        bindingTemplate: {
+            sourceType: "channel",
+            sourceId: "YOUR_DISCORD_CHANNEL_ID",
+        },
+    },
+    "connector.feishu": {
+        id: "connector.feishu",
+        label: "Feishu connector",
+        package: "@dobby.ai/connector-feishu",
+        instanceId: "feishu.main",
+        contributionId: "connector.feishu",
+        defaultConfig: {
+            appId: "REPLACE_WITH_FEISHU_APP_ID",
+            appSecret: "REPLACE_WITH_FEISHU_APP_SECRET",
+            domain: "feishu",
+            messageFormat: "card_markdown",
+            replyMode: "direct",
+            downloadAttachments: true,
+        },
+        bindingTemplate: {
+            sourceType: "chat",
+            sourceId: "YOUR_FEISHU_CHAT_ID",
+        },
     },
 };
+function dedupeChoiceIds(choiceIds) {
+    const dedupedChoiceIds = [];
+    const seenChoiceIds = new Set();
+    for (const choiceId of choiceIds) {
+        if (seenChoiceIds.has(choiceId)) {
+            continue;
+        }
+        seenChoiceIds.add(choiceId);
+        dedupedChoiceIds.push(choiceId);
+    }
+    return dedupedChoiceIds;
+}
 export function listInitProviderChoices() {
     return Object.values(PROVIDER_CATALOG);
 }
@@ -51,65 +93,66 @@ export function isInitProviderChoiceId(value) {
 export function isInitConnectorChoiceId(value) {
     return Object.prototype.hasOwnProperty.call(CONNECTOR_CATALOG, value);
 }
-export function createInitSelectionConfig(providerChoiceIds, connectorChoiceId, context) {
-    const dedupedProviderChoiceIds = [];
-    const seenProviderChoiceIds = new Set();
-    for (const providerChoiceId of providerChoiceIds) {
-        if (!seenProviderChoiceIds.has(providerChoiceId)) {
-            seenProviderChoiceIds.add(providerChoiceId);
-            dedupedProviderChoiceIds.push(providerChoiceId);
-        }
-    }
+export function createInitSelectionConfig(providerChoiceIds, connectorChoiceIds, context) {
+    const dedupedProviderChoiceIds = dedupeChoiceIds(providerChoiceIds);
     if (dedupedProviderChoiceIds.length === 0) {
         throw new Error("At least one provider choice is required");
     }
+    const dedupedConnectorChoiceIds = dedupeChoiceIds(connectorChoiceIds);
+    if (dedupedConnectorChoiceIds.length === 0) {
+        throw new Error("At least one connector choice is required");
+    }
     if (!dedupedProviderChoiceIds.includes(context.routeProviderChoiceId)) {
         throw new Error(`route provider choice '${context.routeProviderChoiceId}' must be one of selected providers: ${dedupedProviderChoiceIds.join(", ")}`);
     }
     const providerChoices = dedupedProviderChoiceIds.map((providerChoiceId) => PROVIDER_CATALOG[providerChoiceId]);
+    const connectorChoices = dedupedConnectorChoiceIds.map((connectorChoiceId) => CONNECTOR_CATALOG[connectorChoiceId]);
     const primaryProviderChoice = PROVIDER_CATALOG[context.routeProviderChoiceId];
-    const connectorChoice = CONNECTOR_CATALOG[connectorChoiceId];
     return {
         providerChoiceIds: dedupedProviderChoiceIds,
         routeProviderChoiceId: primaryProviderChoice.id,
-        providerChoiceId: primaryProviderChoice.id,
-        connectorChoiceId,
+        connectorChoiceIds: dedupedConnectorChoiceIds,
         extensionPackages: [
-            ...new Set([...providerChoices.map((item) => item.extensionPackage), connectorChoice.extensionPackage]),
+            ...new Set([
+                ...providerChoices.map((item) => item.package),
+                ...connectorChoices.map((item) => item.package),
+            ]),
         ],
         providerInstances: providerChoices.map((providerChoice) => ({
             choiceId: providerChoice.id,
             instanceId: providerChoice.instanceId,
             contributionId: providerChoice.contributionId,
-            config: structuredClone(providerChoice.config),
+            config: structuredClone(providerChoice.defaultConfig),
+        })),
+        connectorInstances: connectorChoices.map((connectorChoice) => ({
+            choiceId: connectorChoice.id,
+            instanceId: connectorChoice.instanceId,
+            contributionId: connectorChoice.contributionId,
+            config: structuredClone(connectorChoice.defaultConfig),
         })),
         providerInstanceId: primaryProviderChoice.instanceId,
-        providerContributionId: primaryProviderChoice.contributionId,
-        providerConfig: structuredClone(primaryProviderChoice.config),
-        connectorInstanceId: connectorChoice.instanceId,
-        connectorContributionId: connectorChoice.contributionId,
-        connectorConfig: {
-            botName: context.botName,
-            botToken: context.botToken,
-            reconnectStaleMs: 60_000,
-            reconnectCheckIntervalMs: 10_000,
-        },
-        routeProfile: {
-            projectRoot: context.projectRoot,
+        routeId: DEFAULT_INIT_ROUTE_ID,
+        routeDefaults: {
+            projectRoot: context.defaultProjectRoot ?? DEFAULT_INIT_PROJECT_ROOT,
             tools: "full",
-            systemPromptFile: "",
-            mentions: context.allowAllMessages ? "optional" : "required",
+            mentions: "required",
             provider: primaryProviderChoice.instanceId,
             sandbox: "host.builtin",
         },
-        bindingId: `${connectorChoice.instanceId}.${context.routeId}`,
-        bindingConfig: {
-            connector: connectorChoice.instanceId,
-            source: {
-                type: "channel",
-                id: context.channelId,
-            },
-            route: context.routeId,
+        routeProfile: {},
+        defaultBinding: {
+            route: DEFAULT_INIT_ROUTE_ID,
         },
+        bindings: connectorChoices.map((connectorChoice) => ({
+            id: `${connectorChoice.instanceId}.${DEFAULT_INIT_ROUTE_ID}`,
+            config: {
+                connector: connectorChoice.instanceId,
+                source: {
+                    type: connectorChoice.bindingTemplate.sourceType,
+                    id: connectorChoice.bindingTemplate.sourceId,
+                },
+                route: DEFAULT_INIT_ROUTE_ID,
+            },
+        })),
     };
 }

package/dist/src/cli/shared/local-extension-specs.js

@@ -0,0 +1,85 @@
+import { access, readFile } from "node:fs/promises";
+import { readdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import { findDobbyRepoRoot } from "../../shared/dobby-repo.js";
+function isExplicitInstallSpec(value) {
+    return value.startsWith("file:")
+        || value.startsWith("git+")
+        || value.startsWith("http://")
+        || value.startsWith("https://")
+        || value.startsWith("./")
+        || value.startsWith("../")
+        || value.startsWith("/");
+}
+async function listRepoLocalExtensionPackages(repoRoot) {
+    const pluginsRoot = resolve(repoRoot, "plugins");
+    const entries = await readdir(pluginsRoot, { withFileTypes: true });
+    const packages = new Map();
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name === "plugin-sdk") {
+            continue;
+        }
+        const packageDir = resolve(pluginsRoot, entry.name);
+        const packageJsonPath = resolve(packageDir, "package.json");
+        const manifestPath = resolve(packageDir, "dobby.manifest.json");
+        try {
+            await access(packageJsonPath);
+            await access(manifestPath);
+            const raw = await readFile(packageJsonPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.name !== "string" || parsed.name.trim().length === 0) {
+                continue;
+            }
+            packages.set(parsed.name, {
+                packageName: parsed.name,
+                packageDir,
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return packages;
+}
+async function assertLocalExtensionBuildReady(localPackage) {
+    const manifestPath = resolve(localPackage.packageDir, "dobby.manifest.json");
+    const rawManifest = await readFile(manifestPath, "utf-8");
+    const parsed = JSON.parse(rawManifest);
+    for (const contribution of parsed.contributions ?? []) {
+        if (typeof contribution.entry !== "string" || contribution.entry.trim().length === 0) {
+            continue;
+        }
+        const entryPath = resolve(localPackage.packageDir, contribution.entry);
+        try {
+            await access(entryPath);
+        }
+        catch {
+            const contributionId = typeof contribution.id === "string" ? contribution.id : "unknown";
+            throw new Error(`Local extension '${localPackage.packageName}' is not built for contribution '${contributionId}'. `
+                + `Missing '${entryPath}'. Run 'npm run build --prefix ${localPackage.packageDir}' first.`);
+        }
+    }
+}
+export async function resolveExtensionInstallSpecs(packageSpecs, cwd = process.cwd()) {
+    const repoRoot = findDobbyRepoRoot(cwd);
+    if (!repoRoot) {
+        return packageSpecs;
+    }
+    const repoPackages = await listRepoLocalExtensionPackages(repoRoot);
+    const resolvedSpecs = [];
+    for (const rawSpec of packageSpecs) {
+        const packageSpec = rawSpec.trim();
+        if (packageSpec.length === 0 || isExplicitInstallSpec(packageSpec)) {
+            resolvedSpecs.push(packageSpec);
+            continue;
+        }
+        const localPackage = repoPackages.get(packageSpec);
+        if (!localPackage) {
+            resolvedSpecs.push(packageSpec);
+            continue;
+        }
+        await assertLocalExtensionBuildReady(localPackage);
+        resolvedSpecs.push(`file:${localPackage.packageDir}`);
+    }
+    return resolvedSpecs;
+}

package/dist/src/cli/shared/schema-prompts.js

@@ -1,4 +1,4 @@
-import { cancel, confirm, isCancel, multiselect, note, select, text, } from "@clack/prompts";
+import { cancel, confirm, isCancel, multiselect, note, password, select, text, } from "@clack/prompts";
 import JSON5 from "json5";
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -61,11 +61,14 @@ function shouldPromptInMinimalMode(field) {
     if (!field.hasDefault && field.required) {
         return true;
     }
-    if (!field.hasDefault && field.existingValue === undefined) {
+    if (field.existingValue !== undefined) {
         return true;
     }
     return false;
 }
+function isSensitiveStringField(key) {
+    return /(token|secret|api[-_]?key)$/i.test(key);
+}
 async function promptNumberField(params) {
     while (true) {
         const result = await text({
@@ -232,6 +235,27 @@ async function promptFieldValue(params) {
             existingValue,
         });
     }
+    if (isSensitiveStringField(key)) {
+        while (true) {
+            const result = await password({
+                message,
+                mask: "*",
+            });
+            if (isCancel(result)) {
+                cancel("Configuration cancelled.");
+                throw new Error("Configuration cancelled.");
+            }
+            const raw = String(result ?? "").trim();
+            if (raw.length === 0) {
+                if (required && existingValue === undefined) {
+                    await note("This field is required.", "Validation");
+                    continue;
+                }
+                return existingValue;
+            }
+            return raw;
+        }
+    }
     while (true) {
         const result = await text({
             message,

package/dist/src/core/gateway.js

@@ -129,7 +129,9 @@ export class Gateway {
                 route,
             };
         }
-        const binding = this.options.bindingResolver.resolve(message.connectorId, message.source);
+        const binding = this.options.bindingResolver.resolve(message.connectorId, message.source, {
+            isDirectMessage: message.isDirectMessage,
+        });
         if (!binding) {
             if (handling.origin === "connector") {
                 this.options.logger.debug({

package/dist/src/core/routing.js

@@ -1,20 +1,21 @@
-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 { isDobbyRepoRoot } from "../shared/dobby-repo.js";
 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({
+const routeDefaultSchema = z.object({
+    projectRoot: z.string().trim().min(1).optional(),
     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),
+    projectRoot: z.string().trim().min(1).optional(),
     tools: z.enum(["full", "readonly"]).optional(),
     mentions: z.enum(["required", "optional"]).optional(),
     provider: z.string().trim().min(1).optional(),
@@ -33,6 +34,9 @@ const bindingItemSchema = z.object({
     source: bindingSourceSchema,
     route: z.string().trim().min(1),
 }).strict();
+const defaultBindingSchema = z.object({
+    route: z.string().trim().min(1),
+}).strict();
 const gatewayConfigSchema = z.object({
     extensions: z.object({
         allowList: z
@@ -54,10 +58,11 @@ const gatewayConfigSchema = z.object({
         items: z.record(z.string(), extensionItemSchema).default({}),
     }).strict(),
     routes: z.object({
-        defaults: routeDefaultsSchema.default({}),
+        default: routeDefaultSchema.default({}),
         items: z.record(z.string(), routeItemSchema),
     }).strict(),
     bindings: z.object({
+        default: defaultBindingSchema.optional(),
         items: z.record(z.string(), bindingItemSchema).default({}),
     }).strict(),
     data: z.object({
@@ -70,22 +75,6 @@ const FORBIDDEN_CONNECTOR_CONFIG_KEYS = {
     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);
@@ -147,9 +136,13 @@ function normalizeSandboxes(parsed) {
         items: normalizeInstances(parsed.items),
     };
 }
-function normalizeRouteProfile(baseDir, profile, defaults) {
+function normalizeRouteProfile(routeId, baseDir, profile, defaults) {
+    const resolvedProjectRoot = profile.projectRoot ?? defaults.projectRoot;
+    if (!resolvedProjectRoot) {
+        throw new Error(`routes.items['${routeId}'].projectRoot is required when routes.default.projectRoot is not set`);
+    }
     const normalized = {
-        projectRoot: resolveMaybeAbsolute(baseDir, profile.projectRoot),
+        projectRoot: resolveMaybeAbsolute(baseDir, resolvedProjectRoot),
         tools: profile.tools ?? defaults.tools,
         mentions: profile.mentions ?? defaults.mentions,
         provider: profile.provider ?? defaults.provider,
@@ -163,10 +156,10 @@ function normalizeRouteProfile(baseDir, profile, defaults) {
 function normalizeRoutes(parsed, baseDir, defaults) {
     const items = {};
     for (const [routeId, profile] of Object.entries(parsed.items)) {
-        items[routeId] = normalizeRouteProfile(baseDir, profile, defaults);
+        items[routeId] = normalizeRouteProfile(routeId, baseDir, profile, defaults);
     }
     return {
-        defaults,
+        default: defaults,
         items,
     };
 }
@@ -182,7 +175,10 @@ function normalizeBindings(parsed) {
             route: binding.route,
         };
     }
-    return { items };
+    return {
+        ...(parsed.default ? { default: { route: parsed.default.route } } : {}),
+        items,
+    };
 }
 function validateConnectorConfigKeys(parsed) {
     for (const [instanceId, item] of Object.entries(parsed.items)) {
@@ -202,16 +198,16 @@ function validateReferences(parsed, normalizedRoutes) {
         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",
+        provider: parsed.routes.default.provider ?? parsed.providers.default,
+        sandbox: parsed.routes.default.sandbox ?? parsed.sandboxes.default ?? BUILTIN_HOST_SANDBOX_ID,
+        tools: parsed.routes.default.tools ?? "full",
+        mentions: parsed.routes.default.mentions ?? "required",
     };
     if (!parsed.providers.items[resolvedDefaults.provider]) {
-        throw new Error(`routes.defaults.provider references unknown provider '${resolvedDefaults.provider}'`);
+        throw new Error(`routes.default.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}'`);
+        throw new Error(`routes.default.sandbox references unknown sandbox '${resolvedDefaults.sandbox}'`);
     }
     for (const [routeId, profile] of Object.entries(normalizedRoutes.items)) {
         if (!parsed.providers.items[profile.provider]) {
@@ -236,6 +232,9 @@ function validateReferences(parsed, normalizedRoutes) {
         }
         seenSources.set(bindingKey, bindingId);
     }
+    if (parsed.bindings.default && !normalizedRoutes.items[parsed.bindings.default.route]) {
+        throw new Error(`bindings.default.route references unknown route '${parsed.bindings.default.route}'`);
+    }
 }
 export async function loadGatewayConfig(configPath) {
     const absoluteConfigPath = resolve(configPath);
@@ -244,10 +243,11 @@ export async function loadGatewayConfig(configPath) {
     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",
+        ...(parsed.routes.default.projectRoot ? { projectRoot: resolveMaybeAbsolute(configBaseDir, parsed.routes.default.projectRoot) } : {}),
+        provider: parsed.routes.default.provider ?? parsed.providers.default,
+        sandbox: parsed.routes.default.sandbox ?? parsed.sandboxes.default ?? BUILTIN_HOST_SANDBOX_ID,
+        tools: parsed.routes.default.tools ?? "full",
+        mentions: parsed.routes.default.mentions ?? "required",
     };
     const normalizedRoutes = normalizeRoutes(parsed.routes, configBaseDir, routeDefaults);
     validateReferences(parsed, normalizedRoutes);
@@ -286,6 +286,7 @@ export class RouteResolver {
 }
 export class BindingResolver {
     bindingsBySource = new Map();
+    defaultBinding;
     constructor(bindings) {
         for (const [bindingId, binding] of Object.entries(bindings.items)) {
             this.bindingsBySource.set(this.buildKey(binding.connector, binding.source), {
@@ -293,12 +294,26 @@ export class BindingResolver {
                 config: binding,
             });
         }
+        this.defaultBinding = bindings.default
+            ? {
+                bindingId: "__default__",
+                config: {
+                    connector: "__default__",
+                    source: {
+                        type: "chat",
+                        id: "__direct_message__",
+                    },
+                    route: bindings.default.route,
+                },
+            }
+            : null;
     }
-    resolve(connectorId, source) {
+    resolve(connectorId, source, options) {
         if (!connectorId.trim() || !source.id.trim()) {
-            return null;
+            return options?.isDirectMessage ? this.defaultBinding : null;
         }
-        return this.bindingsBySource.get(this.buildKey(connectorId, source)) ?? null;
+        return this.bindingsBySource.get(this.buildKey(connectorId, source))
+            ?? (options?.isDirectMessage ? this.defaultBinding : null);
     }
     buildKey(connectorId, source) {
         return `${connectorId.trim()}:${source.type}:${source.id.trim()}`;

package/dist/src/core/types.js

@@ -1 +1,3 @@
 export const BUILTIN_HOST_SANDBOX_ID = "host.builtin";
+export const OUTBOUND_MESSAGE_KIND_METADATA_KEY = "dobby_message_kind";
+export const OUTBOUND_MESSAGE_KIND_PROGRESS = "progress";

package/dist/src/cron/config.js

@@ -7,7 +7,7 @@ const rawCronConfigSchema = z.object({
     storeFile: z.string().min(1).optional(),
     runLogFile: z.string().min(1).optional(),
     pollIntervalMs: z.number().int().positive().default(10_000),
-    maxConcurrentRuns: z.number().int().positive().default(1),
+    maxConcurrentRuns: z.number().int().positive().default(2),
     runMissedOnStartup: z.boolean().default(true),
     jobTimeoutMs: z.number().int().positive().default(10 * 60 * 1000),
 });
@@ -45,7 +45,7 @@ function defaultCronConfigPayload() {
         storeFile: "./data/state/cron-jobs.json",
         runLogFile: "./data/state/cron-runs.jsonl",
         pollIntervalMs: 10_000,
-        maxConcurrentRuns: 1,
+        maxConcurrentRuns: 2,
         runMissedOnStartup: true,
         jobTimeoutMs: 10 * 60 * 1000,
     };