@vercel/factory 0.0.3 → 0.0.4

package/dist/id-DwCihQr4.mjs

@@ -0,0 +1,31 @@
+import { z } from "zod";
+//#region src/schema/common.ts
+const SCHEMA_VERSION = 1;
+const schemaVersionSchema = z.literal(1).describe("Version of the entity schema this row was written with.");
+const isoDateTimeSchema = z.iso.datetime().describe("UTC timestamp in ISO 8601 format, e.g. 2026-08-26T12:00:00Z.");
+const usdSchema = z.number().finite().nonnegative().describe("Amount in US dollars.");
+/**
+* Open vocabulary value. Standard values ship as exported constants; custom
+* values matching the pattern are equally valid.
+*/
+const vocabularySchema = z.string().regex(/^[a-z][a-z0-9_]{0,63}$/, "must be lowercase snake_case starting with a letter").describe("Lowercase snake_case name, e.g. github_issue or sentry_alert.");
+const replyToSchema = z.strictObject({
+	channel: z.string().min(1).describe("Connector that should carry replies, e.g. github or slack."),
+	address: z.string().min(1).describe("Connector-specific reply address, e.g. acme/web#41 or a Slack thread id.")
+});
+//#endregion
+//#region src/schema/id.ts
+function idSchema(prefix) {
+	return z.string().regex(new RegExp(`^${prefix}_[a-z0-9]{6,64}$`));
+}
+const factoryIdSchema = idSchema("fac");
+const repositoryIdSchema = idSchema("repo");
+const signalIdSchema = idSchema("sig");
+const taskIdSchema = idSchema("task");
+const changeIdSchema = idSchema("chg");
+const receiptIdSchema = idSchema("rcpt");
+const repositoryIdsSchema = z.array(repositoryIdSchema).min(1);
+//#endregion
+export { repositoryIdsSchema as a, SCHEMA_VERSION as c, schemaVersionSchema as d, usdSchema as f, repositoryIdSchema as i, isoDateTimeSchema as l, factoryIdSchema as n, signalIdSchema as o, vocabularySchema as p, receiptIdSchema as r, taskIdSchema as s, changeIdSchema as t, replyToSchema as u };
+
+//# sourceMappingURL=id-DwCihQr4.mjs.map

package/dist/id-DwCihQr4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-DwCihQr4.mjs","names":[],"sources":["../src/schema/common.ts","../src/schema/id.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const SCHEMA_VERSION = 1;\n\nexport const schemaVersionSchema = z\n  .literal(SCHEMA_VERSION)\n  .describe(\"Version of the entity schema this row was written with.\");\n\nexport const isoDateTimeSchema = z.iso\n  .datetime()\n  .describe(\"UTC timestamp in ISO 8601 format, e.g. 2026-08-26T12:00:00Z.\");\n\nexport const usdSchema = z.number().finite().nonnegative().describe(\"Amount in US dollars.\");\n\n/**\n * Open vocabulary value. Standard values ship as exported constants; custom\n * values matching the pattern are equally valid.\n */\nexport const vocabularySchema = z\n  .string()\n  .regex(/^[a-z][a-z0-9_]{0,63}$/, \"must be lowercase snake_case starting with a letter\")\n  .describe(\"Lowercase snake_case name, e.g. github_issue or sentry_alert.\");\n\nexport const replyToSchema = z.strictObject({\n  channel: z\n    .string()\n    .min(1)\n    .describe(\"Connector that should carry replies, e.g. github or slack.\"),\n  address: z\n    .string()\n    .min(1)\n    .describe(\"Connector-specific reply address, e.g. acme/web#41 or a Slack thread id.\"),\n});\n\nexport type ReplyTo = z.infer<typeof replyToSchema>;\n","import { z } from \"zod\";\n\nfunction idSchema(prefix: string) {\n  return z.string().regex(new RegExp(`^${prefix}_[a-z0-9]{6,64}$`));\n}\n\nexport const factoryIdSchema = idSchema(\"fac\");\nexport const repositoryIdSchema = idSchema(\"repo\");\nexport const signalIdSchema = idSchema(\"sig\");\nexport const taskIdSchema = idSchema(\"task\");\nexport const changeIdSchema = idSchema(\"chg\");\nexport const receiptIdSchema = idSchema(\"rcpt\");\n\nexport const repositoryIdsSchema = z.array(repositoryIdSchema).min(1);\n\nexport type FactoryId = z.infer<typeof factoryIdSchema>;\nexport type RepositoryId = z.infer<typeof repositoryIdSchema>;\nexport type SignalId = z.infer<typeof signalIdSchema>;\nexport type TaskId = z.infer<typeof taskIdSchema>;\nexport type ChangeId = z.infer<typeof changeIdSchema>;\nexport type ReceiptId = z.infer<typeof receiptIdSchema>;\n"],"mappings":";;AAEA,MAAa,iBAAiB;AAE9B,MAAa,sBAAsB,EAChC,QAAA,CAAsB,CAAC,CACvB,SAAS,yDAAyD;AAErE,MAAa,oBAAoB,EAAE,IAChC,SAAS,CAAC,CACV,SAAS,8DAA8D;AAE1E,MAAa,YAAY,EAAE,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,uBAAuB;;;;;AAM3F,MAAa,mBAAmB,EAC7B,OAAO,CAAC,CACR,MAAM,0BAA0B,qDAAqD,CAAC,CACtF,SAAS,+DAA+D;AAE3E,MAAa,gBAAgB,EAAE,aAAa;CAC1C,SAAS,EACN,OAAO,CAAC,CACR,IAAI,CAAC,CAAC,CACN,SAAS,4DAA4D;CACxE,SAAS,EACN,OAAO,CAAC,CACR,IAAI,CAAC,CAAC,CACN,SAAS,0EAA0E;AACxF,CAAC;;;AC9BD,SAAS,SAAS,QAAgB;CAChC,OAAO,EAAE,OAAO,CAAC,CAAC,MAAM,IAAI,OAAO,IAAI,OAAO,iBAAiB,CAAC;AAClE;AAEA,MAAa,kBAAkB,SAAS,KAAK;AAC7C,MAAa,qBAAqB,SAAS,MAAM;AACjD,MAAa,iBAAiB,SAAS,KAAK;AAC5C,MAAa,eAAe,SAAS,MAAM;AAC3C,MAAa,iBAAiB,SAAS,KAAK;AAC5C,MAAa,kBAAkB,SAAS,MAAM;AAE9C,MAAa,sBAAsB,EAAE,MAAM,kBAAkB,CAAC,CAAC,IAAI,CAAC"}

