@dobby.ai/dobby 0.1.0

package/dist/src/cli/commands/config.js

@@ -0,0 +1,243 @@
+import { cancel, intro, isCancel, multiselect, note, outro, } from "@clack/prompts";
+import { ensureGatewayConfigShape } from "../shared/config-mutators.js";
+import { requireRawConfig, resolveConfigPath, writeConfigWithValidation } from "../shared/config-io.js";
+import { applyConfigureSection, isConfigureSection, normalizeConfigureSectionOrder, } from "../shared/configure-sections.js";
+import { applyAndValidateContributionSchemas, getContributionSchema, loadContributionSchemaCatalog, listContributionSchemas, } from "../shared/config-schema.js";
+export const CONFIG_SECTION_VALUES = ["providers", "connectors", "routes", "bindings", "sandboxes", "data", "extensions"];
+const EDITABLE_CONFIG_SECTIONS = ["provider", "connector", "route", "binding"];
+/**
+ * Validates section identifiers accepted by `config show|list`.
+ */
+export function isConfigSection(value) {
+    return CONFIG_SECTION_VALUES.includes(value);
+}
+/**
+ * Returns a stable scalar/object/array type label for list output.
+ */
+function describeValueType(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    return typeof value;
+}
+/**
+ * Guards plain object-like values for preview/list summary generation.
+ */
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * Renders a compact preview string for list rows.
+ */
+export function previewConfigValue(value, maxLength = 80) {
+    let raw;
+    if (value === null) {
+        raw = "null";
+    }
+    else if (typeof value === "string") {
+        raw = JSON.stringify(value);
+    }
+    else if (typeof value === "number" || typeof value === "boolean") {
+        raw = String(value);
+    }
+    else if (Array.isArray(value)) {
+        const head = value.slice(0, 3).map((item) => previewConfigValue(item, 24)).join(", ");
+        raw = `[${head}${value.length > 3 ? ", ..." : ""}]`;
+    }
+    else if (isRecord(value)) {
+        const keys = Object.keys(value);
+        const head = keys.slice(0, 3).join(", ");
+        raw = `{${head}${keys.length > 3 ? ", ..." : ""}}`;
+    }
+    else {
+        raw = String(value);
+    }
+    return raw.length > maxLength ? `${raw.slice(0, maxLength - 3)}...` : raw;
+}
+/**
+ * Summarizes one object value into list-friendly rows.
+ */
+export function buildConfigListEntries(value) {
+    if (!isRecord(value)) {
+        return [
+            {
+                key: "(value)",
+                type: describeValueType(value),
+                preview: previewConfigValue(value),
+            },
+        ];
+    }
+    return Object.entries(value)
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([key, item]) => ({
+        key,
+        type: describeValueType(item),
+        ...(isRecord(item) ? { children: Object.keys(item).length } : {}),
+        ...(Array.isArray(item) ? { children: item.length } : {}),
+        preview: previewConfigValue(item),
+    }));
+}
+/**
+ * Picks and validates a top-level config section.
+ */
+function resolveConfigSection(section) {
+    if (!section) {
+        return undefined;
+    }
+    if (!isConfigSection(section)) {
+        throw new Error(`Unknown section '${section}'. Allowed: ${CONFIG_SECTION_VALUES.join(", ")}`);
+    }
+    return section;
+}
+/**
+ * Pretty prints list rows for human-readable CLI output.
+ */
+function printListEntries(entries) {
+    if (entries.length === 0) {
+        console.log("(empty)");
+        return;
+    }
+    for (const entry of entries) {
+        const children = entry.children !== undefined ? `, children=${entry.children}` : "";
+        console.log(`${entry.key}: type=${entry.type}${children}, preview=${entry.preview}`);
+    }
+}
+/**
+ * Loads current config and normalizes missing sections to make read output stable.
+ */
+async function loadNormalizedConfig() {
+    const configPath = resolveConfigPath();
+    const rawConfig = await requireRawConfig(configPath);
+    return ensureGatewayConfigShape(structuredClone(rawConfig));
+}
+/**
+ * Prints full config or one top-level section.
+ */
+export async function runConfigShowCommand(options) {
+    const normalized = await loadNormalizedConfig();
+    const section = resolveConfigSection(options.section);
+    const value = section ? normalized[section] : normalized;
+    if (options.json) {
+        console.log(JSON.stringify(value ?? null));
+        return;
+    }
+    console.log(JSON.stringify(value ?? null, null, 2));
+}
+/**
+ * Prints a typed summary for top-level config sections or one section's children.
+ */
+export async function runConfigListCommand(options) {
+    const normalized = await loadNormalizedConfig();
+    const section = resolveConfigSection(options.section);
+    const entries = section
+        ? buildConfigListEntries(normalized[section])
+        : CONFIG_SECTION_VALUES.map((key) => ({
+            key,
+            type: describeValueType(normalized[key]),
+            ...(isRecord(normalized[key]) ? { children: Object.keys(normalized[key]).length } : {}),
+            ...(Array.isArray(normalized[key]) ? { children: normalized[key].length } : {}),
+            preview: previewConfigValue(normalized[key]),
+        }));
+    if (options.json) {
+        console.log(JSON.stringify(entries));
+        return;
+    }
+    printListEntries(entries);
+}
+/**
+ * Lists loaded contribution schema availability for installed/allow-listed extensions.
+ */
+export async function runConfigSchemaListCommand(options) {
+    const configPath = resolveConfigPath();
+    const rawConfig = await requireRawConfig(configPath);
+    const entries = await listContributionSchemas(configPath, rawConfig);
+    if (options.json) {
+        console.log(JSON.stringify(entries));
+        return;
+    }
+    if (entries.length === 0) {
+        console.log("(empty)");
+        return;
+    }
+    for (const entry of entries) {
+        console.log(`${entry.contributionId}: kind=${entry.kind}, package=${entry.packageName}, hasSchema=${entry.hasSchema ? "yes" : "no"}`);
+    }
+}
+/**
+ * Prints one contribution JSON Schema by contributionId.
+ */
+export async function runConfigSchemaShowCommand(options) {
+    const configPath = resolveConfigPath();
+    const rawConfig = await requireRawConfig(configPath);
+    const entry = await getContributionSchema(configPath, rawConfig, options.contributionId);
+    if (!entry) {
+        throw new Error(`Unknown contributionId '${options.contributionId}'. Run 'dobby config schema list' first.`);
+    }
+    if (!entry.configSchema) {
+        throw new Error(`Contribution '${options.contributionId}' does not expose configSchema.`);
+    }
+    if (options.json) {
+        console.log(JSON.stringify(entry.configSchema));
+        return;
+    }
+    console.log(JSON.stringify(entry.configSchema, null, 2));
+}
+/**
+ * Resolves interactive `config edit` target sections from flags or prompt.
+ */
+async function resolveEditSections(sections) {
+    if (sections.length > 0) {
+        const normalized = [];
+        for (const section of sections) {
+            if (!isConfigureSection(section) || !EDITABLE_CONFIG_SECTIONS.includes(section)) {
+                throw new Error(`Unknown --section '${section}'. Allowed: ${EDITABLE_CONFIG_SECTIONS.join(", ")}`);
+            }
+            normalized.push(section);
+        }
+        return normalized;
+    }
+    const picked = await multiselect({
+        message: "Select sections to edit",
+        options: EDITABLE_CONFIG_SECTIONS.map((section) => ({ value: section, label: section })),
+        initialValues: ["provider", "connector", "route", "binding"],
+        required: true,
+    });
+    if (isCancel(picked)) {
+        cancel("Config edit cancelled.");
+        throw new Error("Config edit cancelled.");
+    }
+    return picked;
+}
+/**
+ * Runs interactive high-frequency config editing with one validated atomic write.
+ */
+export async function runConfigEditCommand(options) {
+    const configPath = resolveConfigPath();
+    const rawConfig = await requireRawConfig(configPath);
+    const next = ensureGatewayConfigShape(structuredClone(rawConfig));
+    intro("dobby config edit");
+    const requestedSections = await resolveEditSections(options.sections);
+    const sections = normalizeConfigureSectionOrder(requestedSections);
+    if (sections.join(",") !== requestedSections.join(",")) {
+        await note(`Execution order: ${sections.join(" -> ")}`, "Info");
+    }
+    const catalog = await loadContributionSchemaCatalog(configPath, next);
+    const schemaByContributionId = new Map(catalog
+        .filter((item) => item.configSchema)
+        .map((item) => [item.contributionId, item.configSchema]));
+    const schemaStateByContributionId = new Map(catalog.map((item) => [item.contributionId, item.configSchema ? "with_schema" : "without_schema"]));
+    for (const section of sections) {
+        await applyConfigureSection(section, next, { schemaByContributionId, schemaStateByContributionId });
+        await note(`Section '${section}' prepared`, "Updated");
+    }
+    const validatedConfig = await applyAndValidateContributionSchemas(configPath, next);
+    await writeConfigWithValidation(configPath, validatedConfig, {
+        validate: true,
+        createBackup: true,
+    });
+    await note(`Saved to ${configPath}`, "Saved");
+    outro("Configuration updated.");
+}

