@otto-code/protocol 0.5.0

package/dist/provider-config.js

@@ -0,0 +1,238 @@
+import { z } from "zod";
+import { AgentProviderSchema } from "./provider-manifest.js";
+const ProviderCommandDefaultSchema = z.object({
+    mode: z.literal("default"),
+});
+const ProviderCommandAppendSchema = z.object({
+    mode: z.literal("append"),
+    args: z.array(z.string()).optional(),
+});
+const ProviderCommandReplaceSchema = z.object({
+    mode: z.literal("replace"),
+    argv: z.array(z.string().min(1)).min(1),
+});
+export const ProviderCommandSchema = z.discriminatedUnion("mode", [
+    ProviderCommandDefaultSchema,
+    ProviderCommandAppendSchema,
+    ProviderCommandReplaceSchema,
+]);
+export const ProviderRuntimeSettingsSchema = z.object({
+    command: ProviderCommandSchema.optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    disallowedTools: z.array(z.string()).optional(),
+});
+const ProviderProfileThinkingOptionSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    description: z.string().optional(),
+    isDefault: z.boolean().optional(),
+});
+export const ProviderProfileModelSchema = z.object({
+    id: z.string().min(1),
+    label: z.string().min(1),
+    description: z.string().optional(),
+    isDefault: z.boolean().optional(),
+    thinkingOptions: z.array(ProviderProfileThinkingOptionSchema).optional(),
+});
+/**
+ * Coarse categories for Otto's agent-facing tool catalog. Providers that receive
+ * Otto tools natively (see the openai-compat provider) can be scoped to a subset
+ * of these groups; omitting the selection means all groups. Kept deliberately
+ * coarse — users pick groups, not individual tools.
+ */
+export const OTTO_TOOL_GROUPS = [
+    "preview",
+    "browser",
+    "web",
+    "agents",
+    "terminals",
+    "schedules",
+    "artifacts",
+    "workspace",
+];
+/**
+ * Map a tool name to its group. Covers both Otto's catalog tools and the
+ * openai-compat builtin web tools (web_search/web_fetch → "web"). Unknown/
+ * lifecycle tools fall under "agents".
+ */
+export function ottoToolGroupForName(name) {
+    if (name.startsWith("preview_"))
+        return "preview";
+    if (name.startsWith("browser_"))
+        return "browser";
+    if (name === "web_search" || name === "web_fetch")
+        return "web";
+    if (name.includes("terminal"))
+        return "terminals";
+    if (name.includes("schedule") || name === "create_heartbeat")
+        return "schedules";
+    if (name.includes("artifact"))
+        return "artifacts";
+    if (name.includes("worktree") || name.includes("workspace"))
+        return "workspace";
+    return "agents";
+}
+const McpStdioServerConfigSchema = z.object({
+    type: z.literal("stdio"),
+    command: z.string(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    alwaysLoad: z.boolean().optional(),
+});
+const McpHttpServerConfigSchema = z.object({
+    type: z.literal("http"),
+    url: z.string(),
+    headers: z.record(z.string(), z.string()).optional(),
+    alwaysLoad: z.boolean().optional(),
+});
+const McpSseServerConfigSchema = z.object({
+    type: z.literal("sse"),
+    url: z.string(),
+    headers: z.record(z.string(), z.string()).optional(),
+    alwaysLoad: z.boolean().optional(),
+});
+/**
+ * Canonical MCP server config. Shared by AgentSessionConfig (per-agent servers
+ * sent at create time) and ProviderOverride (provider-level servers in the
+ * daemon config). stdio entries execute arbitrary commands as the daemon user —
+ * both sources sit behind existing trust boundaries (daemon-side config file,
+ * authenticated agent-create RPC).
+ */
+export const McpServerConfigSchema = z.discriminatedUnion("type", [
+    McpStdioServerConfigSchema,
+    McpHttpServerConfigSchema,
+    McpSseServerConfigSchema,
+]);
+/**
+ * How natively-hosted providers (openai-compat) gate MCP tool calls in
+ * acceptEdits mode. "always-ask" (the default) prompts for every MCP tool;
+ * "trust-read-only" auto-approves tools whose MCP readOnlyHint annotation is
+ * true. In default mode every MCP tool prompts regardless; plan mode never
+ * exposes MCP tools; bypassPermissions auto-approves everything.
+ */
+export const MCP_TOOL_PERMISSION_MODES = ["always-ask", "trust-read-only"];
+/**
+ * Auto-compaction thresholds selectable for daemon-hosted compaction
+ * (openai-compat): percentage of the model's context window at which the
+ * conversation is compacted automatically.
+ */
+export const COMPACTION_THRESHOLD_PERCENTS = [50, 60, 70, 80, 90];
+/**
+ * Compaction tuning for providers whose conversation the daemon owns
+ * (openai-compat). These set the provider-level defaults; the per-agent
+ * "Auto-compact" feature select overrides them at runtime.
+ */
+export const ProviderCompactionConfigSchema = z.object({
+    /** false disables auto-compaction by default for new agents (manual /compact stays). */
+    autoCompact: z.boolean().optional(),
+    /** Context-window percentage at which auto-compaction triggers. Default 80. */
+    thresholdPercent: z
+        .union([z.literal(50), z.literal(60), z.literal(70), z.literal(80), z.literal(90)])
+        .optional(),
+    /** Recent-conversation budget kept verbatim through compaction. Default 20000. */
+    keepRecentTokens: z.number().int().positive().optional(),
+    /**
+     * true hides the per-agent "Auto-compact" feature select in chats; agents
+     * always run with the provider-level default above (persisted per-agent
+     * values are ignored while hidden).
+     */
+    hideSelector: z.boolean().optional(),
+});
+export const ProviderOverrideSchema = z.object({
+    extends: z.string().optional(),
+    label: z.string().optional(),
+    description: z.string().optional(),
+    command: z.array(z.string().min(1)).min(1).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    params: z.record(z.string(), z.unknown()).optional(),
+    models: z.array(ProviderProfileModelSchema).optional(),
+    additionalModels: z.array(ProviderProfileModelSchema).optional(),
+    disallowedTools: z.array(z.string()).optional(),
+    /**
+     * Which Otto tool groups to inject for this provider (natively-injected
+     * providers only). Omitted = all groups. Empty array = no Otto tools.
+     */
+    ottoToolGroups: z.array(z.enum(OTTO_TOOL_GROUPS)).optional(),
+    /**
+     * MCP servers for providers whose tool loop the daemon hosts (openai-compat).
+     * Merged with any per-agent AgentSessionConfig.mcpServers; the per-agent
+     * entry wins on a server-name collision.
+     */
+    mcpServers: z.record(z.string(), McpServerConfigSchema).optional(),
+    mcpToolPermissions: z.enum(MCP_TOOL_PERMISSION_MODES).optional(),
+    /**
+     * Compaction defaults for providers whose conversation the daemon owns
+     * (openai-compat). Per-agent feature values win over these.
+     */
+    compaction: ProviderCompactionConfigSchema.optional(),
+    enabled: z.boolean().optional(),
+    order: z.number().optional(),
+});
+const BUILTIN_PROVIDER_IDS = ["claude", "codex", "copilot", "opencode", "pi", "omp"];
+const PROVIDER_ID_PATTERN = /^[a-z][a-z0-9-]*$/;
+export const ProviderOverridesSchema = z
+    .record(z.string(), ProviderOverrideSchema)
+    .superRefine((providers, ctx) => {
+    const builtinProviderIdSet = new Set(BUILTIN_PROVIDER_IDS);
+    // "acp" spawns a generic ACP agent process; "openai-compatible" is served
+    // natively by the daemon against an OpenAI-compatible HTTP endpoint
+    // (LM Studio, Ollama, vLLM, ...) — no external binary involved.
+    const validExtendsValues = new Set([
+        ...BUILTIN_PROVIDER_IDS,
+        "acp",
+        "openai-compatible",
+    ]);
+    for (const [providerId, provider] of Object.entries(providers)) {
+        if (!PROVIDER_ID_PATTERN.test(providerId)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [providerId],
+                message: `Provider ID "${providerId}" must match ${PROVIDER_ID_PATTERN}.`,
+            });
+        }
+        const isBuiltinProvider = builtinProviderIdSet.has(providerId);
+        if (!isBuiltinProvider && !provider.extends) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [providerId, "extends"],
+                message: `Custom provider "${providerId}" must declare extends.`,
+            });
+        }
+        if (!isBuiltinProvider && !provider.label) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [providerId, "label"],
+                message: `Custom provider "${providerId}" must declare label.`,
+            });
+        }
+        if (provider.extends && !validExtendsValues.has(provider.extends)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [providerId, "extends"],
+                message: `Provider "${providerId}" extends unknown provider "${provider.extends}".`,
+            });
+        }
+        if (provider.extends === "acp" && !provider.command) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [providerId, "command"],
+                message: `Provider "${providerId}" extending "acp" must declare command.`,
+            });
+        }
+    }
+});
+export const AgentProviderRuntimeSettingsMapSchema = z
+    .record(z.string(), ProviderRuntimeSettingsSchema)
+    .superRefine((providers, ctx) => {
+    for (const providerId of Object.keys(providers)) {
+        const parsedProviderId = AgentProviderSchema.safeParse(providerId);
+        if (!parsedProviderId.success) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [providerId],
+                message: `Invalid agent provider "${providerId}".`,
+            });
+        }
+    }
+});
+//# sourceMappingURL=provider-config.js.map

