@stacksjs/ts-cloud 0.7.56 → 0.7.58

package/dist/placement/drivers.d.ts

@@ -0,0 +1,54 @@
+import type { JsonValue } from '../control-plane';
+import type { CapacityPool, PoolBackend, RemoteBuild, RemoteBuildDriver } from './types';
+export interface RemoteBuildTransport {
+    provision(input: {
+        backend: PoolBackend;
+        pool: CapacityPool;
+        build: RemoteBuild;
+        tokenExpiresAt: string;
+    }): Promise<{
+        handle: string;
+    }>;
+    execute(input: {
+        handle: string;
+        spec: JsonValue;
+        sourceSha: string;
+        signal: AbortSignal;
+        onLog(message: string): void;
+    }): Promise<void>;
+    publish(input: {
+        handle: string;
+        sourceSha: string;
+    }): Promise<{
+        artifactUri: string;
+        artifactDigest: string;
+        cacheKey?: string;
+    }>;
+    destroy(input: {
+        handle: string;
+    }): Promise<void>;
+}
+/** Provider-neutral orchestration over real server, ECS task, or ASG runner transports. */
+export declare class TransportRemoteBuildDriver implements RemoteBuildDriver {
+    readonly backend: PoolBackend;
+    private transport;
+    private handles;
+    constructor(backend: PoolBackend, transport: RemoteBuildTransport);
+    run({ build, pool, signal, log, }: {
+        build: RemoteBuild;
+        pool: CapacityPool;
+        signal: AbortSignal;
+        log(message: string): void;
+    }): Promise<{
+        artifactUri: string;
+        artifactDigest: string;
+        cacheKey?: string;
+    }>;
+    cleanup({ build }: {
+        build: RemoteBuild;
+        pool: CapacityPool;
+    }): Promise<void>;
+}
+export declare const createServerBuildDriver: (transport: RemoteBuildTransport) => TransportRemoteBuildDriver;
+export declare const createEcsBuildDriver: (transport: RemoteBuildTransport) => TransportRemoteBuildDriver;
+export declare const createAsgBuildDriver: (transport: RemoteBuildTransport) => TransportRemoteBuildDriver;

package/dist/placement/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './store';
+export * from './service';
+export * from './builds';
+export * from './queue';
+export * from './drivers';

package/dist/placement/placement.test.d.ts

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

package/dist/placement/queue.d.ts

@@ -0,0 +1,4 @@
+import type { QueueOperationHandler } from '../queue';
+import type { RemoteBuildDriver } from './types';
+import { PlacementStore } from './store';
+export declare function createRemoteBuildQueueHandlers(store: PlacementStore, drivers: readonly RemoteBuildDriver[]): Record<string, QueueOperationHandler>;

package/dist/placement/service.d.ts

@@ -0,0 +1,34 @@
+import type { FleetStore } from '../fleet';
+import type { CapacityPool, PlacementDecision, PlacementRequirements, WorkloadPlacement } from './types';
+import { PlacementStore } from './store';
+export declare class PlacementService {
+    readonly store: PlacementStore;
+    readonly fleet: FleetStore;
+    constructor(store: PlacementStore, fleet: FleetStore);
+    private poolCandidates;
+    private serverReasons;
+    private decision;
+    explain(projectId: string, requirements: PlacementRequirements): PlacementDecision[];
+    place(input: {
+        projectId: string;
+        environmentId?: string;
+        resourceId: string;
+        releaseId?: string;
+        requirements: PlacementRequirements;
+    }): WorkloadPlacement;
+    activate(id: string): WorkloadPlacement;
+    release(id: string): WorkloadPlacement;
+    drainPool(id: string): {
+        pool: CapacityPool;
+        moved: WorkloadPlacement[];
+        blocked: WorkloadPlacement[];
+    };
+    drainServer(poolId: string, serverId: string): {
+        moved: WorkloadPlacement[];
+        blocked: WorkloadPlacement[];
+    };
+    reconcileFailure(serverId: string): {
+        rescheduled: WorkloadPlacement[];
+        blocked: WorkloadPlacement[];
+    };
+}