package/dist/src/cli/commands/configure.js

@@ -0,0 +1,61 @@
+import { cancel, intro, isCancel, multiselect, note, outro, } from "@clack/prompts";
+import { ensureGatewayConfigShape } from "../shared/config-mutators.js";
+import { requireRawConfig, resolveConfigPath, writeConfigWithValidation } from "../shared/config-io.js";
+import { applyConfigureSection, CONFIGURE_SECTION_VALUES, isConfigureSection, normalizeConfigureSectionOrder, } from "../shared/configure-sections.js";
+import { applyAndValidateContributionSchemas, loadContributionSchemaCatalog } from "../shared/config-schema.js";
+/**
+ * Resolves target sections from CLI flags or interactive section picker.
+ */
+async function resolveSections(sections) {
+    if (sections.length > 0) {
+        const normalized = [];
+        for (const section of sections) {
+            if (!isConfigureSection(section)) {
+                throw new Error(`Unknown --section '${section}'. Allowed: ${CONFIGURE_SECTION_VALUES.join(", ")}`);
+            }
+            normalized.push(section);
+        }
+        return normalized;
+    }
+    const picked = await multiselect({
+        message: "Select sections to configure",
+        options: CONFIGURE_SECTION_VALUES.map((section) => ({ value: section, label: section })),
+        initialValues: ["provider", "connector", "route", "binding"],
+        required: true,
+    });
+    if (isCancel(picked)) {
+        cancel("Configure cancelled.");
+        throw new Error("Configure cancelled.");
+    }
+    return picked;
+}
+/**
+ * Executes interactive config updates and validates one final atomic save.
+ */
+export async function runConfigureCommand(options) {
+    const configPath = resolveConfigPath();
+    const rawConfig = await requireRawConfig(configPath);
+    const next = ensureGatewayConfigShape(structuredClone(rawConfig));
+    intro("dobby configure");
+    const requestedSections = await resolveSections(options.sections);
+    const sections = normalizeConfigureSectionOrder(requestedSections);
+    if (sections.join(",") !== requestedSections.join(",")) {
+        await note(`Execution order: ${sections.join(" -> ")}`, "Info");
+    }
+    const catalog = await loadContributionSchemaCatalog(configPath, next);
+    const schemaByContributionId = new Map(catalog
+        .filter((item) => item.configSchema)
+        .map((item) => [item.contributionId, item.configSchema]));
+    const schemaStateByContributionId = new Map(catalog.map((item) => [item.contributionId, item.configSchema ? "with_schema" : "without_schema"]));
+    for (const section of sections) {
+        await applyConfigureSection(section, next, { schemaByContributionId, schemaStateByContributionId });
+        await note(`Section '${section}' prepared`, "Updated");
+    }
+    const validatedConfig = await applyAndValidateContributionSchemas(configPath, next);
+    await writeConfigWithValidation(configPath, validatedConfig, {
+        validate: true,
+        createBackup: true,
+    });
+    await note(`Saved to ${configPath}`, "Saved");
+    outro("Configuration updated.");
+}