package/dist/provider-icon-names.d.ts

@@ -0,0 +1,5 @@
+export declare const BUILTIN_PROVIDER_ICON_NAMES: string[];
+export declare const ACP_PROVIDER_ICON_NAMES: string[];
+export declare const TERMINAL_PROFILE_ICON_NAMES: string[];
+export declare const KNOWN_PROVIDER_ICON_NAMES: string[];
+//# sourceMappingURL=provider-icon-names.d.ts.map

package/dist/provider-icon-names.js

@@ -0,0 +1,52 @@
+export const BUILTIN_PROVIDER_ICON_NAMES = [
+    "claude",
+    "codex",
+    "copilot",
+    "kiro",
+    "minimax",
+    "omp",
+    "opencode",
+    "pi",
+];
+export const ACP_PROVIDER_ICON_NAMES = [
+    "agoragentic-acp",
+    "amp-acp",
+    "auggie",
+    "autohand",
+    "cline",
+    "codebuddy-code",
+    "codewhale",
+    "cortex-code",
+    "corust-agent",
+    "crow-cli",
+    "cursor",
+    "deepagents",
+    "dimcode",
+    "dirac",
+    "factory-droid",
+    "fast-agent",
+    "gemini",
+    "glm-acp-agent",
+    "goose",
+    "grok",
+    "junie",
+    "kilo",
+    "kimi",
+    "minion-code",
+    "mistral-vibe",
+    "nova",
+    "poolside",
+    "qoder",
+    "qwen-code",
+    "sigit",
+    "stakpak",
+    "traecli",
+    "vtcode",
+];
+export const TERMINAL_PROFILE_ICON_NAMES = ["agy"];
+export const KNOWN_PROVIDER_ICON_NAMES = [
+    ...BUILTIN_PROVIDER_ICON_NAMES,
+    ...ACP_PROVIDER_ICON_NAMES,
+    ...TERMINAL_PROFILE_ICON_NAMES,
+];
+//# sourceMappingURL=provider-icon-names.js.map

