vellum 0.2.13 → 0.3.2

package/src/runtime/routes/secret-routes.ts

@@ -1,76 +0,0 @@
-import { API_KEY_PROVIDERS, getConfig, invalidateConfigCache } from '../../config/loader.js';
-import { initializeProviders } from '../../providers/registry.js';
-import { setSecureKey } from '../../security/secure-keys.js';
-import { assertMetadataWritable, upsertCredentialMetadata } from '../../tools/credentials/metadata-store.js';
-import { getLogger } from '../../util/logger.js';
-
-const log = getLogger('runtime-http');
-
-export async function handleAddSecret(req: Request): Promise<Response> {
-  const body = await req.json() as {
-    type?: string;
-    name?: string;
-    value?: string;
-  };
-
-  const { type, name, value } = body;
-
-  if (!type || typeof type !== 'string') {
-    return Response.json({ error: 'type is required' }, { status: 400 });
-  }
-  if (!name || typeof name !== 'string') {
-    return Response.json({ error: 'name is required' }, { status: 400 });
-  }
-  if (!value || typeof value !== 'string') {
-    return Response.json({ error: 'value is required' }, { status: 400 });
-  }
-
-  try {
-    if (type === 'api_key') {
-      if (!API_KEY_PROVIDERS.includes(name as typeof API_KEY_PROVIDERS[number])) {
-        return Response.json(
-          { error: `Unknown API key provider: ${name}. Valid providers: ${API_KEY_PROVIDERS.join(', ')}` },
-          { status: 400 },
-        );
-      }
-      const stored = setSecureKey(name, value);
-      if (!stored) {
-        return Response.json({ error: 'Failed to store API key in secure storage' }, { status: 500 });
-      }
-      invalidateConfigCache();
-      initializeProviders(getConfig());
-      log.info({ provider: name }, 'API key updated via HTTP');
-      return Response.json({ success: true, type, name }, { status: 201 });
-    }
-
-    if (type === 'credential') {
-      const colonIdx = name.indexOf(':');
-      if (colonIdx < 1 || colonIdx === name.length - 1) {
-        return Response.json(
-          { error: 'For credential type, name must be in "service:field" format (e.g. "github:api_token")' },
-          { status: 400 },
-        );
-      }
-      assertMetadataWritable();
-      const service = name.slice(0, colonIdx);
-      const field = name.slice(colonIdx + 1);
-      const key = `credential:${service}:${field}`;
-      const stored = setSecureKey(key, value);
-      if (!stored) {
-        return Response.json({ error: 'Failed to store credential in secure storage' }, { status: 500 });
-      }
-      upsertCredentialMetadata(service, field, {});
-      log.info({ service, field }, 'Credential added via HTTP');
-      return Response.json({ success: true, type, name }, { status: 201 });
-    }
-
-    return Response.json(
-      { error: `Unknown secret type: ${type}. Valid types: api_key, credential` },
-      { status: 400 },
-    );
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log.error({ err, type, name }, 'Failed to add secret via HTTP');
-    return Response.json({ error: message }, { status: 500 });
-  }
-}

package/src/runtime/run-orchestrator.ts