package/dist/src/cli/commands/cron.js

@@ -0,0 +1,288 @@
+import { loadGatewayConfig } from "../../core/routing.js";
+import { loadCronConfig } from "../../cron/config.js";
+import { computeInitialNextRunAtMs, describeSchedule } from "../../cron/schedule.js";
+import { CronStore } from "../../cron/store.js";
+import { resolveConfigPath } from "../shared/config-io.js";
+import { createLogger } from "../shared/runtime.js";
+function slugify(value) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replaceAll(/[^a-z0-9]+/g, "-")
+        .replaceAll(/^-+|-+$/g, "");
+    return normalized.length > 0 ? normalized : "job";
+}
+function parseSchedule(input) {
+    const variants = [input.at ? "at" : null, input.everyMs !== undefined ? "every" : null, input.cronExpr ? "cron" : null]
+        .filter((item) => item !== null);
+    if (variants.length !== 1) {
+        throw new Error("Exactly one schedule option is required: --at | --every-ms | --cron");
+    }
+    if (input.at) {
+        return { kind: "at", at: input.at };
+    }
+    if (input.everyMs !== undefined) {
+        if (!Number.isFinite(input.everyMs) || input.everyMs <= 0) {
+            throw new Error("--every-ms must be a positive integer");
+        }
+        return { kind: "every", everyMs: Math.floor(input.everyMs) };
+    }
+    if (!input.cronExpr) {
+        throw new Error("Missing --cron expression");
+    }
+    return {
+        kind: "cron",
+        expr: input.cronExpr,
+        ...(input.tz ? { tz: input.tz } : {}),
+    };
+}
+function parseSessionPolicy(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "stateless" || value === "shared-session") {
+        return value;
+    }
+    throw new Error(`Invalid session policy '${value}'. Expected 'stateless' or 'shared-session'.`);
+}
+function assertDeliveryReferences(config, input) {
+    if (!config.connectors.items[input.connectorId]) {
+        throw new Error(`Unknown connectorId '${input.connectorId}'`);
+    }
+    if (!config.routes.items[input.routeId]) {
+        throw new Error(`Unknown routeId '${input.routeId}'`);
+    }
+}
+async function loadCronContext(options) {
+    const configPath = resolveConfigPath();
+    const gatewayConfig = await loadGatewayConfig(configPath);
+    const loadedCronConfig = await loadCronConfig({
+        gatewayConfigPath: configPath,
+        gatewayConfig,
+        ...(options?.cronConfigPath ? { explicitCronConfigPath: options.cronConfigPath } : {}),
+    });
+    const logger = createLogger();
+    const store = new CronStore(loadedCronConfig.config.storeFile, loadedCronConfig.config.runLogFile, logger);
+    await store.load();
+    return {
+        configPath,
+        gatewayConfig,
+        cronConfigPath: loadedCronConfig.configPath,
+        store,
+    };
+}
+export async function runCronAddCommand(options) {
+    const context = await loadCronContext(options.cronConfigPath ? { cronConfigPath: options.cronConfigPath } : undefined);
+    assertDeliveryReferences(context.gatewayConfig, {
+        connectorId: options.connectorId,
+        routeId: options.routeId,
+    });
+    const schedule = parseSchedule({
+        ...(options.at ? { at: options.at } : {}),
+        ...(options.everyMs !== undefined ? { everyMs: options.everyMs } : {}),
+        ...(options.cronExpr ? { cronExpr: options.cronExpr } : {}),
+        ...(options.tz ? { tz: options.tz } : {}),
+    });
+    const now = Date.now();
+    const nextRunAtMs = computeInitialNextRunAtMs(schedule, now);
+    const id = `${slugify(options.name)}-${Math.random().toString(36).slice(2, 8)}`;
+    const sessionPolicy = parseSessionPolicy(options.sessionPolicy) ?? "stateless";
+    const job = {
+        id,
+        name: options.name,
+        enabled: true,
+        schedule,
+        sessionPolicy,
+        prompt: options.prompt,
+        delivery: {
+            connectorId: options.connectorId,
+            routeId: options.routeId,
+            channelId: options.channelId,
+            ...(options.threadId ? { threadId: options.threadId } : {}),
+        },
+        createdAtMs: now,
+        updatedAtMs: now,
+        state: {
+            ...(nextRunAtMs !== undefined ? { nextRunAtMs } : {}),
+            consecutiveErrors: 0,
+        },
+    };
+    await context.store.upsertJob(job);
+    console.log(`Added cron job ${job.id}`);
+    console.log(`- schedule: ${describeSchedule(job.schedule)}`);
+    console.log(`- delivery: ${job.delivery.connectorId}/${job.delivery.routeId}/${job.delivery.channelId}`);
+    console.log(`- cron config: ${context.cronConfigPath}`);
+}
+export async function runCronListCommand(options) {
+    const context = await loadCronContext(options.cronConfigPath ? { cronConfigPath: options.cronConfigPath } : undefined);
+    const jobs = context.store.listJobs();
+    if (options.json) {
+        console.log(JSON.stringify({ jobs, cronConfigPath: context.cronConfigPath }, null, 2));
+        return;
+    }
+    if (jobs.length === 0) {
+        console.log(`No cron jobs configured (${context.cronConfigPath})`);
+        return;
+    }
+    console.log(`Cron jobs (${context.cronConfigPath}):`);
+    for (const job of jobs) {
+        const next = job.state.nextRunAtMs ? new Date(job.state.nextRunAtMs).toISOString() : "-";
+        const last = job.state.lastRunAtMs ? new Date(job.state.lastRunAtMs).toISOString() : "-";
+        const schedule = describeSchedule(job.schedule);
+        console.log(`- ${job.id} [${job.enabled ? "enabled" : "paused"}] ${job.name}`);
+        console.log(`  schedule=${schedule}`);
+        console.log(`  next=${next} last=${last} status=${job.state.lastStatus ?? "-"}`);
+        console.log(`  delivery=${job.delivery.connectorId}/${job.delivery.routeId}/${job.delivery.channelId}`);
+    }
+}
+export async function runCronStatusCommand(options) {
+    const context = await loadCronContext(options.cronConfigPath ? { cronConfigPath: options.cronConfigPath } : undefined);
+    const target = options.jobId ? context.store.getJob(options.jobId) : null;
+    if (options.jobId && !target) {
+        throw new Error(`Cron job '${options.jobId}' does not exist`);
+    }
+    if (options.json) {
+        if (target) {
+            console.log(JSON.stringify(target, null, 2));
+            return;
+        }
+        console.log(JSON.stringify(context.store.listJobs(), null, 2));
+        return;
+    }
+    if (target) {
+        console.log(`Cron status for ${target.id}`);
+        console.log(`- name: ${target.name}`);
+        console.log(`- enabled: ${target.enabled}`);
+        console.log(`- schedule: ${describeSchedule(target.schedule)}`);
+        console.log(`- sessionPolicy: ${target.sessionPolicy ?? "stateless"}`);
+        console.log(`- nextRun: ${target.state.nextRunAtMs ? new Date(target.state.nextRunAtMs).toISOString() : "-"}`);
+        console.log(`- lastRun: ${target.state.lastRunAtMs ? new Date(target.state.lastRunAtMs).toISOString() : "-"}`);
+        console.log(`- lastStatus: ${target.state.lastStatus ?? "-"}`);
+        if (target.state.lastError) {
+            console.log(`- lastError: ${target.state.lastError}`);
+        }
+        return;
+    }
+    await runCronListCommand({
+        ...(options.cronConfigPath ? { cronConfigPath: options.cronConfigPath } : {}),
+        json: false,
+    });
+}
+export async function runCronRunCommand(options) {
+    const context = await loadCronContext(options.cronConfigPath ? { cronConfigPath: options.cronConfigPath } : undefined);
+    const now = Date.now();
+    await context.store.updateJob(options.jobId, (current) => ({
+        ...current,
+        enabled: true,
+        updatedAtMs: now,
+        state: {
+            ...current.state,
+            nextRunAtMs: now,
+        },
+    }));
+    console.log(`Scheduled cron job ${options.jobId} to run on next scheduler tick.`);
+    console.log("Ensure the gateway process is running for execution.");
+}
+export async function runCronUpdateCommand(options) {
+    const context = await loadCronContext(options.cronConfigPath ? { cronConfigPath: options.cronConfigPath } : undefined);
+    const now = Date.now();
+    const hasScheduleUpdate = options.at !== undefined || options.everyMs !== undefined || options.cronExpr !== undefined;
+    const nextSchedule = hasScheduleUpdate
+        ? parseSchedule({
+            ...(options.at ? { at: options.at } : {}),
+            ...(options.everyMs !== undefined ? { everyMs: options.everyMs } : {}),
+            ...(options.cronExpr ? { cronExpr: options.cronExpr } : {}),
+            ...(options.tz ? { tz: options.tz } : {}),
+        })
+        : null;
+    await context.store.updateJob(options.jobId, (current) => {
+        const updatedDelivery = {
+            connectorId: options.connectorId ?? current.delivery.connectorId,
+            routeId: options.routeId ?? current.delivery.routeId,
+            channelId: options.channelId ?? current.delivery.channelId,
+        };
+        const resolvedThreadId = options.clearThread ? undefined : (options.threadId ?? current.delivery.threadId);
+        if (resolvedThreadId !== undefined) {
+            updatedDelivery.threadId = resolvedThreadId;
+        }
+        assertDeliveryReferences(context.gatewayConfig, {
+            connectorId: updatedDelivery.connectorId,
+            routeId: updatedDelivery.routeId,
+        });
+        const schedule = nextSchedule ?? current.schedule;
+        const nextRunAtMs = nextSchedule
+            ? computeInitialNextRunAtMs(schedule, now)
+            : current.state.nextRunAtMs;
+        const nextState = {
+            ...current.state,
+        };
+        if (nextSchedule) {
+            if (nextRunAtMs === undefined) {
+                delete nextState.nextRunAtMs;
+            }
+            else {
+                nextState.nextRunAtMs = nextRunAtMs;
+            }
+        }
+        const parsedSessionPolicy = parseSessionPolicy(options.sessionPolicy);
+        const nextJob = {
+            ...current,
+            name: options.name ?? current.name,
+            prompt: options.prompt ?? current.prompt,
+            schedule,
+            delivery: updatedDelivery,
+            updatedAtMs: now,
+            state: nextState,
+        };
+        const nextSessionPolicy = parsedSessionPolicy ?? current.sessionPolicy;
+        if (nextSessionPolicy !== undefined) {
+            nextJob.sessionPolicy = nextSessionPolicy;
+        }
+        else {
+            delete nextJob.sessionPolicy;
+        }
+        return nextJob;
+    });
+    console.log(`Updated cron job ${options.jobId}`);
+}
+export async function runCronRemoveCommand(options) {
+    const context = await loadCronContext(options.cronConfigPath ? { cronConfigPath: options.cronConfigPath } : undefined);
+    const removed = await context.store.removeJob(options.jobId);
+    if (!removed) {
+        throw new Error(`Cron job '${options.jobId}' does not exist`);
+    }
+    console.log(`Removed cron job ${options.jobId}`);
+}
+export async function runCronPauseCommand(options) {
+    const context = await loadCronContext(options.cronConfigPath ? { cronConfigPath: options.cronConfigPath } : undefined);
+    const now = Date.now();
+    await context.store.updateJob(options.jobId, (current) => ({
+        ...current,
+        enabled: false,
+        updatedAtMs: now,
+    }));
+    console.log(`Paused cron job ${options.jobId}`);
+}
+export async function runCronResumeCommand(options) {
+    const context = await loadCronContext(options.cronConfigPath ? { cronConfigPath: options.cronConfigPath } : undefined);
+    const now = Date.now();
+    await context.store.updateJob(options.jobId, (current) => {
+        const nextState = {
+            ...current.state,
+        };
+        const nextRunAtMs = computeInitialNextRunAtMs(current.schedule, now);
+        if (nextRunAtMs === undefined) {
+            delete nextState.nextRunAtMs;
+        }
+        else {
+            nextState.nextRunAtMs = nextRunAtMs;
+        }
+        return {
+            ...current,
+            enabled: true,
+            updatedAtMs: now,
+            state: nextState,
+        };
+    });
+    console.log(`Resumed cron job ${options.jobId}`);
+}