package/dist/placement/store.d.ts

@@ -0,0 +1,49 @@
+import type { ControlPlaneStore, JsonValue } from '../control-plane';
+import type { CapacityPool, CapacityVector, PlacementDecision, PlacementRequirements, RemoteBuild, WorkloadPlacement } from './types';
+export declare const zeroCapacity: () => CapacityVector;
+export declare const capacity: (value?: Partial<CapacityVector>) => CapacityVector;
+export declare class PlacementStore {
+    readonly control: ControlPlaneStore;
+    private now;
+    private id;
+    constructor(control: ControlPlaneStore, now?: () => Date, id?: () => string);
+    createPool(input: Omit<CapacityPool, 'id' | 'reserved' | 'version' | 'createdAt' | 'updatedAt'>): CapacityPool;
+    getPool(id: string): CapacityPool | undefined;
+    listPools(projectId: string): CapacityPool[];
+    updatePool(id: string, patch: Partial<Pick<CapacityPool, 'status' | 'reserved' | 'capacity' | 'concurrency'>>): CapacityPool;
+    addMember(poolId: string, serverId: string, override?: Partial<CapacityVector>): void;
+    members(poolId: string): Array<{
+        serverId: string;
+        status: string;
+        capacityOverride: Partial<CapacityVector>;
+    }>;
+    memberStatus(poolId: string, serverId: string, status: 'active' | 'draining' | 'offline'): void;
+    listPlacements(projectId: string, statuses?: WorkloadPlacement['status'][]): WorkloadPlacement[];
+    getPlacement(id: string): WorkloadPlacement | undefined;
+    activeUsage(poolId: string, serverId?: string): {
+        resources: CapacityVector;
+        count: number;
+    };
+    expireLeases(): number;
+    reserve(input: {
+        projectId: string;
+        environmentId?: string;
+        resourceId: string;
+        releaseId?: string;
+        requirements: PlacementRequirements;
+        decision: PlacementDecision;
+    }): WorkloadPlacement;
+    transitionPlacement(id: string, status: WorkloadPlacement['status']): WorkloadPlacement;
+    createBuild(input: {
+        projectId: string;
+        resourceId?: string;
+        poolId: string;
+        placementId?: string;
+        operationId?: string;
+        sourceSha: string;
+        buildSpec: JsonValue;
+        tokenExpiresAt: string;
+    }): RemoteBuild;
+    getBuild(id: string): RemoteBuild | undefined;
+    updateBuild(id: string, patch: Partial<Pick<RemoteBuild, 'status' | 'operationId' | 'workspace' | 'cacheKey' | 'artifactUri' | 'artifactDigest' | 'cleanupAt'>>): RemoteBuild;
+}

package/dist/placement/types.d.ts