package/dist/provider-manifest.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import type { AgentMode } from "./agent-types.js";
+export type AgentModeColorTier = "neutral" | "safe" | "moderate" | "dangerous" | "planning" | `#${string}`;
+export type AgentModeIcon = string;
+export interface AgentModeVisuals {
+    icon: AgentModeIcon;
+    colorTier: AgentModeColorTier;
+}
+export type AgentProviderModeDefinition = Omit<AgentMode, "icon" | "colorTier"> & AgentModeVisuals & {
+    isUnattended?: boolean;
+};
+export interface AgentProviderDefinition {
+    id: string;
+    label: string;
+    description: string;
+    enabledByDefault?: boolean;
+    defaultModeId: string | null;
+    modes: AgentProviderModeDefinition[];
+    voice?: {
+        enabled: boolean;
+        defaultModeId: string;
+        defaultModel?: string;
+    };
+}
+export declare const AGENT_PROVIDER_DEFINITIONS: AgentProviderDefinition[];
+export declare const DEV_AGENT_PROVIDER_DEFINITIONS: AgentProviderDefinition[];
+export declare function getAgentProviderDefinition(provider: string, definitions?: AgentProviderDefinition[]): AgentProviderDefinition;
+export declare const BUILTIN_PROVIDER_IDS: string[];
+export declare const AGENT_PROVIDER_IDS: string[];
+export declare const AgentProviderSchema: z.ZodString;
+export declare function isValidAgentProvider(value: string, validIds?: Iterable<string>): boolean;
+export declare function getUnattendedModeId(provider: string, definitions?: AgentProviderDefinition[]): string | undefined;
+export declare function getModeVisuals(provider: string, modeId: string, definitions: AgentProviderDefinition[]): AgentModeVisuals | undefined;
+//# sourceMappingURL=provider-manifest.d.ts.map

