@hyperdrive.bot/paseo-protocol 0.2.5

package/dist/provider-manifest.js

@@ -0,0 +1,344 @@
+import { z } from "zod";
+const CLAUDE_MODES = [
+    {
+        id: "default",
+        label: "Always Ask",
+        description: "Prompts for permission the first time a tool is used",
+        icon: "ShieldCheck",
+        colorTier: "safe",
+    },
+    {
+        id: "auto",
+        label: "Auto mode",
+        description: "Uses a model classifier to review permission prompts automatically",
+        icon: "ShieldQuestionMark",
+        colorTier: "moderate",
+    },
+    {
+        id: "acceptEdits",
+        label: "Accept File Edits",
+        description: "Automatically approves edit-focused tools without prompting",
+        icon: "ShieldAlert",
+        colorTier: "moderate",
+    },
+    {
+        id: "plan",
+        label: "Plan Mode",
+        description: "Analyze the codebase without executing tools or edits",
+        icon: "ShieldCheck",
+        colorTier: "planning",
+    },
+    {
+        id: "bypassPermissions",
+        label: "Bypass",
+        description: "Skip all permission prompts (use with caution)",
+        icon: "ShieldAlert",
+        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",
+        },
+        wireFamily: "anthropic-messages",
+        compatibleProviders: [],
+    },
+    {
+        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",
+        },
+        wireFamily: "openai-compatible",
+        compatibleProviders: [],
+    },
+    {
+        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,
+        wireFamily: "generic-acp",
+        compatibleProviders: [],
+    },
+    {
+        id: "opencode",
+        label: "OpenCode",
+        description: "Open-source coding assistant with multi-provider model support",
+        defaultModeId: "build",
+        modes: OPENCODE_MODES,
+        voice: {
+            enabled: true,
+            defaultModeId: "build",
+        },
+        wireFamily: "generic-acp",
+        compatibleProviders: [],
+    },
+    {
+        id: "pi",
+        label: "Pi",
+        description: "Minimal terminal-based coding agent with multi-provider LLM support",
+        defaultModeId: null,
+        modes: [],
+        wireFamily: "anthropic-messages",
+        compatibleProviders: [],
+    },
+    {
+        id: "omp",
+        label: "OMP",
+        description: "Pi-compatible coding agent distributed as Oh My Pi",
+        enabledByDefault: false,
+        defaultModeId: null,
+        modes: [],
+        wireFamily: "anthropic-messages",
+        compatibleProviders: [],
+    },
+];
+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,
+        wireFamily: "anthropic-messages",
+        compatibleProviders: [],
+    },
+    {
+        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,
+        wireFamily: "anthropic-messages",
+    },
+];
+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 };
+}
+/**
+ * Validates that `compatibleProviders` declarations are symmetric across all
+ * provided definitions: if A declares B compatible, B MUST declare A as well.
+ * One-sided declarations are dropped from the effective set and emitted as
+ * warnings so they fail loudly at boot rather than producing a half-broken
+ * swap experience at runtime.
+ *
+ * Wire-family mismatches are ALSO dropped + warned: even if both sides
+ * declare each other, a swap between two providers in different families
+ * cannot work (different wire formats / resume tokens).
+ */
+export function validateCompatibleProvidersSymmetry(definitions) {
+    const byId = new Map();
+    for (const definition of definitions) {
+        byId.set(definition.id, definition);
+    }
+    const effective = new Map();
+    for (const definition of definitions) {
+        effective.set(definition.id, new Set());
+    }
+    const warnings = [];
+    for (const definition of definitions) {
+        const declared = definition.compatibleProviders ?? [];
+        for (const other of declared) {
+            if (other === definition.id) {
+                warnings.push(`Provider '${definition.id}' lists itself in compatibleProviders — ignored.`);
+                continue;
+            }
+            const counterpart = byId.get(other);
+            if (!counterpart) {
+                warnings.push(`Provider '${definition.id}' lists unknown provider '${other}' as compatible — ignored.`);
+                continue;
+            }
+            const counterpartDeclares = (counterpart.compatibleProviders ?? []).includes(definition.id);
+            if (!counterpartDeclares) {
+                warnings.push(`Asymmetric compatibility: '${definition.id}' lists '${other}' but '${other}' does not list '${definition.id}' — dropped.`);
+                continue;
+            }
+            if (counterpart.wireFamily !== definition.wireFamily) {
+                warnings.push(`Wire-family mismatch between '${definition.id}' (${definition.wireFamily}) and '${other}' (${counterpart.wireFamily}) — swap dropped.`);
+                continue;
+            }
+            effective.get(definition.id)?.add(other);
+        }
+    }
+    return {
+        effective: new Map([...effective.entries()].map(([k, v]) => [k, v])),
+        warnings,
+    };
+}
+/**
+ * Compute the effective set of compatibleProviders for a runtime registry
+ * that may include custom providers extending builtins (e.g. "Claude (Pool)"
+ * with `extends: "claude"`). Strategy:
+ *
+ * 1. Start from each provider's explicit `compatibleProviders` list.
+ * 2. Auto-link providers that share the same `extends` base (siblings) AND
+ *    auto-link each derived provider with its base — but ONLY when both have
+ *    the same wireFamily AND the base did not explicitly opt out.
+ * 3. Run symmetry validation on the resulting graph; drop asymmetric edges.
+ *
+ * The result is a Map keyed by provider id, listing the providers each one
+ * may swap TO.
+ */
+export function computeEffectiveCompatibleProviders(definitions, 
+/** Optional: providerId -> base provider id (the `extends` target). */
+extensionMap) {
+    if (!extensionMap || extensionMap.size === 0) {
+        return validateCompatibleProvidersSymmetry(definitions);
+    }
+    // Build an augmented set of definitions where derived providers inherit
+    // bidirectional compatibility with siblings + the base.
+    const familyByBase = new Map();
+    for (const [derivedId, baseId] of extensionMap.entries()) {
+        const siblings = familyByBase.get(baseId) ?? [];
+        siblings.push(derivedId);
+        familyByBase.set(baseId, siblings);
+    }
+    const augmented = definitions.map((definition) => {
+        const baseId = extensionMap.get(definition.id);
+        const siblings = baseId ? (familyByBase.get(baseId) ?? []) : [];
+        const baseSiblings = familyByBase.get(definition.id) ?? [];
+        const inherited = new Set(definition.compatibleProviders ?? []);
+        // Derived → base + sibling derivatives
+        if (baseId) {
+            inherited.add(baseId);
+            for (const sibling of siblings) {
+                if (sibling !== definition.id)
+                    inherited.add(sibling);
+            }
+        }
+        // Base → derivatives extending it
+        for (const derived of baseSiblings) {
+            inherited.add(derived);
+        }
+        return {
+            ...definition,
+            compatibleProviders: [...inherited],
+        };
+    });
+    return validateCompatibleProvidersSymmetry(augmented);
+}
+//# 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