@moinulmoin/eden 0.1.0

package/dist/eve.d.ts

@@ -0,0 +1,49 @@
+export declare const EVE_CLI_COMMANDS: readonly ["preflight", "deploy", "destroy"];
+export type EveCliCommand = (typeof EVE_CLI_COMMANDS)[number];
+export type EveCliEnvironment = "preview" | "production";
+export interface EveCliInvocation {
+    readonly kind: "invocation";
+    readonly command: EveCliCommand;
+    readonly projectRoot: string;
+    readonly environment: EveCliEnvironment;
+    readonly name: string;
+    readonly envFile?: string;
+}
+export interface EveCliHelp {
+    readonly kind: "help";
+    readonly scope: EveCliCommand;
+}
+export type ParsedEveInvocation = EveCliHelp | EveCliInvocation;
+export interface EveCliExecutionRequest {
+    readonly command: EveCliCommand;
+    readonly cwd: string;
+    readonly projectRoot: string;
+    readonly environment: EveCliEnvironment;
+    readonly name: string;
+    /**
+     * The path is intentionally opaque at this boundary. The deployment-safety
+     * layer is the only owner allowed to open or parse its contents.
+     */
+    readonly envFile?: string;
+}
+export type EveCliRunner = (request: EveCliExecutionRequest) => void | Promise<void>;
+export interface EveCliDiagnostic {
+    readonly code: string;
+    readonly message: string;
+    readonly source?: string;
+}
+export declare class EveCliError extends Error {
+    readonly code: string;
+    readonly source: string | undefined;
+    readonly diagnostics: readonly EveCliDiagnostic[];
+    constructor(options: {
+        readonly code: string;
+        readonly message: string;
+        readonly source?: string;
+        readonly diagnostics?: readonly EveCliDiagnostic[];
+    });
+}
+export declare const EVE_USAGE = "Usage: eden <preflight|deploy|destroy> [options]\n\nEden Deploy commands:\n  preflight  Build and inspect a local Eve candidate without remote mutation\n  deploy     Deploy the selected Eve project to the exact named target\n  destroy    Remove the exact owned Eve target\n\nEvery Deploy command requires --project, --env, and --name.\n--env accepts only preview or production.\n--env-file is accepted only by preflight and deploy.\nEden Agent authoring remains available through the separate eden agent namespace.\n\nOptions:\n  --help  Show this help\n";
+export declare function eveHelpText(scope: EveCliHelp["scope"]): string;
+export declare function parseEveArguments(args: readonly string[]): ParsedEveInvocation;
+//# sourceMappingURL=eve.d.ts.map

package/dist/eve.js

