anhedral 0.10.1 → 0.11.0

package/dist/delivery.js

@@ -69,7 +69,7 @@ function history(root, project) {
         throw new Error('Release history belongs to a different or unsupported project.');
     return value;
 }
-function checkTargets(root, project) {
+function checkTargets(root, project, allowResourcePlaceholders = false) {
     if (!project.targets.length)
         throw new Error('No Cloudflare targets; native applications require their platform delivery tools.');
     for (const target of project.targets) {
@@ -80,7 +80,24 @@ function checkTargets(root, project) {
             throw new Error('Worker name or environment changed; reconcile the application manifest before shipping.');
         if (config.account_id && config.account_id !== project.accountId)
             throw new Error('Wrangler configuration account conflicts with the registered account.');
-        if (/REPLACE_WITH_|YOUR_[A-Z_]+/.test(readFileSync(path.join(directory, 'wrangler.jsonc'), 'utf8')))
+        const pending = structuredClone(config);
+        if (allowResourcePlaceholders) {
+            for (const [field, id] of [
+                ['d1_databases', 'database_id'],
+                ['kv_namespaces', 'id'],
+                ['pipelines', 'stream'],
+            ]) {
+                const entries = pending[field];
+                if (Array.isArray(entries))
+                    for (const entry of entries) {
+                        if (entry && typeof entry[id] === 'string' && entry[id].startsWith('REPLACE_WITH_'))
+                            entry[id] = 'pending-resource';
+                    }
+            }
+        }
+        if (/REPLACE_WITH_|YOUR_[A-Z_]+/.test(allowResourcePlaceholders
+            ? JSON.stringify(pending)
+            : readFileSync(path.join(directory, 'wrangler.jsonc'), 'utf8')))
             throw new Error('Configure selected resources before shipping; placeholder bindings remain.');
         const pkg = JSON.parse(readFileSync(path.join(directory, 'package.json'), 'utf8'));
         if (typeof pkg.scripts?.deploy !== 'string')
@@ -93,9 +110,9 @@ function configurationFingerprint(root, project) {
         hash.update(readFileSync(path.join(targetDirectory(root, target), 'wrangler.jsonc')));
     return hash.digest('hex');
 }
-export function planDelivery(root) {
+export function planDelivery(root, allowResourcePlaceholders = false) {
     const project = readApplication(root);
-    checkTargets(root, project);
+    checkTargets(root, project, allowResourcePlaceholders);
     return {
         project,
         checks: [['pnpm', 'run', 'check']],

package/dist/index.d.ts

@@ -10,7 +10,6 @@ export { planProvisioning, provisionApplication } from './provision.js';
 export { registerVercelApplication, connectVercelApplication, planVercelDelivery, shipVercelApplication, vercelApplicationStatus, verifyVercelApplication, rollbackVercelApplication, adoptVercelApplication, recoverVercelApplication, } from './vercel.js';
 export { setupRepository, githubRepository } from './repository.js';
 export { inspectProviderReadiness } from './provider-readiness.js';
-export { registerManagedApplication, stageManagedVersion, saveManagedVersion, deployManagedVersion, managedApplicationStatus, } from './managed-hosting.js';
 export { STACK_REGISTRY, STACK_ITEMS, getStackItem } from './stack-registry.js';
 export type { StackItemId } from './stack-registry.js';
 export type { StackRegistryItem } from './registry/types.js';
@@ -19,3 +18,26 @@ export { resolveStackRegistry } from './registry/resolve.js';
 export type { ResolvedStackRegistry } from './registry/resolve.js';
 export { addStackItems } from './registry/add.js';
 export type { AddRequest } from './registry/add.js';
+export { PROVIDER_AUTH, requiredProviders, authenticateProviders } from './provider-auth.js';
+export type { ProviderAuth, AuthOptions, AuthCheck } from './provider-auth.js';
+export { buildMobileApplication } from './mobile-delivery.js';
+export type { MobileBuildOptions } from './mobile-delivery.js';
+export { shipCloudflareApplication } from './ship.js';
+export { shipSelectedStack, shipSelectedVercelApplication } from './ship.js';
+export { planProviderProvisioning, provisionSelectedProviders } from './providers/provision.js';
+export { providerConfigurationTemplate } from './providers/config.js';
+export type { ProviderConfiguration, IntegrationProvider } from './providers/config.js';
+export { validateProviderConfiguration } from './providers/config.js';
+export { PROVIDER_CONFIGURATION_SCHEMA } from './providers/schema.js';
+export { PROVIDER_DEFINITIONS } from './providers/definitions.js';
+export type { ProviderSettingsById } from './providers/definitions.js';
+export { applicationRuntime } from './providers/runtime.js';
+export { readLifecycleOperation } from './lifecycle.js';
+export type { LifecycleOperation, OperationState, PhaseState } from './lifecycle.js';
+export { integrationStatus, recoverIntegrationResource } from './providers/recovery.js';
+export type { IntegrationRecoveryRequest } from './providers/recovery.js';
+export { CAPABILITY_CONTRACT, formatCapabilityContract } from './capability-contract.js';
+export type { CapabilitySupport, CapabilityEvidence, CapabilityStage, ProductCapability, } from './capability-contract.js';
+export { recoverDeliveryLock } from './project-state.js';
+export { inspectApplication } from './project-inspector.js';
+export type { ProjectInspection } from './inspector-model.js';

package/dist/index.js

@@ -7,8 +7,22 @@ export { planProvisioning, provisionApplication } from './provision.js';
 export { registerVercelApplication, connectVercelApplication, planVercelDelivery, shipVercelApplication, vercelApplicationStatus, verifyVercelApplication, rollbackVercelApplication, adoptVercelApplication, recoverVercelApplication, } from './vercel.js';
 export { setupRepository, githubRepository } from './repository.js';
 export { inspectProviderReadiness } from './provider-readiness.js';
-export { registerManagedApplication, stageManagedVersion, saveManagedVersion, deployManagedVersion, managedApplicationStatus, } from './managed-hosting.js';
 export { STACK_REGISTRY, STACK_ITEMS, getStackItem } from './stack-registry.js';
 export { inspectWorkspaceGraph } from './workspace-graph.js';
 export { resolveStackRegistry } from './registry/resolve.js';
 export { addStackItems } from './registry/add.js';
+export { PROVIDER_AUTH, requiredProviders, authenticateProviders } from './provider-auth.js';
+export { buildMobileApplication } from './mobile-delivery.js';
+export { shipCloudflareApplication } from './ship.js';
+export { shipSelectedStack, shipSelectedVercelApplication } from './ship.js';
+export { planProviderProvisioning, provisionSelectedProviders } from './providers/provision.js';
+export { providerConfigurationTemplate } from './providers/config.js';
+export { validateProviderConfiguration } from './providers/config.js';
+export { PROVIDER_CONFIGURATION_SCHEMA } from './providers/schema.js';
+export { PROVIDER_DEFINITIONS } from './providers/definitions.js';
+export { applicationRuntime } from './providers/runtime.js';
+export { readLifecycleOperation } from './lifecycle.js';
+export { integrationStatus, recoverIntegrationResource } from './providers/recovery.js';
+export { CAPABILITY_CONTRACT, formatCapabilityContract } from './capability-contract.js';
+export { recoverDeliveryLock } from './project-state.js';
+export { inspectApplication } from './project-inspector.js';

package/dist/inspector-model.d.ts

@@ -0,0 +1,115 @@
+import type { LifecycleOperation } from './lifecycle-model.js';
+export interface InspectionSection<T> {
+    state: 'available' | 'unavailable';
+    data: T;
+    error?: string;
+}
+export type DependencyField = 'dependencies' | 'devDependencies' | 'peerDependencies' | 'optionalDependencies';
+export interface WorkspaceEvidence {
+    name: string;
+    directory: string;
+    dependencies: {
+        name: string;
+        kind: DependencyField;
+    }[];
+}
+export interface BindingEvidence {
+    application: string;
+    name: string;
+    kind: string;
+    configured: boolean;
+    identifierRequired: boolean;
+    resourceId: string | null;
+}
+export interface ReleaseEvidence {
+    id: string;
+    state: string;
+    commit: string;
+    recordedAt: string | null;
+    url: string | null;
+    kind: 'deployment' | 'build';
+    operationState?: string;
+    platform?: string;
+    profile?: string;
+    artifact?: string;
+}
+export interface TargetEvidence {
+    id: string;
+    provider: 'cloudflare' | 'vercel' | 'expo' | 'desktop' | 'extension';
+    application: string;
+    audience: 'public' | 'private' | 'unconfigured' | 'not-applicable';
+    accountReference: string | null;
+    latestAttempt: ReleaseEvidence | null;
+    lastSuccessful: ReleaseEvidence | null;
+    delivery: 'implemented' | 'artifact-only' | 'scaffold-only';
+    liveStatus: 'unknown';
+    error?: string;
+}
+export interface IntegrationEvidence {
+    provider: string;
+    operations: {
+        operation: string;
+        status: 'pending' | 'complete';
+        resources: Record<string, string>;
+        recovery: string;
+        kind: string | null;
+    }[];
+}
+export interface ResourceEvidence {
+    kind: string;
+    name: string;
+    id: string;
+    reused: boolean | null;
+    recordedAt: string | null;
+}
+/** Browser-safe projection. Read time never substitutes for provider evidence time. */
+export interface ProjectInspection {
+    schemaVersion: 1;
+    name: string;
+    inspectedAt: string;
+    authentication: {
+        state: 'not-checked';
+    };
+    liveStatus: {
+        state: 'unknown';
+    };
+    limits: string[];
+    selection: InspectionSection<{
+        cliVersion: string | null;
+        products: string[];
+        hosting: 'cloudflare' | 'vercel' | null;
+    }>;
+    setupProviders: InspectionSection<{
+        id: string;
+        managementCredential: string | null;
+        ownerSteps: string[];
+        authentication: 'not-checked';
+        permissions: 'unknown';
+        billing: 'unknown';
+    }[]>;
+    workspaces: InspectionSection<WorkspaceEvidence[]>;
+    configuration: InspectionSection<{
+        bindings: BindingEvidence[];
+        schedules: {
+            application: string;
+            expression: string;
+        }[];
+        environment: {
+            application: string;
+            name: string;
+        }[];
+    }>;
+    targets: InspectionSection<TargetEvidence[]>;
+    integrations: InspectionSection<IntegrationEvidence[]>;
+    cloudflareResources: InspectionSection<ResourceEvidence[]>;
+    readiness: InspectionSection<{
+        localReady: boolean;
+        checks: {
+            id: string;
+            ok: boolean;
+            detail: string;
+        }[];
+    }>;
+    operation: InspectionSection<LifecycleOperation | null>;
+}
+export type ApplicationInspection = ProjectInspection;

package/dist/inspector-model.js

@@ -0,0 +1 @@
+export {};

package/dist/lifecycle-model.d.ts

@@ -0,0 +1,15 @@
+export type OperationState = 'running' | 'blocked' | 'completed' | 'failed';
+export type PhaseState = 'running' | 'completed' | 'failed';
+export interface LifecycleOperation {
+    schemaVersion: 1;
+    id: string;
+    target: 'cloudflare' | 'vercel' | 'mixed' | 'mobile';
+    state: OperationState;
+    startedAt: string;
+    updatedAt: string;
+    phases: {
+        name: string;
+        state: PhaseState;
+    }[];
+}
+export declare function isLifecycleOperation(value: unknown): value is LifecycleOperation;

package/dist/lifecycle-model.js

@@ -0,0 +1,20 @@
+export function isLifecycleOperation(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const operation = value;
+    return (operation.schemaVersion === 1 &&
+        typeof operation.id === 'string' &&
+        /^[a-f0-9-]{36}$/.test(operation.id) &&
+        ['cloudflare', 'vercel', 'mixed', 'mobile'].includes(operation.target) &&
+        ['running', 'blocked', 'completed', 'failed'].includes(operation.state) &&
+        [operation.startedAt, operation.updatedAt].every((date) => typeof date === 'string' && Number.isFinite(Date.parse(date))) &&
+        Array.isArray(operation.phases) &&
+        operation.phases.length <= 100 &&
+        operation.phases.every((phase) => phase &&
+            typeof phase.name === 'string' &&
+            /^[a-z][a-z-]{0,63}$/.test(phase.name) &&
+            ['running', 'completed', 'failed'].includes(phase.state)) &&
+        new Set(operation.phases.map((phase) => phase.name)).size === operation.phases.length &&
+        Object.keys(operation).every((key) => ['schemaVersion', 'id', 'target', 'state', 'startedAt', 'updatedAt', 'phases'].includes(key)) &&
+        operation.phases.every((phase) => Object.keys(phase).every((key) => ['name', 'state'].includes(key))));
+}

package/dist/lifecycle.d.ts

@@ -0,0 +1,12 @@
+import { type DeliveryRunner } from './project-state.js';
+import { type LifecycleOperation } from './lifecycle-model.js';
+export type { LifecycleOperation, OperationState, PhaseState } from './lifecycle-model.js';
+export { isLifecycleOperation } from './lifecycle-model.js';
+export interface LifecycleSession {
+    phase<T>(name: string, action: () => Promise<T>): Promise<T>;
+}
+/** A nonsecret record of execution; a completed phase is not product acceptance. */
+export declare function readLifecycleOperation(root: string): LifecycleOperation | null;
+export declare function withLifecycleOperation<T>(root: string, target: LifecycleOperation['target'], run: DeliveryRunner, action: (session: LifecycleSession) => Promise<T>): Promise<T & {
+    operation: LifecycleOperation;
+}>;

package/dist/lifecycle.js

@@ -0,0 +1,92 @@
+import path from 'node:path';
+import { existsSync, lstatSync, realpathSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { readBoundedFile, MAX_PROJECT_JSON_BYTES } from './bounded-file.js';
+import { atomicJson, withApplicationLock } from './project-state.js';
+import { isLifecycleOperation } from './lifecycle-model.js';
+export { isLifecycleOperation } from './lifecycle-model.js';
+/** A nonsecret record of execution; a completed phase is not product acceptance. */
+export function readLifecycleOperation(root) {
+    root = realpathSync(root);
+    const file = path.join(root, '.anhedral/operation.json');
+    if (!existsSync(file))
+        return null;
+    if (realpathSync(path.dirname(file)) !== path.join(root, '.anhedral') ||
+        lstatSync(file).isSymbolicLink())
+        throw new Error('Invalid lifecycle state location.');
+    let value;
+    try {
+        value = JSON.parse(readBoundedFile(file, MAX_PROJECT_JSON_BYTES).toString('utf8'));
+    }
+    catch {
+        throw new Error('Invalid lifecycle state.');
+    }
+    if (!isLifecycleOperation(value))
+        throw new Error('Invalid lifecycle state.');
+    return value;
+}
+export async function withLifecycleOperation(root, target, run, action) {
+    root = realpathSync(root);
+    const env = { ...process.env, CI: '1', NO_COLOR: '1' };
+    const relative = '.anhedral/operation.json';
+    if ((await run('git', ['ls-files', '--', relative], root, env)).trim() ||
+        (await run('git', ['check-ignore', '--no-index', '--', relative], root, env)).trim() !==
+            relative)
+        throw new Error('Ignore .anhedral/ before recording a shipping operation.');
+    return withApplicationLock(root, async () => {
+        readLifecycleOperation(root);
+        const now = new Date().toISOString();
+        const operation = {
+            schemaVersion: 1,
+            id: randomUUID(),
+            target,
+            state: 'running',
+            startedAt: now,
+            updatedAt: now,
+            phases: [],
+        };
+        const save = () => {
+            operation.updatedAt = new Date().toISOString();
+            atomicJson(path.join(root, relative), operation);
+        };
+        save();
+        const session = {
+            async phase(name, task) {
+                if (!/^[a-z][a-z-]{0,63}$/.test(name) ||
+                    operation.phases.some((phase) => phase.name === name) ||
+                    operation.phases.length >= 100)
+                    throw new Error('Invalid or duplicate lifecycle phase.');
+                const phase = { name, state: 'running' };
+                operation.phases.push(phase);
+                save();
+                try {
+                    const result = await task();
+                    phase.state = 'completed';
+                    save();
+                    return result;
+                }
+                catch (error) {
+                    phase.state = 'failed';
+                    save();
+                    throw error;
+                }
+            },
+        };
+        try {
+            const result = await action(session);
+            const state = result && typeof result === 'object' && 'state' in result ? result.state : undefined;
+            operation.state = ['partial', 'failed'].includes(String(state))
+                ? 'failed'
+                : ['configuration-required', 'provider-configuration-required', 'building'].includes(String(state))
+                    ? 'blocked'
+                    : 'completed';
+            save();
+            return Object.assign({}, result, { operation });
+        }
+        catch (error) {
+            operation.state = 'failed';
+            save();
+            throw error;
+        }
+    });
+}

package/dist/mobile-delivery.d.ts

@@ -0,0 +1,100 @@
+import { type DeliveryRunner } from './project-state.js';
+export interface MobileBuildOptions {
+    platform: 'ios' | 'android';
+    profile: string;
+    dryRun?: boolean;
+}
+/** EAS builds produce artifacts; store submission is a separate user action. */
+export declare function buildMobileApplication(root: string, options: MobileBuildOptions, run?: DeliveryRunner): Promise<{
+    commit: string;
+    platform: "android" | "ios";
+    profile: string;
+    buildId: any;
+    downloadUrl: string;
+    state: string;
+    storeSubmission: boolean;
+    artifact: string;
+    buildPageUrl?: string | undefined;
+    schemaVersion: number;
+    projectId: string;
+    owner: any;
+    slug: any;
+    recordedAt: string;
+} | {
+    platform: "android" | "ios";
+    profile: string;
+    command: string[];
+    mutation: boolean;
+    storeSubmission: boolean;
+    integrations: {
+        schemaVersion: number;
+        providers: {
+            provider: keyof import("./index.js").ProviderSettingsById;
+            settings: import("./providers/definitions.js").NeonSettings | import("./providers/definitions.js").ClerkSettings | import("./providers/definitions.js").ResendSettings | import("./providers/definitions.js").StripeSettings | import("./providers/definitions.js").RevenueCatSettings | import("./providers/definitions.js").SentrySettings | import("./providers/definitions.js").PostHogSettings | import("./providers/definitions.js").OpenAISettings;
+            credential: string;
+            missing: string[];
+        }[];
+        configured: boolean;
+        mutation: boolean;
+    };
+    state?: undefined;
+    deployed?: undefined;
+    nextAction?: undefined;
+    schemaVersion?: undefined;
+    buildId?: undefined;
+    buildPageUrl?: undefined;
+    commit?: undefined;
+} | {
+    state: string;
+    deployed: boolean;
+    integrations: {
+        schemaVersion: number;
+        results: {
+            provider: string;
+            resources: Record<string, string>;
+            ready: boolean;
+            nextActions: string[];
+        }[];
+        ready: boolean;
+        configuredFiles: string[];
+        mutation: boolean;
+    };
+    storeSubmission: boolean;
+    platform?: undefined;
+    profile?: undefined;
+    command?: undefined;
+    mutation?: undefined;
+    nextAction?: undefined;
+    schemaVersion?: undefined;
+    buildId?: undefined;
+    buildPageUrl?: undefined;
+    commit?: undefined;
+} | {
+    state: string;
+    deployed: boolean;
+    storeSubmission: boolean;
+    nextAction: string;
+    platform?: undefined;
+    profile?: undefined;
+    command?: undefined;
+    mutation?: undefined;
+    integrations?: undefined;
+    schemaVersion?: undefined;
+    buildId?: undefined;
+    buildPageUrl?: undefined;
+    commit?: undefined;
+} | {
+    schemaVersion: number;
+    state: string;
+    buildId: any;
+    buildPageUrl: string;
+    commit: string;
+    platform: "android" | "ios";
+    profile: string;
+    storeSubmission: boolean;
+    nextAction: string;
+    command?: undefined;
+    mutation?: undefined;
+    integrations?: undefined;
+    deployed?: undefined;
+}>;