@vercel/factory 0.0.3 → 0.0.5

package/dist/index.d.mts

@@ -0,0 +1,187 @@
+import { a as StoredEntry, i as StoreDriver, n as RecordExistsError, o as StoredRecord, r as RecordNotFoundError, s as VersionConflictError, t as CollectionName } from "./driver-CrZsy7sm.mjs";
+import { a as signalSchema, c as ReplyTo, d as replyToSchema, f as schemaVersionSchema, i as signalOutcomeSchema, l as SCHEMA_VERSION, m as vocabularySchema, n as SignalOutcome, o as signalSourceSchema, p as usdSchema, r as SignalSource, s as standardSignalSources, t as Signal, u as isoDateTimeSchema } from "./signal-CHVEmzvI.mjs";
+import { $ as ReceiptPhase, A as TaskPatch, B as taskDevboxSchema, C as ChangeTransitionOptions, Ct as changeIdSchema, D as CreateTaskInput, Dt as repositoryIdsSchema, E as CreateStoresOptions, Et as repositoryIdSchema, F as TaskKind, G as taskStateSchema, H as taskOriginSchema, I as TaskState, J as repositorySchema, K as Repository, L as harnessSchema, M as createStores, N as Task, O as DecideSignalOptions, Ot as signalIdSchema, P as TaskApproval, Q as ReceiptKind, R as standardTaskKinds, S as ChangePatch, St as TaskId, T as CreateSignalInput, Tt as receiptIdSchema, U as taskQuestionSchema, V as taskKindSchema, W as taskSchema, X as Cost, Y as repositorySlugSchema, Z as Receipt, _ as findingVerificationMethodSchema, _t as ChangeId, a as approvalRuleSchema, at as receiptStateSchema, b as ApprovalDecision, bt as RepositoryId, c as Finding, ct as standardReceiptStates, d as FindingVerification, dt as ChangeState, et as ReceiptState, f as findingCategorySchema, ft as Level, g as findingVerificationLevelSchema, gt as levelSchema, h as findingSchema, ht as changeStateSchema, i as approvalPolicySchema, it as receiptSchema, j as TaskTransitionOptions, k as FactoryStores, kt as taskIdSchema, l as FindingCategory, lt as Change, m as findingPrioritySchema, mt as changeSchema, n as ApprovalRule, nt as receiptKindSchema, o as defaultApprovalPolicy, ot as standardReceiptKinds, p as findingFingerprint, pt as changeEvidenceSchema, q as RepositorySlug, r as ApprovalSubject, rt as receiptPhaseSchema, s as requiresApproval, st as standardReceiptPhases, t as ApprovalPolicy, tt as costSchema, u as FindingPriority, ut as ChangeEvidence, v as findingVerificationSchema, vt as FactoryId, w as CreateChangeInput, wt as factoryIdSchema, x as ApprovalError, xt as SignalId, y as AppendReceiptInput, yt as ReceiptId, z as taskApprovalSchema } from "./approval-h5aj8HYN.mjs";
+import { z } from "zod";
+import { EveNextConfig, EveNextConfigFunction, EveNextConfigInput } from "eve/next";
+//#region src/briefs.d.ts
+/** The finding behind a task, when its signal carries one. */
+declare function findingForTask(stores: FactoryStores, task: Task): Promise<Finding | null>;
+/**
+ * The foreman's starting message for a fix task: facts only, never the
+ * reporter's reasoning. The finding text is untrusted data and is labelled so.
+ */
+declare function fixBrief(task: Task, repository: Repository, finding: Finding | null): string;
+/** The scanner's starting message for a scan task. */
+declare function scanBrief(task: Task, repository: Repository): string;
+//#endregion
+//#region src/schema/factory-config.d.ts
+declare const factoryConfigRepositorySchema: z.ZodObject<{
+  slug: z.ZodString;
+  dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const factoryConfigSchema: z.ZodObject<{
+  connectors: z.ZodDefault<z.ZodObject<{
+    github: z.ZodArray<z.ZodObject<{
+      owner: z.ZodString;
+      connector: z.ZodString;
+    }, z.core.$strict>>;
+    slack: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      connector: z.ZodString;
+    }, z.core.$strict>>>;
+  }, z.core.$strict>>;
+  repositories: z.ZodArray<z.ZodObject<{
+    slug: z.ZodString;
+    dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  }, z.core.$strict>>;
+  operators: z.ZodArray<z.ZodString>;
+  approval: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    source: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+      P0: "P0";
+      P1: "P1";
+      P2: "P2";
+      P3: "P3";
+    }>>>;
+    require: z.ZodBoolean;
+  }, z.core.$strict>>>;
+}, z.core.$strict>;
+type FactoryConfig = z.infer<typeof factoryConfigSchema>;
+type FactoryConfigInput = z.input<typeof factoryConfigSchema>;
+declare function defineFactory(config: FactoryConfigInput): FactoryConfig;
+//#endregion
+//#region src/build-factory.d.ts
+interface FactoryArgs<TConfig extends EveNextConfig = EveNextConfig> {
+  factoryConfig: FactoryConfigInput;
+  nextConfig: EveNextConfigInput<TConfig>;
+  root?: string;
+}
+declare function buildFactory<TConfig extends EveNextConfig>({ factoryConfig, nextConfig, root }: FactoryArgs<TConfig>): EveNextConfigFunction<TConfig>;
+//#endregion
+//#region src/changes.d.ts
+interface AdoptPullRequestInput {
+  repositoryId: RepositoryId;
+  prNumber: number;
+  prUrl: string;
+  author: string;
+}
+declare function adoptPullRequest(stores: Pick<FactoryStores, "changes">, input: AdoptPullRequestInput): Promise<Change>;
+//#endregion
+//#region src/dispatch.d.ts
+declare class DispatchRefusedError extends Error {
+  readonly taskId: TaskId;
+  readonly reason: string;
+  constructor(taskId: TaskId, reason: string);
+}
+interface DispatchOptions {
+  /**
+   * Starts the durable execution for the task (an Eve agent run). Runs after
+   * the task has won the queued -> running transition. The execution owns its
+   * own provisioning: it creates its Devbox as its first step and patches the
+   * task record with the result.
+   */
+  launch: (task: Task) => Promise<void>;
+  /** How many launches to try before the task fails for good; a failure re-queues for the next sweep. */
+  maxLaunchAttempts?: number;
+}
+declare const DEFAULT_MAX_LAUNCH_ATTEMPTS = 45;
+/**
+ * The handshake between recorded work and execution: win the store-gated
+ * transition (at most one dispatcher can succeed), then start the run. A
+ * launch failure re-queues the task (bumping its attempt) until the attempt
+ * limit, then fails it; a crash between the transition and the launch leaves
+ * a running task with no execution, which the sweep reaps.
+ */
+declare function dispatchTask(stores: FactoryStores, taskId: TaskId, options: DispatchOptions): Promise<Task>;
+//#endregion
+//#region src/schema/budget.d.ts
+declare const budgetMonthSchema: z.ZodString;
+declare const budgetSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  factoryId: z.ZodString;
+  month: z.ZodString;
+  limits: z.ZodObject<{
+    totalUsd: z.ZodNumber;
+    investigationUsd: z.ZodNumber;
+    perTaskReservationUsd: z.ZodNumber;
+    warningPercent: z.ZodNumber;
+    perRepositoryUsd: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+  }, z.core.$strict>;
+  notices: z.ZodObject<{
+    warningAt: z.ZodOptional<z.ZodISODateTime>;
+    exhaustedAt: z.ZodOptional<z.ZodISODateTime>;
+  }, z.core.$strict>;
+}, z.core.$strict>;
+type Budget = z.infer<typeof budgetSchema>;
+//#endregion
+//#region src/schema/transitions.d.ts
+type TransitionActor = "system" | "reconciler" | "foreman" | "operator" | "webhook" | "human";
+interface Transition<State extends string> {
+  readonly from: State;
+  readonly to: State;
+  readonly trigger: string;
+  readonly actor: TransitionActor;
+}
+declare const taskInitialState = "queued";
+declare const taskTransitions: readonly Transition<TaskState>[];
+declare const changeInitialState = "verifying";
+declare const changeTransitions: readonly Transition<ChangeState>[];
+declare const signalInitialOutcome = "pending";
+declare const signalOutcomeTransitions: readonly Transition<SignalOutcome>[];
+declare function isTransitionAllowed<State extends string>(transitions: readonly Transition<State>[], from: State, to: State): boolean;
+declare function legalNextStates<State extends string>(transitions: readonly Transition<State>[], from: State): readonly State[];
+declare class InvalidTransitionError<State extends string> extends Error {
+  readonly from: State;
+  readonly to: State;
+  readonly legalNextStates: readonly State[];
+  constructor(from: State, to: State, legal: readonly State[]);
+}
+declare function assertTransition<State extends string>(transitions: readonly Transition<State>[], from: State, to: State): void;
+declare function terminalStates<State extends string>(transitions: readonly Transition<State>[]): readonly State[];
+//#endregion
+//#region src/signals.d.ts
+interface SignalCreator {
+  create(input: CreateSignalInput): Promise<Signal>;
+}
+/**
+ * Bind normalized intake to signal creation alone. Connectors and API routes
+ * own authentication and normalization; configured workflows own what happens
+ * next.
+ */
+declare function createSignalCreator(stores: Pick<FactoryStores, "signals">): SignalCreator;
+//#endregion
+//#region src/store/memory.d.ts
+declare function createInMemoryDriver(): StoreDriver;
+//#endregion
+//#region src/sweep.d.ts
+/** Starts the agent for one task kind. Supplied by the app, which knows its agents' addresses. */
+type TaskLauncher = (task: Task, repository: Repository) => Promise<void>;
+interface SweepOptions {
+  /** Launcher per task kind, e.g. code_change -> foreman, security_scan -> security-scanner. */
+  launchers: Readonly<Record<string, TaskLauncher>>;
+}
+interface SweepResult {
+  dispatched: string[];
+  /** Tasks left in the queue and why: awaiting approval, no launcher, missing repository. */
+  skipped: {
+    taskId: string;
+    reason: string;
+  }[];
+  /** Tasks whose launch threw; dispatchTask has already recorded them as failed. */
+  failed: {
+    taskId: string;
+    reason: string;
+  }[];
+}
+/**
+ * One pass of the factory's dispatcher, meant to run on a schedule inside the
+ * deployment: every queued task that is allowed to run is started, in
+ * creation order. Nothing outside the factory ever starts an agent; the CLI
+ * and the dashboard only write tasks and approvals, and this picks them up.
+ * Idempotent by construction: dispatchTask's single-winner transition means
+ * two overlapping sweeps cannot start the same task twice.
+ */
+declare function sweepQueued(stores: FactoryStores, options: SweepOptions): Promise<SweepResult>;
+//#endregion
+export { AdoptPullRequestInput, AppendReceiptInput, ApprovalDecision, ApprovalError, ApprovalPolicy, ApprovalRule, ApprovalSubject, Budget, Change, ChangeEvidence, ChangeId, ChangePatch, ChangeState, ChangeTransitionOptions, CollectionName, Cost, CreateChangeInput, CreateSignalInput, CreateStoresOptions, CreateTaskInput, DEFAULT_MAX_LAUNCH_ATTEMPTS, DecideSignalOptions, DispatchOptions, DispatchRefusedError, FactoryArgs, FactoryConfig, FactoryConfigInput, FactoryId, FactoryStores, Finding, FindingCategory, FindingPriority, FindingVerification, InvalidTransitionError, Level, Receipt, ReceiptId, ReceiptKind, ReceiptPhase, ReceiptState, RecordExistsError, RecordNotFoundError, ReplyTo, Repository, RepositoryId, RepositorySlug, SCHEMA_VERSION, Signal, SignalCreator, SignalId, SignalOutcome, SignalSource, StoreDriver, StoredEntry, StoredRecord, SweepOptions, SweepResult, Task, TaskApproval, TaskId, TaskKind, TaskLauncher, TaskPatch, TaskState, TaskTransitionOptions, Transition, TransitionActor, VersionConflictError, adoptPullRequest, approvalPolicySchema, approvalRuleSchema, assertTransition, budgetMonthSchema, budgetSchema, buildFactory, changeEvidenceSchema, changeIdSchema, changeInitialState, changeSchema, changeStateSchema, changeTransitions, costSchema, createInMemoryDriver, createSignalCreator, createStores, defaultApprovalPolicy, defineFactory, dispatchTask, factoryConfigRepositorySchema, factoryConfigSchema, factoryIdSchema, findingCategorySchema, findingFingerprint, findingForTask, findingPrioritySchema, findingSchema, findingVerificationLevelSchema, findingVerificationMethodSchema, findingVerificationSchema, fixBrief, harnessSchema, isTransitionAllowed, isoDateTimeSchema, legalNextStates, levelSchema, receiptIdSchema, receiptKindSchema, receiptPhaseSchema, receiptSchema, receiptStateSchema, replyToSchema, repositoryIdSchema, repositoryIdsSchema, repositorySchema, repositorySlugSchema, requiresApproval, scanBrief, schemaVersionSchema, signalIdSchema, signalInitialOutcome, signalOutcomeSchema, signalOutcomeTransitions, signalSchema, signalSourceSchema, standardReceiptKinds, standardReceiptPhases, standardReceiptStates, standardSignalSources, standardTaskKinds, sweepQueued, taskApprovalSchema, taskDevboxSchema, taskIdSchema, taskInitialState, taskKindSchema, taskOriginSchema, taskQuestionSchema, taskSchema, taskStateSchema, taskTransitions, terminalStates, usdSchema, vocabularySchema };
+//# sourceMappingURL=index.d.mts.map