package/dist/provider-manifest.js

@@ -0,0 +1,227 @@
+import { z } from "zod";
+const CLAUDE_MODES = [
+    {
+        id: "default",
+        label: "Always Ask",
+        description: "Prompts for permission the first time a tool is used",
+        icon: "ShieldQuestionMark",
+        colorTier: "neutral",
+    },
+    {
+        id: "acceptEdits",
+        label: "Accept File Edits",
+        description: "Automatically approves edit-focused tools without prompting",
+        icon: "ShieldPerson",
+        colorTier: "safe",
+    },
+    {
+        id: "plan",
+        label: "Plan Mode",
+        description: "Analyze the codebase without executing tools or edits",
+        icon: "ShieldToggle",
+        colorTier: "planning",
+    },
+    {
+        id: "auto",
+        label: "Auto mode",
+        description: "Uses a model classifier to review permission prompts automatically",
+        icon: "LocalPolice",
+        colorTier: "moderate",
+    },
+    {
+        id: "bypassPermissions",
+        label: "Bypass",
+        description: "Skip all permission prompts (use with caution)",
+        icon: "PrivacyTip",
+        colorTier: "dangerous",
+        isUnattended: true,
+    },
+];
+const CODEX_MODES = [
+    {
+        id: "auto",
+        label: "Default Permissions",
+        description: "Edit files and run commands with Codex's default approval flow.",
+        icon: "ShieldAlert",
+        colorTier: "moderate",
+    },
+    {
+        id: "auto-review",
+        label: "Auto-review",
+        description: "Same workspace-write permissions as Default, but eligible `on-request` approvals are routed through the auto-reviewer subagent.",
+        icon: "ShieldQuestionMark",
+        colorTier: "moderate",
+    },
+    {
+        id: "full-access",
+        label: "Full Access",
+        description: "Edit files, run commands, and access the network without additional prompts.",
+        icon: "ShieldAlert",
+        colorTier: "dangerous",
+        isUnattended: true,
+    },
+];
+const COPILOT_MODES = [
+    {
+        id: "https://agentclientprotocol.com/protocol/session-modes#agent",
+        label: "Agent",
+        description: "Default agent mode for conversational interactions",
+        icon: "ShieldAlert",
+        colorTier: "moderate",
+    },
+    {
+        id: "https://agentclientprotocol.com/protocol/session-modes#plan",
+        label: "Plan",
+        description: "Plan mode for creating and executing multi-step plans",
+        icon: "ShieldCheck",
+        colorTier: "planning",
+    },
+    {
+        id: "allow-all",
+        label: "Allow All",
+        description: "Automatically approves all Copilot tool, path, and URL requests.",
+        icon: "ShieldOff",
+        colorTier: "dangerous",
+        isUnattended: true,
+    },
+];
+const OPENCODE_MODES = [
+    {
+        id: "build",
+        label: "Build",
+        description: "Allows edits and tool execution for implementation work",
+        icon: "Bot",
+        colorTier: "moderate",
+    },
+    {
+        id: "plan",
+        label: "Plan",
+        description: "Read-only planning mode that avoids file edits",
+        icon: "Bot",
+        colorTier: "planning",
+    },
+];
+const MOCK_LOAD_TEST_MODES = [
+    {
+        id: "load-test",
+        label: "Load Test",
+        description: "Streams repeated markdown, reasoning, and tool calls for app stress testing",
+        icon: "ShieldOff",
+        colorTier: "dangerous",
+    },
+];
+const MOCK_SLOW_MODES = [
+    {
+        id: "default",
+        label: "Default",
+        description: "Dev-only mode for the mock slow provider",
+        icon: "ShieldOff",
+        colorTier: "dangerous",
+    },
+];
+export const AGENT_PROVIDER_DEFINITIONS = [
+    {
+        id: "claude",
+        label: "Claude",
+        description: "Anthropic's multi-tool assistant with MCP support, streaming, and deep reasoning",
+        defaultModeId: "default",
+        modes: CLAUDE_MODES,
+        voice: {
+            enabled: true,
+            defaultModeId: "default",
+            defaultModel: "haiku",
+        },
+    },
+    {
+        id: "codex",
+        label: "Codex",
+        description: "OpenAI's Codex workspace agent with sandbox controls and optional network access",
+        defaultModeId: "auto",
+        modes: CODEX_MODES,
+        voice: {
+            enabled: true,
+            defaultModeId: "auto",
+            defaultModel: "gpt-5.4-mini",
+        },
+    },
+    {
+        id: "copilot",
+        label: "Copilot",
+        description: "GitHub Copilot via Agent Client Protocol with dynamic modes and session support",
+        defaultModeId: "https://agentclientprotocol.com/protocol/session-modes#agent",
+        modes: COPILOT_MODES,
+    },
+    {
+        id: "opencode",
+        label: "OpenCode",
+        description: "Open-source coding assistant with multi-provider model support",
+        defaultModeId: "build",
+        modes: OPENCODE_MODES,
+        voice: {
+            enabled: true,
+            defaultModeId: "build",
+        },
+    },
+    {
+        id: "pi",
+        label: "Pi",
+        description: "Minimal terminal-based coding agent with multi-provider LLM support",
+        defaultModeId: null,
+        modes: [],
+    },
+    {
+        id: "omp",
+        label: "OMP",
+        description: "Pi-compatible coding agent distributed as Oh My Pi",
+        enabledByDefault: false,
+        defaultModeId: null,
+        modes: [],
+    },
+];
+export const DEV_AGENT_PROVIDER_DEFINITIONS = [
+    {
+        id: "mock",
+        label: "Mock Load Test",
+        description: "Development-only provider that emits synthetic agent traffic for performance tests",
+        defaultModeId: "load-test",
+        modes: MOCK_LOAD_TEST_MODES,
+    },
+    {
+        id: "mock-slow",
+        label: "Mock Slow Provider",
+        description: "Dev-only: hangs during model discovery to test loading and timeout UI",
+        defaultModeId: "default",
+        modes: MOCK_SLOW_MODES,
+    },
+];
+export function getAgentProviderDefinition(provider, definitions = [
+    ...AGENT_PROVIDER_DEFINITIONS,
+    ...DEV_AGENT_PROVIDER_DEFINITIONS,
+]) {
+    const definition = definitions.find((entry) => entry.id === provider);
+    if (!definition) {
+        throw new Error(`Unknown agent provider: ${provider}`);
+    }
+    return definition;
+}
+export const BUILTIN_PROVIDER_IDS = AGENT_PROVIDER_DEFINITIONS.map((d) => d.id);
+export const AGENT_PROVIDER_IDS = BUILTIN_PROVIDER_IDS;
+export const AgentProviderSchema = z.string();
+export function isValidAgentProvider(value, validIds = BUILTIN_PROVIDER_IDS) {
+    return Array.isArray(validIds) ? validIds.includes(value) : new Set(validIds).has(value);
+}
+export function getUnattendedModeId(provider, definitions = [
+    ...AGENT_PROVIDER_DEFINITIONS,
+    ...DEV_AGENT_PROVIDER_DEFINITIONS,
+]) {
+    const definition = definitions.find((entry) => entry.id === provider);
+    return definition?.modes.find((mode) => mode.isUnattended)?.id;
+}
+export function getModeVisuals(provider, modeId, definitions) {
+    const definition = definitions.find((entry) => entry.id === provider);
+    const mode = definition?.modes.find((m) => m.id === modeId);
+    if (!mode)
+        return undefined;
+    return { icon: mode.icon, colorTier: mode.colorTier };
+}
+//# sourceMappingURL=provider-manifest.js.map