@@ -0,0 +1,234 @@
+export const EVE_CLI_COMMANDS = [
+    "preflight",
+    "deploy",
+    "destroy",
+];
+export class EveCliError extends Error {
+    code;
+    source;
+    diagnostics;
+    constructor(options) {
+        super(options.message);
+        this.name = "EveCliError";
+        this.code = options.code;
+        this.source = options.source;
+        this.diagnostics = options.diagnostics ?? [];
+    }
+}
+const EVE_NAME_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u;
+export const EVE_USAGE = `Usage: eden <preflight|deploy|destroy> [options]
+
+Eden Deploy commands:
+  preflight  Build and inspect a local Eve candidate without remote mutation
+  deploy     Deploy the selected Eve project to the exact named target
+  destroy    Remove the exact owned Eve target
+
+Every Deploy command requires --project, --env, and --name.
+--env accepts only preview or production.
+--env-file is accepted only by preflight and deploy.
+Eden Agent authoring remains available through the separate eden agent namespace.
+
+Options:
+  --help  Show this help
+`;
+const EVE_COMMAND_USAGE = {
+    preflight: `Usage: eden preflight --project <path> --env <preview|production> --name <name> [--env-file <path>]
+
+Build and inspect an immutable local Eve candidate. Preflight is read-only toward remote resources.
+
+Options:
+  --project <path>     Required canonical Eve project root
+  --env <environment>  Required preview or production target
+  --name <name>        Required exact target name
+  --env-file <path>    Optional opaque runtime environment file
+  --help               Show this help
+`,
+    deploy: `Usage: eden deploy --project <path> --env <preview|production> --name <name> [--env-file <path>]
+
+Deploy the selected Eve project to one exact target after host checks pass.
+
+Options:
+  --project <path>     Required canonical Eve project root
+  --env <environment>  Required preview or production target
+  --name <name>        Required exact target name
+  --env-file <path>    Optional opaque runtime environment file
+  --help               Show this help
+`,
+    destroy: `Usage: eden destroy --project <path> --env <preview|production> --name <name>
+
+Destroy only the exact owned Eve target after ownership verification.
+
+Options:
+  --project <path>     Required canonical Eve project root
+  --env <environment>  Required preview or production target
+  --name <name>        Required exact target name
+  --help               Show this help
+`,
+};
+function eveError(code, message, source) {
+    return new EveCliError({
+        code,
+        message,
+        ...(source === undefined ? {} : { source }),
+    });
+}
+function parseOptionValue(args, index, option) {
+    const value = args[index + 1];
+    if (value === undefined ||
+        value.length === 0 ||
+        value.startsWith("-")) {
+        throw eveError("EVE_OPTION_VALUE_MISSING", `The ${option} option requires a value.`);
+    }
+    return { value, nextIndex: index + 1 };
+}
+function parseProjectValue(value) {
+    if (value.length === 0) {
+        throw eveError("EVE_PROJECT_INVALID", "The --project option requires a non-empty path.");
+    }
+    return value;
+}
+function parseEnvironmentValue(value) {
+    if (value === "preview" || value === "production")
+        return value;
+    throw eveError("EVE_ENV_INVALID", "The --env option must be preview or production.");
+}
+function parseNameValue(value) {
+    if (!EVE_NAME_PATTERN.test(value)) {
+        throw eveError("EVE_NAME_INVALID", "The --name option must be a lowercase alphanumeric target name with optional dashes.");
+    }
+    return value;
+}
+function parseEnvFileValue(value) {
+    if (value.length === 0) {
+        throw eveError("EVE_ENV_FILE_INVALID", "The --env-file option requires a non-empty path.");
+    }
+    return value;
+}
+function parseCommand(value) {
+    if (value === "preflight" ||
+        value === "deploy" ||
+        value === "destroy") {
+        return value;
+    }
+    throw eveError("EVE_COMMAND_UNKNOWN", `Unknown Eve command "${value ?? ""}".`);
+}
+export function eveHelpText(scope) {
+    return EVE_COMMAND_USAGE[scope].trimEnd();
+}
+export function parseEveArguments(args) {
+    const command = parseCommand(args[0]);
+    if (args.length === 2 &&
+        (args[1] === "--help" || args[1] === "-h")) {
+        return { kind: "help", scope: command };
+    }
+    let projectRoot;
+    let environment;
+    let name;
+    let envFile;
+    let help = false;
+    for (let index = 1; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument === undefined) {
+            throw eveError("EVE_ARGUMENT_UNKNOWN", "The Eve command contains an invalid argument.");
+        }
+        if (argument === "--help" || argument === "-h") {
+            help = true;
+            continue;
+        }
+        if (argument === "--project") {
+            if (projectRoot !== undefined) {
+                throw eveError("EVE_PROJECT_REPEATED", "The --project option may be supplied only once.");
+            }
+            const parsed = parseOptionValue(args, index, "--project");
+            projectRoot = parseProjectValue(parsed.value);
+            index = parsed.nextIndex;
+            continue;
+        }
+        if (argument.startsWith("--project=")) {
+            if (projectRoot !== undefined) {
+                throw eveError("EVE_PROJECT_REPEATED", "The --project option may be supplied only once.");
+            }
+            projectRoot = parseProjectValue(argument.slice("--project=".length));
+            continue;
+        }
+        if (argument === "--env") {
+            if (environment !== undefined) {
+                throw eveError("EVE_ENV_REPEATED", "The --env option may be supplied only once.");
+            }
+            const parsed = parseOptionValue(args, index, "--env");
+            environment = parseEnvironmentValue(parsed.value);
+            index = parsed.nextIndex;
+            continue;
+        }
+        if (argument.startsWith("--env=")) {
+            if (environment !== undefined) {
+                throw eveError("EVE_ENV_REPEATED", "The --env option may be supplied only once.");
+            }
+            environment = parseEnvironmentValue(argument.slice("--env=".length));
+            continue;
+        }
+        if (argument === "--name") {
+            if (name !== undefined) {
+                throw eveError("EVE_NAME_REPEATED", "The --name option may be supplied only once.");
+            }
+            const parsed = parseOptionValue(args, index, "--name");
+            name = parseNameValue(parsed.value);
+            index = parsed.nextIndex;
+            continue;
+        }
+        if (argument.startsWith("--name=")) {
+            if (name !== undefined) {
+                throw eveError("EVE_NAME_REPEATED", "The --name option may be supplied only once.");
+            }
+            name = parseNameValue(argument.slice("--name=".length));
+            continue;
+        }
+        if (argument === "--env-file") {
+            if (command === "destroy") {
+                throw eveError("EVE_ENV_FILE_UNSUPPORTED", "The --env-file option is supported only by eden preflight and eden deploy.");
+            }
+            if (envFile !== undefined) {
+                throw eveError("EVE_ENV_FILE_REPEATED", "The --env-file option may be supplied only once.");
+            }
+            const parsed = parseOptionValue(args, index, "--env-file");
+            envFile = parseEnvFileValue(parsed.value);
+            index = parsed.nextIndex;
+            continue;
+        }
+        if (argument.startsWith("--env-file=")) {
+            if (command === "destroy") {
+                throw eveError("EVE_ENV_FILE_UNSUPPORTED", "The --env-file option is supported only by eden preflight and eden deploy.");
+            }
+            if (envFile !== undefined) {
+                throw eveError("EVE_ENV_FILE_REPEATED", "The --env-file option may be supplied only once.");
+            }
+            envFile = parseEnvFileValue(argument.slice("--env-file=".length));
+            continue;
+        }
+        if (argument.startsWith("-")) {
+            throw eveError("EVE_OPTION_UNKNOWN", "The Eve command contains an unknown option.");
+        }
+        throw eveError("EVE_ARGUMENT_UNKNOWN", "The Eve command does not accept positional arguments.");
+    }
+    if (help) {
+        return { kind: "help", scope: command };
+    }
+    if (projectRoot === undefined) {
+        throw eveError("EVE_PROJECT_REQUIRED", "The --project option is required for every Eve command.");
+    }
+    if (environment === undefined) {
+        throw eveError("EVE_ENV_REQUIRED", "The --env option is required for every Eve command.");
+    }
+    if (name === undefined) {
+        throw eveError("EVE_NAME_REQUIRED", "The --name option is required for every Eve command.");
+    }
+    return {
+        kind: "invocation",
+        command,
+        projectRoot,
+        environment,
+        name,
+        ...(envFile === undefined ? {} : { envFile }),
+    };
+}
+//# sourceMappingURL=eve.js.map