@@ -0,0 +1,109 @@
+import type { JsonValue } from '../control-plane';
+export type PoolPurpose = 'application' | 'build' | 'worker' | 'monitoring' | 'backup';
+export type PoolBackend = 'server' | 'ecs' | 'asg';
+export type CapacityVector = Record<'cpu' | 'memoryBytes' | 'diskBytes' | 'gpu', number>;
+export interface CapacityPool {
+    id: string;
+    organizationId: string;
+    projectId: string;
+    name: string;
+    purpose: PoolPurpose;
+    backend: PoolBackend;
+    region?: string;
+    architecture?: string;
+    labels: Record<string, string>;
+    requiredServerLabels: Record<string, string>;
+    toleratedTaints: string[];
+    capacity: CapacityVector;
+    reserved: Partial<CapacityVector>;
+    maxWorkloads: number;
+    costWeight: number;
+    spreadKey?: string;
+    concurrency: number;
+    ephemeralWorkspaces: boolean;
+    allowProductionSecrets: boolean;
+    status: 'active' | 'draining' | 'disabled';
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PlacementRequirements {
+    purpose: PoolPurpose;
+    resources: Partial<CapacityVector>;
+    region?: string;
+    architecture?: string;
+    labels?: Record<string, string>;
+    stateful?: boolean;
+    autoReschedule?: boolean;
+    leaseSeconds?: number;
+}
+export interface PlacementDecision {
+    poolId: string;
+    poolName: string;
+    serverId?: string;
+    eligible: boolean;
+    reasons: string[];
+    available: CapacityVector;
+    score: {
+        fit: number;
+        spread: number;
+        cost: number;
+    };
+}
+export interface WorkloadPlacement {
+    id: string;
+    projectId: string;
+    environmentId?: string;
+    resourceId: string;
+    releaseId?: string;
+    poolId: string;
+    serverId?: string;
+    purpose: PoolPurpose;
+    requirements: PlacementRequirements;
+    decision: PlacementDecision;
+    stateful: boolean;
+    autoReschedule: boolean;
+    status: 'reserved' | 'active' | 'moving' | 'blocked' | 'released' | 'failed';
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RemoteBuild {
+    id: string;
+    projectId: string;
+    resourceId?: string;
+    poolId: string;
+    placementId?: string;
+    operationId?: string;
+    sourceSha: string;
+    buildSpec: JsonValue;
+    credentialPolicy: {
+        productionSecrets: false;
+        shortLivedTokenExpiresAt: string;
+    };
+    workspace?: string;
+    cacheKey?: string;
+    artifactUri?: string;
+    artifactDigest?: string;
+    status: 'queued' | 'running' | 'uploading' | 'succeeded' | 'failed' | 'cancelled' | 'cleanup_required';
+    cleanupAt?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RemoteBuildDriver {
+    backend: PoolBackend;
+    run(input: {
+        build: RemoteBuild;
+        pool: CapacityPool;
+        signal: AbortSignal;
+        log(message: string): void;
+    }): Promise<{
+        artifactUri: string;
+        artifactDigest: string;
+        cacheKey?: string;
+    }>;
+    cleanup(input: {
+        build: RemoteBuild;
+        pool: CapacityPool;
+    }): Promise<void>;
+}

package/dist/preview/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './store';
+export * from './service';

package/dist/preview/service.d.ts

@@ -0,0 +1,45 @@
+import type { ControlPlaneOperation, ControlPlaneStore, JsonValue } from '../control-plane';
+import type { PreviewInstance } from './types';
+import { DurableOperationQueue } from '../queue';
+import { PreviewEnvironmentStore } from './store';
+export interface PreviewCleanupCandidate {
+    preview: PreviewInstance;
+    reasons: string[];
+}
+export interface PreviewCleanupResult {
+    candidates: PreviewCleanupCandidate[];
+    operations: ControlPlaneOperation[];
+    dryRun: boolean;
+}
+export interface DiscoveredPreviewResource {
+    provider: string;
+    providerResourceId: string;
+    kind: string;
+    tags: Record<string, string>;
+    observedState?: JsonValue;
+    estimatedMonthlyCost?: number;
+}
+export declare class PreviewEnvironmentService {
+    readonly controlPlane: ControlPlaneStore;
+    readonly previews: PreviewEnvironmentStore;
+    readonly queue: DurableOperationQueue;
+    constructor(controlPlane: ControlPlaneStore);
+    enqueueDeploy(preview: PreviewInstance, input?: {
+        created?: boolean;
+        actorId?: string;
+        reason?: string;
+    }): ControlPlaneOperation;
+    enqueueDestroy(preview: PreviewInstance, reason: string, actorId?: string): ControlPlaneOperation;
+    cleanup(input?: {
+        now?: Date;
+        maxAgeHours?: number;
+        keepCount?: number;
+        dryRun?: boolean;
+        actorId?: string;
+    }): PreviewCleanupResult;
+    reconcile(discovered: DiscoveredPreviewResource[]): {
+        matched: string[];
+        unknownPreviewResources: string[];
+        ignoredUntagged: string[];
+    };
+}

package/dist/preview/service.test.d.ts

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

package/dist/preview/store.d.ts

@@ -0,0 +1,47 @@
+import type { ControlPlaneStore, JsonValue } from '../control-plane';
+import type { CreatePreviewDefinitionInput, PreviewDefinition, PreviewInstance, PreviewResource, PreviewStatus, UpsertPreviewInput } from './types';
+export declare class PreviewEnvironmentStore {
+    readonly controlPlane: ControlPlaneStore;
+    private readonly now;
+    private readonly id;
+    constructor(controlPlane: ControlPlaneStore, options?: {
+        now?: () => Date;
+        id?: () => string;
+    });
+    createDefinition(input: CreatePreviewDefinitionInput): PreviewDefinition;
+    getDefinition(id: string): PreviewDefinition | undefined;
+    getDefinitionForResource(resourceId: string): PreviewDefinition | undefined;
+    listDefinitions(projectId: string): PreviewDefinition[];
+    listInstances(input?: {
+        projectId?: string;
+        definitionId?: string;
+        status?: PreviewStatus;
+    }): PreviewInstance[];
+    getInstance(id: string): PreviewInstance | undefined;
+    findForPullRequest(definitionId: string, repository: string, pullRequestNumber: number): PreviewInstance | undefined;
+    findForBranch(definitionId: string, repository: string, branch: string): PreviewInstance | undefined;
+    upsert(input: UpsertPreviewInput): {
+        preview: PreviewInstance;
+        created: boolean;
+        changed: boolean;
+        inheritedSecrets: string[];
+    };
+    transition(id: string, status: PreviewStatus, input?: {
+        operationId?: string;
+        observedState?: JsonValue;
+        teardownError?: string;
+        costEstimate?: number;
+    }): PreviewInstance;
+    extend(id: string, hours: number): PreviewInstance;
+    expired(now?: Date): PreviewInstance[];
+    recordResource(input: {
+        previewId: string;
+        provider: string;
+        providerResourceId: string;
+        kind: string;
+        tags: Record<string, string>;
+        observedState?: JsonValue;
+    }): PreviewResource;
+    listResources(previewId: string): PreviewResource[];
+    markResourcesDeleted(previewId: string): number;
+}

package/dist/preview/store.test.d.ts

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

package/dist/preview/types.d.ts

@@ -0,0 +1,99 @@
+import type { JsonValue } from '../control-plane';
+export type PreviewDatabaseStrategy = 'disabled' | 'isolated' | 'snapshot' | 'shared_read_only';
+export type PreviewStatus = 'queued' | 'deploying' | 'active' | 'updating' | 'destroying' | 'destroyed' | 'failed' | 'cleanup_failed';
+export interface PreviewDefinition {
+    id: string;
+    projectId: string;
+    resourceId: string;
+    baseEnvironmentId: string;
+    enabled: boolean;
+    branchRule?: string;
+    domainPattern: string;
+    ttlHours: number;
+    keepCount: number;
+    publicAccess: boolean;
+    authenticationRequired: boolean;
+    allowForks: boolean;
+    inheritedSecrets: string[];
+    resourceOverrides: JsonValue;
+    databaseStrategy: PreviewDatabaseStrategy;
+    maxMonthlyCost: number;
+    maxCpu: number;
+    maxMemoryMb: number;
+    cleanupOnClose: boolean;
+    version: number;
+    createdByActorId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PreviewInstance {
+    id: string;
+    definitionId: string;
+    projectId: string;
+    resourceId: string;
+    baseEnvironmentId: string;
+    identityKey: string;
+    sourceProvider?: string;
+    repository?: string;
+    branch: string;
+    pullRequestNumber?: number;
+    fork: boolean;
+    commitSha: string;
+    name: string;
+    stackName: string;
+    url?: string;
+    status: PreviewStatus;
+    expiresAt: string;
+    latestOperationId?: string;
+    createdByActorId?: string;
+    costEstimate?: number;
+    desiredState: JsonValue;
+    observedState: JsonValue;
+    teardownError?: string;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+    destroyedAt?: string;
+}
+export interface PreviewResource {
+    id: string;
+    previewId: string;
+    provider: string;
+    providerResourceId: string;
+    kind: string;
+    tags: Record<string, string>;
+    observedState: JsonValue;
+    discoveredAt: string;
+    deletedAt?: string;
+}
+export interface CreatePreviewDefinitionInput {
+    projectId: string;
+    resourceId: string;
+    baseEnvironmentId: string;
+    branchRule?: string;
+    domainPattern: string;
+    ttlHours?: number;
+    keepCount?: number;
+    publicAccess?: boolean;
+    authenticationRequired?: boolean;
+    allowForks?: boolean;
+    inheritedSecrets?: string[];
+    resourceOverrides?: JsonValue;
+    databaseStrategy?: PreviewDatabaseStrategy;
+    maxMonthlyCost?: number;
+    maxCpu?: number;
+    maxMemoryMb?: number;
+    cleanupOnClose?: boolean;
+    createdByActorId?: string;
+}
+export interface UpsertPreviewInput {
+    definitionId: string;
+    sourceProvider?: string;
+    repository?: string;
+    branch: string;
+    pullRequestNumber?: number;
+    fork?: boolean;
+    commitSha: string;
+    createdByActorId?: string;
+    now?: Date;
+}

package/dist/push/apns.d.ts

@@ -1,29 +1,3 @@
-/**
- * Apple Push Notification Service (APNs) Client
- * Uses HTTP/2 with JWT token authentication
- *
- * Prerequisites:
- * - Apple Developer account
- * - APNs Key (p8 file) from Apple Developer Portal
- * - Key ID and Team ID
- *
- * @example
- * ```ts
- * const apns = new APNsClient({
- *   keyId: 'ABC123DEFG',
- *   teamId: 'DEF456GHIJ',
- *   privateKey: fs.readFileSync('AuthKey_ABC123DEFG.p8', 'utf8'),
- *   bundleId: 'com.example.app',
- *   production: false // true for production, false for sandbox
- * })
- *
- * await apns.send({
- *   deviceToken: '...',
- *   title: 'Hello',
- *   body: 'World',
- * })
- * ```
- */
 export interface APNsConfig {
     /** APNs Key ID from Apple Developer Portal */
     keyId: string;

package/dist/push/fcm.d.ts

@@ -1,26 +1,3 @@
-/**
- * Firebase Cloud Messaging (FCM) Client
- * Uses FCM HTTP v1 API with Google OAuth2 authentication
- *
- * Prerequisites:
- * - Firebase project
- * - Service account JSON key from Firebase Console
- *
- * @example
- * ```ts
- * const fcm = new FCMClient({
- *   projectId: 'your-project-id',
- *   clientEmail: 'firebase-adminsdk@project.iam.gserviceaccount.com',
- *   privateKey: '-----BEGIN PRIVATE KEY-----\n...',
- * })
- *
- * await fcm.send({
- *   token: '...',
- *   title: 'Hello',
- *   body: 'World',
- * })
- * ```
- */
 export interface FCMConfig {
     /** Firebase project ID */
     projectId: string;

package/dist/push/index.d.ts

@@ -40,5 +40,5 @@
  */
 export * from './apns';
 export * from './fcm';
-export type { APNsConfig, APNsNotification, APNsSendResult, APNsBatchResult, } from './apns';
-export type { FCMConfig, FCMNotification, FCMSendResult, FCMBatchResult, } from './fcm';
+export type { APNsConfig, APNsNotification, APNsSendResult, APNsBatchResult } from './apns';
+export type { FCMConfig, FCMNotification, FCMSendResult, FCMBatchResult } from './fcm';

package/dist/push/index.js

@@ -1,8 +1,8 @@
 import"../chunk-v0bahtg2.js";
 
 // src/push/apns.ts
-import { createSign } from "node:crypto";
 import * as http2 from "node:http2";
+import { createSign } from "node:crypto";
 var APNS_PRODUCTION_HOST = "api.push.apple.com";
 var APNS_SANDBOX_HOST = "api.sandbox.push.apple.com";
 var TOKEN_EXPIRY_MS = 45 * 60 * 1000;

package/dist/queue/deployment-handlers.d.ts

@@ -0,0 +1,27 @@
+import type { ControlPlaneOperation, ControlPlaneStore } from '../control-plane';
+import type { QueueExecutionContext, QueueOperationHandler } from './types';
+export declare const DEPLOYMENT_QUEUE_KINDS: readonly ['deployment.create', 'deployment.rollback', 'application.create', 'deploy.source', 'deploy.preview', 'preview.create', 'preview.update', 'preview.destroy', 'compose.deploy', 'compose.redeploy', 'compose.start', 'compose.stop', 'compose.delete', 'compose.scale'];
+export interface QueuedDeploymentCommand {
+    id: string;
+    label: string;
+    description: string;
+    command: string[];
+    mutates: true;
+    target: {
+        environment: string;
+        resource?: string;
+        previewId?: string;
+        composeId?: string;
+    };
+}
+export interface QueuedDeploymentResult {
+    ok: boolean;
+    exitCode: number;
+    command?: string;
+    stderr?: string;
+}
+export declare function resolveQueuedDeploymentCommand(store: ControlPlaneStore, operation: ControlPlaneOperation): QueuedDeploymentCommand;
+export declare function createDeploymentQueueHandlers(input: {
+    store: ControlPlaneStore;
+    execute: (command: QueuedDeploymentCommand, context: QueueExecutionContext) => Promise<QueuedDeploymentResult>;
+}): Record<string, QueueOperationHandler>;

package/dist/queue/deployment-handlers.test.d.ts

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

package/dist/queue/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './queue';
+export * from './worker';
+export * from './deployment-handlers';

package/dist/queue/queue.d.ts

@@ -0,0 +1,57 @@
+import type { ControlPlaneOperation, ControlPlaneStore, JsonValue, OperationState } from '../control-plane';
+import type { EnqueueOperationInput, OperationJob, OperationLogEntry, QueueConcurrencyLimits, QueueLogInput, QueueOperationHandler, QueueOperationView, QueueRecoveryResult, QueueRunResult } from './types';
+export declare class DurableOperationQueue {
+    readonly controlPlane: ControlPlaneStore;
+    private readonly nowFn;
+    private readonly idFn;
+    private readonly workerId;
+    private readonly leaseMs;
+    readonly limits: QueueConcurrencyLimits;
+    constructor(controlPlane: ControlPlaneStore, options?: {
+        workerId?: string;
+        leaseMs?: number;
+        limits?: Partial<QueueConcurrencyLimits>;
+        now?: () => Date;
+        id?: () => string;
+    });
+    private now;
+    private leaseExpiry;
+    enqueue(input: EnqueueOperationInput): QueueOperationView;
+    getJob(operationId: string): OperationJob | undefined;
+    view(operationId: string): QueueOperationView | undefined;
+    list(input?: {
+        projectId?: string;
+        state?: OperationState;
+        limit?: number;
+    }): QueueOperationView[];
+    configureConcurrency(limits: Partial<QueueConcurrencyLimits>, input?: {
+        organizationId?: string;
+        actorId?: string;
+    }): QueueConcurrencyLimits;
+    private runningCount;
+    private blockReason;
+    claim(operationId: string): QueueOperationView | undefined;
+    claimNext(kinds?: readonly string[]): QueueOperationView | undefined;
+    heartbeat(operationId: string, step?: string): void;
+    appendLog(operationId: string, message: string, input?: QueueLogInput): OperationLogEntry;
+    logs(operationId: string, input?: {
+        after?: number;
+        limit?: number;
+    }): OperationLogEntry[];
+    requestCancellation(operationId: string, actorId?: string): ControlPlaneOperation;
+    retry(operationId: string, errorClass: string, input?: {
+        delayMs?: number;
+        actorId?: string;
+    }): ControlPlaneOperation;
+    private release;
+    private finish;
+    complete(operationId: string, output?: JsonValue): ControlPlaneOperation;
+    fail(operationId: string, error: string, output?: JsonValue): ControlPlaneOperation;
+    runOne(handlers: Record<string, QueueOperationHandler>): Promise<QueueRunResult>;
+    recoverExpired(): QueueRecoveryResult;
+    clearCompleted(input?: {
+        before?: string;
+        actorId?: string;
+        projectId?: string;
+    }): number;
+}

package/dist/queue/queue.test.d.ts

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