package/dist/index-WNGZJRRH.d.mts

@@ -0,0 +1,67 @@
+import { c as ReplyTo, r as SignalSource } from "./signal-CHVEmzvI.mjs";
+import { z } from "zod";
+//#region src/connectors/index.d.ts
+interface WebhookEvent {
+  deliveryId: string;
+  event: string;
+  payload: unknown;
+}
+interface NormalizedSignal<TSource extends SignalSource = SignalSource> {
+  source: TSource;
+  deliveryId: string;
+  replyTo: ReplyTo;
+  payload: unknown;
+}
+type SignalNormalizer<TSignal extends NormalizedSignal = NormalizedSignal> = (event: WebhookEvent) => TSignal | null;
+declare const communicationOutcomes: readonly ["accepted", "started", "succeeded", "failed", "needs_human", "question", "digest", "rolled_back", "budget_warning", "budget_exhausted", "message"];
+declare const communicationOutcomeSchema: z.ZodEnum<{
+  message: "message";
+  succeeded: "succeeded";
+  failed: "failed";
+  needs_human: "needs_human";
+  question: "question";
+  accepted: "accepted";
+  rolled_back: "rolled_back";
+  started: "started";
+  digest: "digest";
+  budget_warning: "budget_warning";
+  budget_exhausted: "budget_exhausted";
+}>;
+declare const communicationEventSchema: z.ZodObject<{
+  eventId: z.ZodString;
+  repositoryId: z.ZodString;
+  taskId: z.ZodOptional<z.ZodString>;
+  changeId: z.ZodOptional<z.ZodString>;
+  replyTo: z.ZodObject<{
+    channel: z.ZodString;
+    address: z.ZodString;
+  }, z.core.$strict>;
+  outcome: z.ZodEnum<{
+    message: "message";
+    succeeded: "succeeded";
+    failed: "failed";
+    needs_human: "needs_human";
+    question: "question";
+    accepted: "accepted";
+    rolled_back: "rolled_back";
+    started: "started";
+    digest: "digest";
+    budget_warning: "budget_warning";
+    budget_exhausted: "budget_exhausted";
+  }>;
+  data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+type CommunicationOutcome = z.infer<typeof communicationOutcomeSchema>;
+type CommunicationEvent = z.infer<typeof communicationEventSchema>;
+interface CommunicationAdapter {
+  readonly channel: string;
+  deliver(event: CommunicationEvent): Promise<void>;
+}
+interface CommunicationRouter {
+  readonly channels: readonly string[];
+  deliver(event: CommunicationEvent): Promise<void>;
+}
+declare function createCommunicationRouter(adapters: readonly CommunicationAdapter[]): CommunicationRouter;
+//#endregion
+export { NormalizedSignal as a, communicationEventSchema as c, createCommunicationRouter as d, CommunicationRouter as i, communicationOutcomeSchema as l, CommunicationEvent as n, SignalNormalizer as o, CommunicationOutcome as r, WebhookEvent as s, CommunicationAdapter as t, communicationOutcomes as u };
+//# sourceMappingURL=index-WNGZJRRH.d.mts.map

package/dist/index.d.mts

@@ -0,0 +1,175 @@
+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>>;
+  }, 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/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 { 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, 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