@@ -1,296 +0,0 @@
-/**
- * Orchestrates run lifecycle for the HTTP runtime API.
- *
- * A "run" wraps a single agent-loop execution, tracking its state through:
- *   running → needs_confirmation → running → completed | failed
- *   running → needs_secret       → running → completed | failed
- *
- * When a tool needs permission, the orchestrator intercepts the
- * confirmation_request from the session's prompter and records it in
- * the run store.  Similarly, when a tool needs a secret (e.g.
- * credential_store prompt), the orchestrator intercepts the
- * secret_request and records it.  The client can then poll the run
- * status and submit a decision or secret via the respective endpoints.
- */
-
-import * as runsStore from '../memory/runs-store.js';
-import type { Run } from '../memory/runs-store.js';
-import type { Session } from '../daemon/session.js';
-import type { ServerMessage } from '../daemon/ipc-protocol.js';
-import { resolveChannelCapabilities } from '../daemon/session-runtime-assembly.js';
-import type { UserDecision } from '../permissions/types.js';
-import { checkIngressForSecrets } from '../security/secret-ingress.js';
-import { IngressBlockedError } from '../util/errors.js';
-import { getLogger } from '../util/logger.js';
-import { assistantEventHub } from './assistant-event-hub.js';
-import { buildAssistantEvent } from './assistant-event.js';
-
-const log = getLogger('run-orchestrator');
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-interface PendingRunState {
-  prompterRequestId: string;
-  session: Session;
-}
-
-export interface RunOrchestratorDeps {
-  getOrCreateSession: (conversationId: string) => Promise<Session>;
-  resolveAttachments: (attachmentIds: string[]) => Array<{
-    id: string;
-    filename: string;
-    mimeType: string;
-    data: string;
-  }>;
-}
-
-// ---------------------------------------------------------------------------
-// Orchestrator
-// ---------------------------------------------------------------------------
-
-export class RunOrchestrator {
-  private pending = new Map<string, PendingRunState>();
-  private deps: RunOrchestratorDeps;
-
-  constructor(deps: RunOrchestratorDeps) {
-    this.deps = deps;
-
-    // On startup, mark any runs left in non-terminal states as failed.
-    // These are orphans from a previous daemon process that was interrupted.
-    const recovered = runsStore.failOrphanedRuns();
-    if (recovered > 0) {
-      log.info({ count: recovered }, 'Recovered orphaned runs from previous session');
-    }
-  }
-
-  /**
-   * Start a new run: persist the user message, create a run record,
-   * and fire the agent loop in the background.
-   */
-  async startRun(
-    conversationId: string,
-    content: string,
-    attachmentIds?: string[],
-  ): Promise<Run> {
-    // Block inbound content that contains secrets — mirrors the IPC check in sessions.ts
-    const ingressCheck = checkIngressForSecrets(content);
-    if (ingressCheck.blocked) {
-      throw new IngressBlockedError(ingressCheck.userNotice!, ingressCheck.detectedTypes);
-    }
-
-    const session = await this.deps.getOrCreateSession(conversationId);
-
-    if (session.isProcessing()) {
-      throw new Error('Session is already processing a message');
-    }
-
-    const attachments = attachmentIds
-      ? this.deps.resolveAttachments(attachmentIds)
-      : [];
-
-    const requestId = crypto.randomUUID();
-    const messageId = session.persistUserMessage(content, attachments, requestId);
-    const run = runsStore.createRun(conversationId, messageId);
-
-    // Runs are always HTTP-originated; set channel capabilities so the attachment
-    // scope heuristic resolves to 'self' rather than 'local-assistant'.
-    session.setChannelCapabilities(resolveChannelCapabilities('http-api'));
-
-    // Serialized publish chain so hub subscribers observe events in order.
-    let hubChain: Promise<void> = Promise.resolve();
-    const publishToHub = (msg: ServerMessage): void => {
-      const msgRecord = msg as unknown as Record<string, unknown>;
-      const msgSessionId =
-        'sessionId' in msg && typeof msgRecord.sessionId === 'string'
-          ? (msgRecord.sessionId as string)
-          : undefined;
-      const resolvedSessionId = msgSessionId ?? conversationId;
-      const event = buildAssistantEvent('self', msg, resolvedSessionId);
-      hubChain = hubChain
-        .then(() => assistantEventHub.publish(event))
-        .catch((err: unknown) => {
-          log.warn({ err }, 'assistant-events hub subscriber threw during HTTP run');
-        });
-    };
-
-
-    // Hook into session to intercept confirmation_request and secret_request events.
-    // When the prompter sends one of these, we record it in the run store so
-    // the client can poll and submit a decision/secret via the respective endpoint.
-    // Do NOT set hasNoClient — run sessions have a client (the HTTP caller).
-    let lastError: string | null = null;
-    session.updateClient((msg: ServerMessage) => {
-      if (msg.type === 'confirmation_request') {
-        runsStore.setRunConfirmation(run.id, {
-          toolName: msg.toolName,
-          toolUseId: msg.requestId,
-          input: msg.input,
-          riskLevel: msg.riskLevel,
-          executionTarget: msg.executionTarget,
-          allowlistOptions: msg.allowlistOptions,
-          scopeOptions: msg.scopeOptions,
-          principalKind: msg.principalKind,
-          principalId: msg.principalId,
-          principalVersion: msg.principalVersion,
-          persistentDecisionsAllowed: msg.persistentDecisionsAllowed,
-        });
-        this.pending.set(run.id, {
-          prompterRequestId: msg.requestId,
-          session,
-        });
-      } else if (msg.type === 'secret_request') {
-        runsStore.setRunSecret(run.id, {
-          requestId: msg.requestId,
-          service: msg.service,
-          field: msg.field,
-          label: msg.label,
-          description: msg.description,
-          placeholder: msg.placeholder,
-          purpose: msg.purpose,
-          allowOneTimeSend: msg.allowOneTimeSend,
-        });
-        this.pending.set(run.id, {
-          prompterRequestId: msg.requestId,
-          session,
-        });
-      }
-      // Mirror every outbound message to the assistant-events hub so SSE
-      // subscribers receive the same payload parity as IPC clients.
-      publishToHub(msg);
-    });
-
-    // Fire-and-forget the agent loop
-    const cleanup = () => {
-      this.pending.delete(run.id);
-      // Reset channel capabilities so a subsequent IPC/desktop session on the
-      // same conversation is not incorrectly treated as an HTTP-API client.
-      session.setChannelCapabilities(null);
-      // Reset the session's client callback to a no-op so the stale
-      // closure doesn't intercept events from future runs on the same session.
-      // Set hasNoClient=true here since the run is done and no HTTP caller
-      // is actively listening — truly no client at this point.
-      session.updateClient(() => {}, true);
-    };
-
-    session.runAgentLoop(content, messageId, (msg: ServerMessage) => {
-      if (msg.type === 'error') {
-        lastError = msg.message;
-      } else if (msg.type === 'session_error') {
-        lastError = msg.userMessage;
-      }
-      // Mirror agent-loop events (assistant_text_delta, message_complete,
-      // tool_use_start, tool_result, etc.) to the hub. These travel through
-      // the onEvent path, distinct from the updateClient path used by the
-      // prompter (confirmation_request). Both paths must publish so SSE
-      // consumers receive the full response stream.
-      publishToHub(msg);
-    }).then(() => {
-      if (lastError) {
-        log.error({ runId: run.id, error: lastError }, 'Run failed (error event from agent loop)');
-        runsStore.failRun(run.id, lastError);
-      } else {
-        runsStore.completeRun(run.id);
-      }
-      cleanup();
-    }).catch((err) => {
-      const message = err instanceof Error ? err.message : String(err);
-      log.error({ err, runId: run.id }, 'Run failed');
-      runsStore.failRun(run.id, message);
-      cleanup();
-    });
-
-    return run;
-  }
-
-  /** Read current run state from the store. */
-  getRun(runId: string): Run | null {
-    return runsStore.getRun(runId);
-  }
-
-  /**
-   * Submit a permission decision for a pending confirmation.
-   *
-   * Returns:
-   * - `'applied'`         – decision was applied or already handled (idempotent)
-   * - `'run_not_found'`   – no run exists with the given ID
-   * - `'no_pending_decision'` – run exists but is not awaiting a confirmation
-   */
-  submitDecision(runId: string, decision: UserDecision): 'applied' | 'run_not_found' | 'no_pending_decision' {
-    const pendingState = this.pending.get(runId);
-    if (pendingState) {
-      runsStore.clearRunConfirmation(runId);
-      pendingState.session.handleConfirmationResponse(
-        pendingState.prompterRequestId,
-        decision,
-      );
-      this.pending.delete(runId);
-      return 'applied';
-    }
-
-    // No in-memory pending state — check if the run exists.
-    const run = runsStore.getRun(runId);
-    if (!run) return 'run_not_found';
-
-    // If the run is still needs_confirmation but there's no in-memory
-    // state, the prompter already timed out and auto-denied. Fail the
-    // run rather than clearing to 'running', since no agent loop exists
-    // to complete it.
-    if (run.status === 'needs_confirmation') {
-      runsStore.failRun(runId, 'Prompter timed out (no active handler)');
-      return 'applied';
-    }
-
-    // Terminal states (completed/failed) mean the decision was already
-    // handled (double-submit). Treat as idempotent success.
-    if (run.status === 'completed' || run.status === 'failed') {
-      return 'applied';
-    }
-
-    // Run is in 'running' state with no pending confirmation — the
-    // agent loop hasn't reached a confirmation point yet. Reject so
-    // the client doesn't mistakenly treat the decision as accepted.
-    return 'no_pending_decision';
-  }
-
-  /**
-   * Submit a secret value for a pending secret request.
-   *
-   * Returns:
-   * - `'applied'`           – secret was forwarded to the session
-   * - `'run_not_found'`     – no run exists with the given ID
-   * - `'no_pending_secret'` – run exists but is not awaiting a secret
-   */
-  submitSecret(
-    runId: string,
-    value?: string,
-    delivery?: 'store' | 'transient_send',
-  ): 'applied' | 'run_not_found' | 'no_pending_secret' {
-    const pendingState = this.pending.get(runId);
-    if (pendingState) {
-      runsStore.clearRunSecret(runId);
-      pendingState.session.handleSecretResponse(
-        pendingState.prompterRequestId,
-        value,
-        delivery,
-      );
-      this.pending.delete(runId);
-      return 'applied';
-    }
-
-    const run = runsStore.getRun(runId);
-    if (!run) return 'run_not_found';
-
-    if (run.status === 'needs_secret') {
-      runsStore.failRun(runId, 'Secret prompter timed out (no active handler)');
-      return 'applied';
-    }
-
-    if (run.status === 'completed' || run.status === 'failed') {
-      return 'applied';
-    }
-
-    return 'no_pending_secret';
-  }
-}