package/dist/index.d.ts

@@ -0,0 +1,196 @@
+#!/usr/bin/env -S node --
+import type { EdenCompilerResult } from "@moinulmoin/eden-compiler";
+import { type EveCliExecutionRequest } from "./eve.js";
+import { type EvePreflightOptions } from "./eve-control-plane.js";
+export { EVE_CLI_COMMANDS, EVE_USAGE, EveCliError, eveHelpText, parseEveArguments, } from "./eve.js";
+export { EvePackagingError, buildEveProjectSnapshot, createDockerEveProjectBuilder, revalidateEveProjectCandidateInputs, } from "./eve-packaging.js";
+export { EVE_RESERVED_HOST_VARIABLES, EVE_START_COMMAND, EveRuntimeConfig, EveRuntimeConfigError, loadEveRuntimeConfig, parseEveRuntimeConfig, prepareEveRuntimeInjection, readEveRuntimeConfig, redactEveRuntimeOutput, } from "./eve-runtime-config.js";
+export type { EveReservedHostVariable, EveRuntimeConfigErrorCode, EveRuntimeInjection, EveRuntimeInjectionMode, EveRuntimeInjectionOptions, EveRuntimeInputIdentity, EveRuntimeProtectedPutRequest, EveRuntimeProtectedPutResult, EveRuntimeProtectedStore, EveStartProcessRequest, RedactedRuntimeConfigSeam, } from "./eve-runtime-config.js";
+export { buildEveRuntimeImage, revalidateEveRuntimeCandidate, validateEveHostRequirements, } from "./eve-runtime-image.js";
+export type { EveCliCommand, EveCliEnvironment, EveCliExecutionRequest, EveCliHelp, EveCliInvocation, EveCliRunner, ParsedEveInvocation, } from "./eve.js";
+export type { EveNodeImage, EvePackagingCheck, EvePackagingCode, EveProjectBuilder, EveProjectBuilderRequest, EveProjectBuilderResult, EveProjectBuildCandidate, EveProjectFile, EveProjectImage, EveProjectInputManifest, EveProjectOutput, EveProjectPackagingResult, EveProjectRuntime, EveProjectSnapshot, EveProjectSnapshotOptions, EveProjectToolchain, EveRuntimeConfigExclusion, } from "./eve-packaging.js";
+export type { EveHostRequirements, EveRuntimeClosure, EveRuntimeClosureFile, EveRuntimeCleanup, EveRuntimeImage, EveRuntimeImageMetadata, EveRuntimeImageRequest, EveRuntimeImageResult, EveRuntimeNativeModule, EveRuntimeStatus, } from "./eve-runtime-image.js";
+export { DEFAULT_EVE_HOST_REQUIREMENTS, DEFAULT_EVE_NODE_IMAGE, runEveControlPlane, runEveDestroy, } from "./eve-control-plane.js";
+export type { EveCloudflareReadRequest, EveCloudflareReadResult, EveCloudflareReadRunner, EveCloudflareTargetState, EveContainerDeleteRunner, EveDeploymentCompensationRequest, EveDeploymentCompensationRunner, EveDeploymentHealthRequest, EveDeploymentHealthResult, EveDeploymentHealthRunner, EveDeploymentIdentity, EveDeploymentIdentityProof, EveDeploymentMetadata, EveDeploymentPublicationRequest, EveDeploymentPublicationResult, EveDeploymentPublicationRunner, EveDeploymentStatus, EveDestroyCloudflareReadRequest, EveDestroyCloudflareReadRunner, EveDestroyOutcome, EveDestroyTargetRead, EveImagePublicationRequest, EveImagePublicationResult, EveImagePublicationRunner, EvePreflightCandidate, EvePreflightCheck, EvePreflightCheckStatus, EvePreflightOptions, EvePreflightResult, EvePreflightRuntimeEvidence, EvePreflightRuntimeRunner, EvePreflightRuntimeRunnerRequest, EveRuntimeConfigLoader, EveWorkerDeleteRunner, } from "./eve-control-plane.js";
+export declare const EDEN_CLI_COMMANDS: readonly ["preflight", "deploy", "destroy", "agent"];
+export type EdenCliCommand = (typeof EDEN_CLI_COMMANDS)[number];
+export declare const EDEN_AGENT_COMMANDS: readonly ["init", "dev", "build", "deploy"];
+export type EdenAgentCommand = (typeof EDEN_AGENT_COMMANDS)[number];
+export declare const EDEN_LOCAL_HOST: "127.0.0.1";
+export declare const EDEN_LOCAL_PORT: 8797;
+export declare const EDEN_LOCAL_INSPECTOR_HOST: "127.0.0.1";
+export declare const EDEN_LOCAL_INSPECTOR_PORT: 9297;
+export interface EdenCliDryRunRequest {
+    readonly cwd: string;
+    readonly configPath: string;
+    readonly originalConfigPath: string;
+    readonly args: readonly string[];
+}
+export interface EdenCliDryRunResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface EdenCliDryRunHandle {
+    readonly process: EdenCliProcess;
+    readonly result: Promise<EdenCliDryRunResult>;
+}
+export type EdenCliRemoteCommandKind = "secret-put" | "secret-delete" | "deploy" | "delete";
+export interface EdenCliRemoteCommandRequest {
+    readonly kind: EdenCliRemoteCommandKind;
+    readonly cwd: string;
+    readonly args: readonly string[];
+    readonly stdin?: string;
+}
+export interface EdenCliRemoteCommandResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface EdenCliRemoteCommandHandle {
+    readonly process: EdenCliProcess;
+    readonly result: Promise<EdenCliRemoteCommandResult>;
+}
+export type EdenCliRemoteCommandReturn = EdenCliRemoteCommandResult | EdenCliRemoteCommandHandle | Promise<EdenCliRemoteCommandResult | EdenCliRemoteCommandHandle>;
+export interface EdenCliRemoteValidationRequest {
+    readonly cwd: string;
+    readonly environment: "preview" | "production";
+    readonly workerName: string;
+    readonly url: string;
+    readonly expectedGeneration: {
+        readonly generationId: string;
+        readonly bundleDigest: string;
+        readonly manifestVersion: string;
+        readonly runtimeVersion: string;
+        readonly agentBundleVersion: string;
+        readonly protocolVersion: string;
+        readonly schemaVersion: number;
+        readonly toolNames: readonly string[];
+    };
+}
+export interface EdenCliRemoteValidationResult {
+    readonly ok: boolean;
+    readonly code?: string;
+    readonly message?: string;
+}
+export interface EdenCliProcessRequest {
+    readonly command: string;
+    /**
+     * Arguments needed to invoke the executable directly. The package shim is a
+     * shell script on POSIX and discards custom argv0 markers, so the default
+     * runner supplies the real Node entrypoint here.
+     */
+    readonly commandArgs?: readonly string[];
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly processIdentity?: string;
+    readonly readiness?: readonly {
+        readonly host: string;
+        readonly port: number;
+    }[];
+}
+export type EdenCliProcessIdentity = {
+    readonly marker: string;
+    readonly pid: number;
+    readonly pgid: number;
+    readonly lstart: string;
+};
+export interface EdenCliProcessExit {
+    readonly exitCode: number | null;
+    readonly signal: NodeJS.Signals | null;
+}
+export interface EdenCliProcess {
+    readonly pid: number;
+    /**
+     * A process-start identity captured by the process runner immediately after
+     * spawn. PID alone is never sufficient to authorize cleanup.
+     */
+    readonly identity?: EdenCliProcessIdentity | Promise<EdenCliProcessIdentity | undefined>;
+    readonly startIdentity?: string | Promise<string | undefined>;
+    readonly exited: Promise<EdenCliProcessExit>;
+    readonly ready?: Promise<void>;
+    terminate(signal?: NodeJS.Signals): Promise<void>;
+}
+export interface EdenCliProcessRunner {
+    spawn(request: EdenCliProcessRequest): EdenCliProcess;
+}
+export interface EdenCliBuildProjectRequest {
+    readonly projectRoot: string;
+    readonly outputDirectory: string;
+}
+export type EdenCliBuildProjectRunner = (request: EdenCliBuildProjectRequest) => Promise<EdenCompilerResult>;
+export interface EdenCliRuntimeGeneration {
+    readonly generationId: string;
+    readonly bundleDigest: string;
+    readonly manifestVersion: string;
+    readonly runtimeVersion: string;
+    readonly agentBundleVersion: string;
+    readonly protocolVersion: string;
+    readonly schemaVersion: number;
+    readonly toolNames: readonly string[];
+}
+export interface EdenCliRuntimeGenerationProofRequest {
+    readonly process: EdenCliProcess | undefined;
+    readonly generation: EdenCliRuntimeGeneration;
+    readonly signal: AbortSignal;
+}
+export type EdenCliRuntimeGenerationProof = "authenticated-fetch" | ((request: EdenCliRuntimeGenerationProofRequest) => boolean | Promise<boolean>);
+export type EdenRuntimePublicationBoundary = "before-runtime-entry-publish" | "after-runtime-entry-publish" | "before-runtime-config-publish" | "after-runtime-config-publish" | "after-runtime-ready" | "before-runtime-rollback" | "after-runtime-rollback";
+export type EdenDeploymentBoundary = "before-compatibility-dry-run" | "before-remote-runner-invocation" | "after-remote-runner-preflight" | "after-remote-final-read" | "after-compatibility-dry-run" | "before-secret-provision" | "after-secret-provision" | "before-deploy" | "after-deploy" | "before-remote-validation" | "after-remote-validation";
+export interface EdenCliRunOptions {
+    readonly cwd?: string;
+    readonly stdout?: (line: string) => void;
+    readonly stderr?: (line: string) => void;
+    /**
+     * Eve execution is a separate control-plane seam. Agent runners never
+     * receive an Eve invocation, and the default path fails closed.
+     */
+    readonly eveRunner?: (request: EveCliExecutionRequest) => void | Promise<void>;
+    /**
+     * Finite local control-plane seams for the built-in Eve preflight path.
+     * Runtime values and remote-provider mutations never cross this boundary.
+     */
+    readonly eveControlPlane?: EvePreflightOptions;
+    readonly initPublicationHook?: (boundary: EdenInitPublicationBoundary, target?: string) => void | Promise<void>;
+    readonly buildPublicationHook?: (boundary: EdenBuildPublicationBoundary) => void | Promise<void>;
+    readonly dryRunRunner?: (request: EdenCliDryRunRequest) => EdenCliDryRunResult | EdenCliDryRunHandle | Promise<EdenCliDryRunResult>;
+    readonly processRunner?: EdenCliProcessRunner;
+    /**
+     * Internal finite-test override for the compiler invocation. The returned
+     * promise is still owned by the same cancellation/quiescence barrier as the
+     * production compiler call.
+     */
+    readonly buildProjectRunner?: EdenCliBuildProjectRunner;
+    /**
+     * Internal finite-test override for the authenticated local runtime
+     * readiness probe. Production callers use the bounded default.
+     */
+    readonly runtimeReadinessTimeoutMs?: number;
+    /**
+     * Internal lifecycle injection for finite callers that need to stop dev
+     * without emitting a process-global signal.
+     */
+    readonly stopSignal?: AbortSignal;
+    /**
+     * An injected process runner must provide this explicit proof seam. The
+     * string selects Eden's bearer-authenticated /eden/v1/info probe; a callback
+     * may provide an equivalent authenticated proof for a finite fixture.
+     */
+    readonly runtimeGenerationProof?: EdenCliRuntimeGenerationProof;
+    readonly runtimePublicationHook?: (boundary: EdenRuntimePublicationBoundary) => void | Promise<void>;
+    readonly deploymentBoundaryHook?: (boundary: EdenDeploymentBoundary) => void | Promise<void>;
+    readonly remoteCommandRunner?: (request: EdenCliRemoteCommandRequest) => EdenCliRemoteCommandReturn;
+    readonly remoteValidationRunner?: (request: EdenCliRemoteValidationRequest) => Promise<EdenCliRemoteValidationResult>;
+    readonly remoteBearerSecret?: string;
+}
+export type EdenInitPublicationBoundary = "after-lock-acquire" | "after-state-write" | "after-stage-write" | "after-target-validation" | "after-init-link" | "before-init-destination-recheck" | "before-init-cleanup" | "after-init-cleanup-observation" | "after-init-cleanup" | "before-init-link" | "before-target-publish" | "after-target-publish" | "before-complete";
+export type EdenBuildPublicationBoundary = "before-canonical-prepare" | "after-canonical-prepare" | "before-generation-publish" | "after-generation-publish" | "before-current-promotion" | "after-current-promotion";
+export declare function stopEdenDev(options?: {
+    readonly cwd?: string;
+    readonly projectRoot?: string;
+}): Promise<number>;
+export declare function runEdenCli(args: readonly string[], options?: EdenCliRunOptions): Promise<number>;
+export declare function main(args?: readonly string[]): Promise<number>;
+export declare function isEdenCliCommand(value: string): value is EdenCliCommand;
+//# sourceMappingURL=index.d.ts.map