package/dist/schedule/cron-expression.d.ts

@@ -0,0 +1,13 @@
+export interface CronFieldMatcher {
+    matches(value: number): boolean;
+}
+export interface ParsedCronExpression {
+    minute: CronFieldMatcher;
+    hour: CronFieldMatcher;
+    dayOfMonth: CronFieldMatcher;
+    month: CronFieldMatcher;
+    dayOfWeek: CronFieldMatcher;
+}
+export declare function parseCronExpression(expression: string): ParsedCronExpression;
+export declare function validateCronExpression(expression: string): string | null;
+//# sourceMappingURL=cron-expression.d.ts.map

package/dist/schedule/cron-expression.js

@@ -0,0 +1,97 @@
+const CRON_FIELD_BOUNDS = [
+    { min: 0, max: 59, name: "minute" },
+    { min: 0, max: 23, name: "hour" },
+    { min: 1, max: 31, name: "day-of-month" },
+    { min: 1, max: 12, name: "month" },
+    { min: 0, max: 6, name: "day-of-week" },
+];
+function createRange(start, end, step) {
+    const values = [];
+    for (let value = start; value <= end; value += step) {
+        values.push(value);
+    }
+    return values;
+}
+function parseStepPart(part, bounds) {
+    const stepParts = part.split("/");
+    if (stepParts.length > 2) {
+        throw new Error(`Invalid cron ${bounds.name} step`);
+    }
+    const [base, stepSource] = stepParts;
+    const normalizedStep = stepSource?.trim();
+    const step = normalizedStep === undefined ? 1 : Number.parseInt(normalizedStep, 10);
+    if (!Number.isInteger(step) ||
+        step <= 0 ||
+        (normalizedStep !== undefined && String(step) !== normalizedStep)) {
+        throw new Error(`Invalid cron ${bounds.name} step`);
+    }
+    return { base, step };
+}
+function parseField(source, bounds) {
+    const trimmed = source.trim();
+    if (!trimmed) {
+        throw new Error(`Invalid cron ${bounds.name} field`);
+    }
+    const allowed = new Set();
+    for (const rawPart of trimmed.split(",")) {
+        const part = rawPart.trim();
+        if (!part) {
+            throw new Error(`Invalid cron ${bounds.name} field`);
+        }
+        const { base, step } = parseStepPart(part, bounds);
+        if (base === "*") {
+            for (const value of createRange(bounds.min, bounds.max, step)) {
+                allowed.add(value);
+            }
+            continue;
+        }
+        const rangeMatch = base.match(/^(\d+)-(\d+)$/);
+        if (rangeMatch) {
+            const start = Number.parseInt(rangeMatch[1], 10);
+            const end = Number.parseInt(rangeMatch[2], 10);
+            if (start > end || start < bounds.min || end > bounds.max) {
+                throw new Error(`Invalid cron ${bounds.name} range`);
+            }
+            for (const value of createRange(start, end, step)) {
+                allowed.add(value);
+            }
+            continue;
+        }
+        if (!/^\d+$/.test(base)) {
+            throw new Error(`Invalid cron ${bounds.name} value`);
+        }
+        const value = Number.parseInt(base, 10);
+        if (!Number.isInteger(value) || value < bounds.min || value > bounds.max) {
+            throw new Error(`Invalid cron ${bounds.name} value`);
+        }
+        allowed.add(value);
+    }
+    return {
+        matches(value) {
+            return allowed.has(value);
+        },
+    };
+}
+export function parseCronExpression(expression) {
+    const parts = expression.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error("Cron expressions must have 5 fields");
+    }
+    return {
+        minute: parseField(parts[0], CRON_FIELD_BOUNDS[0]),
+        hour: parseField(parts[1], CRON_FIELD_BOUNDS[1]),
+        dayOfMonth: parseField(parts[2], CRON_FIELD_BOUNDS[2]),
+        month: parseField(parts[3], CRON_FIELD_BOUNDS[3]),
+        dayOfWeek: parseField(parts[4], CRON_FIELD_BOUNDS[4]),
+    };
+}
+export function validateCronExpression(expression) {
+    try {
+        parseCronExpression(expression);
+        return null;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : "Invalid cron expression";
+    }
+}
+//# sourceMappingURL=cron-expression.js.map