package/src/schedule/recurrence-engine.ts

@@ -1,138 +0,0 @@
-import { Cron } from 'croner';
-import { rrulestr, RRuleSet } from 'rrule';
-import type { ScheduleSyntax } from './recurrence-types.js';
-
-export interface ScheduleSpec {
-  syntax: ScheduleSyntax;
-  expression: string;
-  timezone?: string | null;
-}
-
-const SUPPORTED_RRULE_PREFIXES = ['DTSTART', 'RRULE:', 'RDATE', 'EXDATE', 'EXRULE'];
-
-function normalizeRruleExpression(expression: string): string {
-  // Handle escaped newlines from JSON transport
-  return expression.replace(/\\n/g, '\n').trim();
-}
-
-function parseRruleLines(expression: string): string[] {
-  return normalizeRruleExpression(expression)
-    .split(/\r?\n/)
-    .map(l => l.trim())
-    .filter(Boolean);
-}
-
-function validateRruleLines(lines: string[]): string | null {
-  let hasInclusion = false;
-  let hasDtstart = false;
-
-  for (const line of lines) {
-    const upper = line.toUpperCase();
-    if (!SUPPORTED_RRULE_PREFIXES.some(p => upper.startsWith(p))) {
-      return `Unsupported recurrence line: ${line}`;
-    }
-    if (upper.startsWith('DTSTART')) hasDtstart = true;
-    if (upper.startsWith('RRULE:') || upper.startsWith('RDATE')) hasInclusion = true;
-  }
-
-  if (!hasDtstart) return 'RRULE expression must include DTSTART for deterministic scheduling';
-  if (!hasInclusion) return 'RRULE expression must include at least one RRULE or RDATE';
-  return null;
-}
-
-/**
- * Detect whether an RRULE expression contains set constructs (RDATE, EXDATE,
- * EXRULE, or multiple RRULE lines) that require RRuleSet parsing.
- */
-export function hasSetConstructs(expression: string): boolean {
-  const lines = parseRruleLines(expression);
-  let rruleCount = 0;
-  for (const line of lines) {
-    const upper = line.toUpperCase();
-    if (upper.startsWith('RDATE') || upper.startsWith('EXDATE') || upper.startsWith('EXRULE')) return true;
-    if (upper.startsWith('RRULE:')) rruleCount++;
-  }
-  return rruleCount > 1;
-}
-
-/**
- * Validate RRULE set lines in an expression. Returns null if valid, or an
- * actionable error string describing the problem. This is intended for tool
- * layers that want to surface a specific error message before calling the
- * store.
- */
-export function validateRruleSetLines(expression: string): string | null {
-  const lines = parseRruleLines(expression);
-  return validateRruleLines(lines);
-}
-
-/**
- * Validate a schedule expression. Returns true if the expression is valid
- * for the given syntax, false otherwise.
- */
-export function isValidScheduleExpression(spec: ScheduleSpec): boolean {
-  try {
-    if (spec.syntax === 'cron') {
-      new Cron(spec.expression, { maxRuns: 0 });
-      return true;
-    }
-
-    if (spec.syntax === 'rrule') {
-      const lines = parseRruleLines(spec.expression);
-      const error = validateRruleLines(lines);
-      if (error) return false;
-
-      const normalized = normalizeRruleExpression(spec.expression);
-      const tzid = spec.timezone ?? undefined;
-      if (hasSetConstructs(normalized)) {
-        rrulestr(normalized, { forceset: true, tzid });
-      } else {
-        rrulestr(normalized, { tzid });
-      }
-      return true;
-    }
-
-    return false;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Compute the next run timestamp (epoch ms) for a schedule expression.
- * Throws if no future runs exist.
- */
-export function computeNextRunAt(spec: ScheduleSpec, nowMs?: number): number {
-  const now = nowMs ?? Date.now();
-
-  if (spec.syntax === 'cron') {
-    const cron = new Cron(spec.expression, {
-      timezone: spec.timezone ?? undefined,
-    });
-    const next = cron.nextRun(new Date(now));
-    if (!next) {
-      throw new Error(`Cron expression "${spec.expression}" has no upcoming runs`);
-    }
-    return next.getTime();
-  }
-
-  if (spec.syntax === 'rrule') {
-    const normalized = normalizeRruleExpression(spec.expression);
-    const lines = parseRruleLines(normalized);
-    const error = validateRruleLines(lines);
-    if (error) throw new Error(error);
-
-    const useSet = hasSetConstructs(normalized);
-    const tzid = spec.timezone ?? undefined;
-    const parsed = useSet
-      ? (rrulestr(normalized, { forceset: true, tzid }) as RRuleSet)
-      : rrulestr(normalized, { tzid });
-    const next = parsed.after(new Date(now));
-    if (!next) {
-      throw new Error(`RRULE expression has no upcoming runs after ${new Date(now).toISOString()}`);
-    }
-    return next.getTime();
-  }
-
-  throw new Error(`Unsupported schedule syntax: ${spec.syntax}`);
-}

package/src/schedule/recurrence-types.ts

@@ -1,67 +0,0 @@
-export type ScheduleSyntax = 'cron' | 'rrule';
-
-/**
- * Detect whether an expression string is cron or RRULE syntax.
- * Returns null for ambiguous or invalid expressions.
- */
-export function detectScheduleSyntax(expression: string): ScheduleSyntax | null {
-  if (!expression || typeof expression !== 'string') return null;
-  const trimmed = expression.trim();
-  if (!trimmed) return null;
-
-  // RRULE detection: starts with RRULE:, DTSTART, or contains FREQ=
-  if (/^(RRULE:|DTSTART)/m.test(trimmed) || /FREQ=/i.test(trimmed)) {
-    return 'rrule';
-  }
-
-  // Cron detection: 5 space-separated fields
-  const fields = trimmed.split(/\s+/);
-  if (fields.length === 5) {
-    // Basic sanity check: each field should match cron-like characters
-    const cronFieldPattern = /^[\d\*\/\-\,\?LW#]+$/;
-    if (fields.every(f => cronFieldPattern.test(f))) {
-      return 'cron';
-    }
-  }
-
-  return null;
-}
-
-/**
- * Normalize schedule syntax from tool/API inputs.
- * Resolution order:
- * 1. If explicit `syntax` is provided, use it
- * 2. If `expression` is provided, auto-detect from expression
- * 3. If `legacyCronExpression` is provided, treat as cron
- * 4. Return null if nothing resolved
- */
-export function normalizeScheduleSyntax(input: {
-  syntax?: ScheduleSyntax;
-  expression?: string;
-  legacyCronExpression?: string;
-}): { syntax: ScheduleSyntax; expression: string } | null {
-  // Explicit syntax + expression
-  if (input.syntax && input.expression) {
-    return { syntax: input.syntax, expression: input.expression };
-  }
-
-  // Auto-detect from expression
-  if (input.expression) {
-    const detected = detectScheduleSyntax(input.expression);
-    if (detected) {
-      return { syntax: detected, expression: input.expression };
-    }
-    // If we have an explicit syntax but couldn't detect, trust the explicit syntax
-    if (input.syntax) {
-      return { syntax: input.syntax, expression: input.expression };
-    }
-    return null;
-  }
-
-  // Legacy cron_expression fallback
-  if (input.legacyCronExpression) {
-    return { syntax: 'cron', expression: input.legacyCronExpression };
-  }
-
-  return null;
-}