@vibesdotdev/forge 0.0.0-stage → 1.0.0-rc.5

package/dist/schemas/actions.d.ts

@@ -0,0 +1,412 @@
+/**
+ * `.forge/actions.yml` — the repo-scoped forge-actions pipeline DSL.
+ *
+ * A repo declares jobs (test / deploy / nightly) that run in response to forge
+ * events: a `push` (matched against a `repo.pushed` event), a `pr` (open/update,
+ * whose result becomes the gating status-check), or a `schedule` (cron, wired to
+ * the scheduled-tasks layer — deferred to a later layer, parsed here so the DSL
+ * is stable).
+ *
+ * The schema is Zod-validated and the YAML is parsed by `parseActionsYml`. A
+ * parse / validation failure is returned as a structured `{ ok:false, error }`
+ * (NEVER thrown) so the platform ingest route can surface it as a single failed
+ * `forge/config` status-check instead of 500ing the push-event ingest.
+ *
+ * Pure + dependency-light (only `yaml` + `zod`) so the parser + the
+ * trigger-matching / ref-guard helpers are unit-testable without any worker /
+ * session / DB context.
+ */
+import * as z from 'zod/v4';
+/** A `run:` step — a shell command executed in a code-session CI runner. */
+export declare const RunStepSchema: z.ZodObject<{
+    run: z.ZodString;
+}, z.core.$strip>;
+/**
+ * A `deploy:` step — shells `vibes infra deploy run <repositoryRelativeDir>` inside the
+ * code-session (infra-deploy is CLI-only / not workerd-safe, so it must run in
+ * the session host, never be imported into a Worker). Split repositories deploy
+ * their root with `.`; a nested path is only for a deployable genuinely owned by
+ * the same checked-out repository. The rule is `SafePackageRootSchema`, so a
+ * deploy directory cannot be an option either.
+ */
+export declare const DeployTargetSchema: z.ZodPipe<z.ZodString, z.ZodString>;
+export declare const DeployStepSchema: z.ZodObject<{
+    deploy: z.ZodPipe<z.ZodString, z.ZodString>;
+    environment: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * A `review:` step — requests the repository's independent exact-head PR review
+ * after the job's `needs`. The Forge control plane runs it (a job holds only
+ * review steps), never a runner shell. `review` names the reviewer profile the
+ * check reports; the repository's review automation chooses the reviewer.
+ */
+export declare const ReviewStepSchema: z.ZodObject<{
+    review: z.ZodString;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        code: "code";
+        visual: "visual";
+    }>>>;
+}, z.core.$strip>;
+/**
+ * The release contract a `publish:` step may ask the publish CLI for.
+ *
+ * One owner for the value and for the argument the compiler passes: a version
+ * this compiler cannot lower refuses at validation instead of reaching
+ * `vibes registry publish --release-contract-version 1`, which publishes under a
+ * contract the pipeline never declared.
+ */
+export declare const FORGE_PUBLISH_RELEASE_CONTRACT_VERSION = 2;
+export declare const ForgePublishReleaseContractVersionSchema: z.ZodLiteral<2>;
+/**
+ * A repository-relative package root a publish step may shell. One definition,
+ * shared with a publish target descriptor's `defaultPaths`
+ * (`../ci/publish-targets.ts`), so an authored path and a descriptor default are
+ * held to the same rule.
+ */
+export declare const PublishPackageRootSchema: z.ZodString;
+/**
+ * A `publish:` step — shells the `argv` its `ci/publish-target` descriptor
+ * declares (`vibes registry publish` / `vibes infra npm publish` built in) on an
+ * enrolled fleet host that already has the CLI.
+ */
+export declare const PublishStepSchema: z.ZodObject<{
+    publish: z.ZodString;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tag: z.ZodOptional<z.ZodString>;
+    releaseContractVersion: z.ZodOptional<z.ZodLiteral<2>>;
+}, z.core.$strip>;
+/**
+ * A `runbook:` step — runs a vibes runbook (`vibes dev runbooks run <id>`) in the
+ * checkout, e.g. `system:check-execute` with `{ trigger: 'ci' }` to run every
+ * unit's declared CI checks. The CLI is bootstrapped onto PATH like the other
+ * vibes-backed steps.
+ */
+export declare const RunbookStepSchema: z.ZodObject<{
+    runbook: z.ZodString;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>>;
+}, z.core.$strip>;
+export declare const StepSchema: z.ZodUnion<readonly [z.ZodObject<{
+    run: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    deploy: z.ZodPipe<z.ZodString, z.ZodString>;
+    environment: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    review: z.ZodString;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        code: "code";
+        visual: "visual";
+    }>>>;
+}, z.core.$strip>, z.ZodObject<{
+    publish: z.ZodString;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tag: z.ZodOptional<z.ZodString>;
+    releaseContractVersion: z.ZodOptional<z.ZodLiteral<2>>;
+}, z.core.$strip>, z.ZodObject<{
+    runbook: z.ZodString;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>>;
+}, z.core.$strip>]>;
+/** A simple (`push` | `pr`) trigger, or a `{ schedule: <cron> }` trigger. */
+export declare const ScheduleTriggerSchema: z.ZodObject<{
+    schedule: z.ZodString;
+}, z.core.$strip>;
+export declare const TriggerSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    push: "push";
+    pr: "pr";
+}>, z.ZodObject<{
+    schedule: z.ZodString;
+}, z.core.$strip>]>;
+/**
+ * The runner OS axis. `linux` is the only OS with a live (CF Sandbox) backend
+ * today; `macos`/`windows` are accepted in the DSL so a repo can declare intent,
+ * but a job requesting an unavailable runner fails its check. Silent skipping
+ * would turn missing infrastructure into false-green CI.
+ */
+export declare const RunsOnOsSchema: z.ZodEnum<{
+    linux: "linux";
+    macos: "macos";
+    windows: "windows";
+}>;
+export type RunsOnOs = z.infer<typeof RunsOnOsSchema>;
+/**
+ * The runner CPU-arch axis. `x64` is the only arch with a live (CF Sandbox,
+ * linux/amd64) backend today; `arm64` is accepted for forward-compat and is
+ * subject to the same fail-closed availability check. Optional — undefined means
+ * "the runner's native arch" (no arch constraint).
+ */
+export declare const RunsOnArchSchema: z.ZodEnum<{
+    x64: "x64";
+    arm64: "arm64";
+}>;
+export type RunsOnArch = z.infer<typeof RunsOnArchSchema>;
+/** Familiar default for jobs that do not need a specialized runner pool. */
+export declare const DEFAULT_FORGE_ACTIONS_RUNNER_PROFILE = "standard";
+/**
+ * Runner profile for jobs that must run on an enrolled fleet machine owned by
+ * the repository owner rather than a disposable sandbox. A sandbox carries no
+ * vibes CLI and no warm caches, so a deploy cannot finish inside its deadline.
+ */
+export declare const FORGE_ACTIONS_FLEET_RUNNER_PROFILE = "fleet";
+/**
+ * Provider-neutral runner profile selected by a repository.
+ *
+ * Profiles are stable product labels (for example `high-cpu`), not provider
+ * instance types. The Forge scheduler resolves the label to an available pool
+ * and fails visibly when no pool can satisfy it.
+ */
+export declare const ForgeRunnerProfileIdSchema: z.ZodString;
+export type ForgeRunnerProfileId = z.infer<typeof ForgeRunnerProfileIdSchema>;
+export declare const ForgeActionsRunnerProfileSchema: z.ZodDefault<z.ZodString>;
+/** Provider-neutral Forge Actions default for jobs without an authored deadline. */
+export declare const DEFAULT_FORGE_ACTIONS_JOB_TIMEOUT_MINUTES = 30;
+/** Public ceiling keeps absolute deadlines representable and operationally reviewable. */
+export declare const MAX_FORGE_ACTIONS_JOB_TIMEOUT_MINUTES: number;
+/**
+ * Absolute job wall-clock deadline in minutes. Seven days supports large native
+ * builds without allowing an unrepresentable or effectively immortal job.
+ * Product plans and runner pools may enforce smaller limits at scheduling time.
+ */
+export declare const ForgeActionsJobTimeoutMinutesSchema: z.ZodDefault<z.ZodNumber>;
+export declare const ArtifactPathSchema: z.ZodString;
+/**
+ * Opaque, lowercase, namespace-safe cache task id. A declaration that omits
+ * `namespace` defaults it to the task id, so the id must itself satisfy the
+ * namespace rule (the canonical policy accepts a wider opaque id; the
+ * authoring gate is deliberately narrower).
+ */
+export declare const ForgeActionsCacheTaskIdSchema: z.ZodString;
+/**
+ * Cache namespace. Mirrors the canonical policy namespace rule
+ * (`CiCacheNamespaceSchema`); the policy re-validates every value the compiler
+ * derives, so a value accepted here that the policy rejects fails compile
+ * rather than relaxing access.
+ */
+export declare const ForgeActionsCacheNamespaceSchema: z.ZodString;
+/** Sensitivity an author may declare; omit it and the policy decides disabled. */
+export declare const ForgeActionsCacheSensitivitySchema: z.ZodEnum<{
+    "public-reproducible": "public-reproducible";
+    "trusted-only": "trusted-only";
+}>;
+/**
+ * Author-owned cache declaration for one job.
+ *
+ * The author names a cache task id and, optionally, a namespace, a
+ * sensitivity, and repository-relative key files. Key file CONTENT, not
+ * their names, participates in the task hash (`compileJobCaches`), so
+ * editing a lockfile or manifest invalidates the cache; touching an
+ * identical file does not.
+ *
+ * An omitted `sensitivity` is a missing classification, not a grant: the
+ * canonical policy derivation treats it as `disabled` and no cache plan is
+ * emitted. `disabled` is deliberately not authorable — it is the fail-closed
+ * default, never a declaration. Credential references, secret bindings, and
+ * privileged execution are policy FACTS derived from the job/run by
+ * `compileJobCaches`, so the declaration is strict: an author who tries to
+ * write them here fails validation instead of quietly widening their own
+ * trust. `trusted-only` may only narrow; `public-reproducible` on a job with
+ * any sensitive policy fact is rejected with `CiCachePlanError`.
+ */
+export declare const ForgeActionsJobCacheSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    namespace: z.ZodOptional<z.ZodString>;
+    sensitivity: z.ZodOptional<z.ZodEnum<{
+        "public-reproducible": "public-reproducible";
+        "trusted-only": "trusted-only";
+    }>>;
+    keyFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type ForgeActionsJobCache = z.infer<typeof ForgeActionsJobCacheSchema>;
+export type ForgeActionsJobCacheInput = z.input<typeof ForgeActionsJobCacheSchema>;
+export declare const JobSchema: z.ZodObject<{
+    on: z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+        push: "push";
+        pr: "pr";
+    }>, z.ZodObject<{
+        schedule: z.ZodString;
+    }, z.core.$strip>]>>;
+    if: z.ZodOptional<z.ZodString>;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    needs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    environment: z.ZodOptional<z.ZodEnum<{
+        local: "local";
+        dev: "dev";
+        staging: "staging";
+        production: "production";
+    }>>;
+    runsOn: z.ZodDefault<z.ZodEnum<{
+        linux: "linux";
+        macos: "macos";
+        windows: "windows";
+    }>>;
+    arch: z.ZodOptional<z.ZodEnum<{
+        x64: "x64";
+        arm64: "arm64";
+    }>>;
+    runnerProfile: z.ZodDefault<z.ZodString>;
+    timeoutMinutes: z.ZodDefault<z.ZodNumber>;
+    steps: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        run: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        deploy: z.ZodPipe<z.ZodString, z.ZodString>;
+        environment: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        review: z.ZodString;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            code: "code";
+            visual: "visual";
+        }>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        publish: z.ZodString;
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        tag: z.ZodOptional<z.ZodString>;
+        releaseContractVersion: z.ZodOptional<z.ZodLiteral<2>>;
+    }, z.core.$strip>, z.ZodObject<{
+        runbook: z.ZodString;
+        input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>>;
+    }, z.core.$strip>]>>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    artifacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    cache: z.ZodOptional<z.ZodObject<{
+        taskId: z.ZodString;
+        namespace: z.ZodOptional<z.ZodString>;
+        sensitivity: z.ZodOptional<z.ZodEnum<{
+            "public-reproducible": "public-reproducible";
+            "trusted-only": "trusted-only";
+        }>>;
+        keyFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+/**
+ * The canonical product-profile id list. `CiProductProfileIdSchema`
+ * (`ci/schemas.ts`) is the same object under the CI-facing name; both exported
+ * names share this one definition and its inferred type.
+ */
+export declare const ForgeCiProductProfileIdSchema: z.ZodEnum<{
+    agent: "agent";
+    desktop: "desktop";
+    web: "web";
+    framework: "framework";
+    api: "api";
+    org: "org";
+}>;
+export type ForgeCiProductProfileId = z.infer<typeof ForgeCiProductProfileIdSchema>;
+export declare const ActionsSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    profile: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        desktop: "desktop";
+        web: "web";
+        framework: "framework";
+        api: "api";
+        org: "org";
+    }>>;
+    jobs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        on: z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+            push: "push";
+            pr: "pr";
+        }>, z.ZodObject<{
+            schedule: z.ZodString;
+        }, z.core.$strip>]>>;
+        if: z.ZodOptional<z.ZodString>;
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        needs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        environment: z.ZodOptional<z.ZodEnum<{
+            local: "local";
+            dev: "dev";
+            staging: "staging";
+            production: "production";
+        }>>;
+        runsOn: z.ZodDefault<z.ZodEnum<{
+            linux: "linux";
+            macos: "macos";
+            windows: "windows";
+        }>>;
+        arch: z.ZodOptional<z.ZodEnum<{
+            x64: "x64";
+            arm64: "arm64";
+        }>>;
+        runnerProfile: z.ZodDefault<z.ZodString>;
+        timeoutMinutes: z.ZodDefault<z.ZodNumber>;
+        steps: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            run: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            deploy: z.ZodPipe<z.ZodString, z.ZodString>;
+            environment: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            review: z.ZodString;
+            capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                code: "code";
+                visual: "visual";
+            }>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            publish: z.ZodString;
+            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            tag: z.ZodOptional<z.ZodString>;
+            releaseContractVersion: z.ZodOptional<z.ZodLiteral<2>>;
+        }, z.core.$strip>, z.ZodObject<{
+            runbook: z.ZodString;
+            input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>>;
+        }, z.core.$strip>]>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        artifacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        cache: z.ZodOptional<z.ZodObject<{
+            taskId: z.ZodString;
+            namespace: z.ZodOptional<z.ZodString>;
+            sensitivity: z.ZodOptional<z.ZodEnum<{
+                "public-reproducible": "public-reproducible";
+                "trusted-only": "trusted-only";
+            }>>;
+            keyFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type RunStep = z.infer<typeof RunStepSchema>;
+export type DeployStep = z.infer<typeof DeployStepSchema>;
+export type ReviewStep = z.infer<typeof ReviewStepSchema>;
+export type PublishStep = z.infer<typeof PublishStepSchema>;
+export type RunbookStep = z.infer<typeof RunbookStepSchema>;
+export type Step = z.infer<typeof StepSchema>;
+export type Trigger = z.infer<typeof TriggerSchema>;
+/** Authored job before schema defaults are materialized. */
+export type JobInput = z.input<typeof JobSchema>;
+/** Validated job with every schema default materialized. */
+export type Job = z.infer<typeof JobSchema>;
+export type ArtifactPath = z.infer<typeof ArtifactPathSchema>;
+export type ActionsInput = z.input<typeof ActionsSchema>;
+export type Actions = z.infer<typeof ActionsSchema>;
+/** Discriminators for authored step kinds. */
+export declare function isRunStep(step: Step): step is RunStep;
+export declare function isDeployStep(step: Step): step is DeployStep;
+export declare function isReviewStep(step: Step): step is ReviewStep;
+export declare function isPublishStep(step: Step): step is PublishStep;
+export declare function isRunbookStep(step: Step): step is RunbookStep;
+/**
+ * The executor a review job is planned on: the Forge control plane, which
+ * claims the attempt, requests the independent PR review and completes it.
+ * A review job never reaches a runner.
+ */
+export declare const FORGE_CONTROL_PLANE_REVIEW_EXECUTOR_ID = "forge-control-plane:review";
+/** A job made only of review steps: it runs on the control plane. */
+export declare function isReviewJob(job: {
+    steps: readonly Step[];
+}): boolean;
+/** A schedule trigger discriminator. */
+export declare function isScheduleTrigger(t: Trigger): t is z.infer<typeof ScheduleTriggerSchema>;
+export type ParseActionsResult = {
+    ok: true;
+    actions: Actions;
+} | {
+    ok: false;
+    error: string;
+    cause?: unknown;
+};
+/**
+ * Parse + validate a `.forge/actions.yml` document. Never throws: a YAML syntax
+ * error or a schema-validation failure is returned as `{ ok:false, error }` with
+ * a single human-readable message (so the engine can write it to a `forge/config`
+ * status-check). An empty / whitespace-only document is treated as a config
+ * error too (a present-but-empty pipeline file is almost always a mistake).
+ */
+export declare function parseActionsYml(source: string): ParseActionsResult;
+//# sourceMappingURL=actions.d.ts.map

package/dist/schemas/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/schemas/actions.ts"],"names":[],"mappings":"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"}