@stacksjs/ts-cloud 0.7.56 → 0.7.58

package/dist/source/store.d.ts

@@ -0,0 +1,149 @@
+import type { ControlPlaneStore, JsonValue } from '../control-plane';
+import type { SourceBinding, SourceConnection, SourceConnectionStoreOptions, SourceCredential, SourceDeployKey, SourceProvider, SourceRepository, SourceWebhook, SourceWebhookDelivery } from './types';
+export declare class SourceConnectionStore {
+    private readonly controlPlane;
+    private readonly key?;
+    private readonly nowFn;
+    private readonly idFn;
+    constructor(controlPlane: ControlPlaneStore, options?: SourceConnectionStoreOptions);
+    private now;
+    private run;
+    private encrypt;
+    private decrypt;
+    createConnection(input: {
+        organizationId: string;
+        provider: SourceProvider;
+        name: string;
+        host: string;
+        owner?: string;
+        authKind?: SourceConnection['authKind'];
+        credential?: SourceCredential;
+        grantedScopes?: string[];
+        credentialExpiresAt?: string;
+        createdByActorId?: string;
+    }): SourceConnection;
+    getConnection(id: string): SourceConnection | undefined;
+    listConnections(organizationId: string): SourceConnection[];
+    private currentConnection;
+    getCredential(id: string): SourceCredential | undefined;
+    rotateCredential(id: string, credential: SourceCredential, input?: {
+        expiresAt?: string;
+        actorId?: string;
+    }): SourceConnection;
+    updateHealth(id: string, input: {
+        status: 'healthy' | 'degraded' | 'expired';
+        message?: string;
+        tested?: boolean;
+        synced?: boolean;
+        grantedScopes?: string[];
+    }): SourceConnection;
+    upsertRepository(input: Omit<SourceRepository, 'id' | 'syncedAt'>): SourceRepository;
+    listRepositories(connectionId: string, search?: string, limit?: number): SourceRepository[];
+    getRepository(id: string): SourceRepository | undefined;
+    createDeployKey(input: {
+        connectionId: string;
+        name: string;
+        publicKey: string;
+        privateKey: string;
+        host: string;
+        hostKey: string;
+        actorId?: string;
+    }): SourceDeployKey;
+    getDeployKey(id: string): SourceDeployKey | undefined;
+    listDeployKeys(connectionId: string): SourceDeployKey[];
+    revokeDeployKey(id: string, actorId?: string): {
+        affectedBindings: SourceBinding[];
+    };
+    getDeployPrivateKey(id: string): string;
+    createBinding(input: {
+        projectId: string;
+        environmentId?: string;
+        resourceId?: string;
+        connectionId: string;
+        repositoryId?: string;
+        repositoryFullName: string;
+        defaultBranch?: string;
+        branchRule?: string;
+        tagRule?: string;
+        monorepoRoot?: string;
+        includePaths?: string[];
+        excludePaths?: string[];
+        submodules?: boolean;
+        cloneDepth?: number;
+        deployKeyId?: string;
+        autoDeploy?: boolean;
+        pullRequestPreviews?: boolean;
+        actorId?: string;
+    }): SourceBinding;
+    getBinding(id: string): SourceBinding | undefined;
+    listBindings(input?: {
+        connectionId?: string;
+        projectId?: string;
+        status?: SourceBinding['status'];
+    }): SourceBinding[];
+    updateBinding(id: string, expectedVersion: number, input: {
+        defaultBranch?: string;
+        branchRule?: string;
+        tagRule?: string;
+        monorepoRoot?: string;
+        includePaths?: string[];
+        excludePaths?: string[];
+        submodules?: boolean;
+        cloneDepth?: number | null;
+        deployKeyId?: string | null;
+        autoDeploy?: boolean;
+        pullRequestPreviews?: boolean;
+        status?: SourceBinding['status'];
+        disabledReason?: string;
+        actorId?: string;
+    }): SourceBinding;
+    createWebhook(input: {
+        connectionId: string;
+        repositoryId?: string;
+        repositoryFullName: string;
+        events?: string[];
+        endpointToken?: string;
+        secret?: string;
+    }): {
+        webhook: SourceWebhook;
+        secret: string;
+    };
+    getWebhook(id: string): SourceWebhook | undefined;
+    getWebhookByEndpointToken(endpointToken: string): SourceWebhook | undefined;
+    getWebhookSecret(id: string): string;
+    getWebhookEndpointToken(id: string): string;
+    listWebhooks(connectionId: string): SourceWebhook[];
+    updateWebhookState(id: string, input: {
+        providerWebhookId?: string;
+        status: SourceWebhook['status'];
+        healthMessage?: string;
+        reconciled?: boolean;
+    }): SourceWebhook;
+    getDeliveryByProviderId(connectionId: string, providerDeliveryId: string): SourceWebhookDelivery | undefined;
+    recordDelivery(input: {
+        connectionId: string;
+        webhookId: string;
+        providerDeliveryId: string;
+        event: string;
+        action?: string;
+        commitSha?: string;
+        signatureStatus: SourceWebhookDelivery['signatureStatus'];
+        status: SourceWebhookDelivery['status'];
+        payloadSummary?: JsonValue;
+        operationId?: string;
+        error?: string;
+    }): {
+        delivery: SourceWebhookDelivery;
+        duplicate: boolean;
+    };
+    updateDelivery(id: string, input: {
+        status: SourceWebhookDelivery['status'];
+        operationId?: string;
+        error?: string;
+    }): SourceWebhookDelivery;
+    listDeliveries(webhookId: string, limit?: number): SourceWebhookDelivery[];
+    disconnectConnection(id: string, actorId?: string): {
+        connection: SourceConnection;
+        affectedBindings: SourceBinding[];
+    };
+}

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

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

package/dist/source/types.d.ts

@@ -0,0 +1,191 @@
+import type { JsonValue } from '../control-plane';
+export type SourceProvider = 'github' | 'gitlab' | 'bitbucket' | 'gitea' | 'generic_https' | 'generic_ssh';
+export type SourceConnectionStatus = 'pending' | 'healthy' | 'degraded' | 'expired' | 'disconnected';
+export interface SourceCapabilities {
+    repositories: boolean;
+    branches: boolean;
+    tags: boolean;
+    webhooks: boolean;
+    pullRequests: boolean;
+    tokenRefresh: boolean;
+    deployKeys: boolean;
+}
+export interface SourceConnection {
+    id: string;
+    organizationId: string;
+    provider: SourceProvider;
+    name: string;
+    host: string;
+    owner?: string;
+    authKind: 'app' | 'oauth_token' | 'access_token' | 'deploy_key' | 'none';
+    credentialConfigured: boolean;
+    credentialFingerprint?: string;
+    grantedScopes: string[];
+    capabilities: SourceCapabilities;
+    status: SourceConnectionStatus;
+    healthMessage?: string;
+    lastTestedAt?: string;
+    lastSyncedAt?: string;
+    credentialExpiresAt?: string;
+    version: number;
+    createdByActorId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SourceCredential {
+    token?: string;
+    username?: string;
+    appId?: string;
+    installationId?: string;
+    privateKey?: string;
+}
+export interface SourceRepository {
+    id: string;
+    connectionId: string;
+    providerRepositoryId: string;
+    fullName: string;
+    cloneUrl: string;
+    defaultBranch: string;
+    visibility: 'public' | 'private' | 'internal' | 'unknown';
+    archived: boolean;
+    metadata: JsonValue;
+    syncedAt: string;
+}
+export interface SourceDeployKey {
+    id: string;
+    connectionId: string;
+    name: string;
+    publicKey: string;
+    publicKeyFingerprint: string;
+    host: string;
+    hostKey: string;
+    hostKeyFingerprint: string;
+    createdByActorId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SourceBinding {
+    id: string;
+    projectId: string;
+    environmentId?: string;
+    resourceId?: string;
+    connectionId: string;
+    repositoryId?: string;
+    repositoryFullName: string;
+    defaultBranch: string;
+    branchRule?: string;
+    tagRule?: string;
+    monorepoRoot: string;
+    includePaths: string[];
+    excludePaths: string[];
+    submodules: boolean;
+    cloneDepth?: number;
+    deployKeyId?: string;
+    autoDeploy: boolean;
+    pullRequestPreviews: boolean;
+    status: 'active' | 'disabled';
+    disabledReason?: string;
+    version: number;
+    createdByActorId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SourceWebhook {
+    id: string;
+    connectionId: string;
+    repositoryId?: string;
+    repositoryFullName: string;
+    providerWebhookId?: string;
+    /** Returned only when the webhook endpoint is created; stored as a hash. */
+    endpointToken?: string;
+    events: string[];
+    status: 'pending' | 'healthy' | 'degraded' | 'disabled';
+    healthMessage?: string;
+    lastDeliveryAt?: string;
+    lastReconciledAt?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SourceWebhookDelivery {
+    id: string;
+    connectionId: string;
+    webhookId: string;
+    providerDeliveryId: string;
+    event: string;
+    action?: string;
+    commitSha?: string;
+    signatureStatus: 'verified' | 'invalid' | 'missing';
+    status: 'accepted' | 'ignored' | 'rejected' | 'duplicate' | 'enqueued' | 'failed';
+    payloadSummary: JsonValue;
+    operationId?: string;
+    error?: string;
+    receivedAt: string;
+    processedAt?: string;
+}
+export interface SourceConnectionStoreOptions {
+    encryptionKey?: string;
+    now?: () => Date;
+    id?: () => string;
+}
+export interface SourceRepositoryPage {
+    repositories: Array<Omit<SourceRepository, 'id' | 'connectionId' | 'syncedAt'>>;
+    nextCursor?: string;
+}
+export interface SourceRef {
+    name: string;
+    commitSha: string;
+    protected?: boolean;
+}
+export interface SourceRefPage {
+    refs: SourceRef[];
+    nextCursor?: string;
+}
+export interface SourceWebhookRegistration {
+    providerWebhookId: string;
+    active: boolean;
+    events: string[];
+    url: string;
+}
+export interface SourceConnectionTest {
+    ok: boolean;
+    account?: string;
+    scopes: string[];
+    message: string;
+}
+export interface SourceCommitStatus {
+    state: 'pending' | 'success' | 'failure' | 'error';
+    url?: string;
+    description: string;
+    context?: string;
+}
+export interface SourceProviderAdapter {
+    readonly provider: SourceProvider;
+    readonly capabilities: SourceCapabilities;
+    testConnection: () => Promise<SourceConnectionTest>;
+    listRepositories: (input?: {
+        cursor?: string;
+        search?: string;
+        limit?: number;
+    }) => Promise<SourceRepositoryPage>;
+    listBranches: (repository: string, input?: {
+        cursor?: string;
+        limit?: number;
+    }) => Promise<SourceRefPage>;
+    listTags: (repository: string, input?: {
+        cursor?: string;
+        limit?: number;
+    }) => Promise<SourceRefPage>;
+    createWebhook: (repository: string, input: {
+        url: string;
+        secret: string;
+        events: string[];
+    }) => Promise<SourceWebhookRegistration>;
+    listWebhooks: (repository: string) => Promise<SourceWebhookRegistration[]>;
+    updateWebhook: (repository: string, webhookId: string, input: {
+        url: string;
+        secret: string;
+        events: string[];
+    }) => Promise<SourceWebhookRegistration>;
+    deleteWebhook: (repository: string, webhookId: string) => Promise<void>;
+    setCommitStatus: (repository: string, commitSha: string, status: SourceCommitStatus) => Promise<void>;
+}

package/dist/source/webhooks.d.ts

@@ -0,0 +1,33 @@
+import type { ControlPlaneOperation, ControlPlaneStore } from '../control-plane';
+import type { SourceConnectionStore } from './store';
+import type { SourceProvider, SourceWebhook } from './types';
+export interface NormalizedSourceEvent {
+    event: 'push' | 'pull_request';
+    action?: string;
+    repository: string;
+    ref?: string;
+    branch?: string;
+    tag?: string;
+    commitSha: string;
+    changedPaths: string[];
+    pullRequestNumber?: number;
+    fork?: boolean;
+    deleted?: boolean;
+}
+export interface ProcessSourceWebhookResult {
+    accepted: boolean;
+    duplicate: boolean;
+    status: 'rejected' | 'ignored' | 'enqueued' | 'duplicate';
+    operations: ControlPlaneOperation[];
+    message: string;
+}
+export declare function normalizeSourceEvent(_provider: SourceProvider, _headers: Headers | Record<string, string | undefined>, _body: Record<string, any>): NormalizedSourceEvent | undefined;
+export declare function processSourceWebhook(input: {
+    sources: SourceConnectionStore;
+    controlPlane: ControlPlaneStore;
+    endpointToken: string;
+    headers: Headers | Record<string, string | undefined>;
+    rawBody: Uint8Array;
+    now?: Date;
+}): Promise<ProcessSourceWebhookResult>;
+export declare function webhookEndpoint(baseUrl: string, webhook: SourceWebhook): string;

package/dist/source/webhooks.test.d.ts

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

package/dist/ssl/acme-client.d.ts

@@ -1,9 +1,3 @@
-/**
- * ACME Client for Let's Encrypt
- * Implements RFC 8555 (ACME Protocol) for certificate issuance
- *
- * This is a pure TypeScript/Bun implementation without external dependencies.
- */
 export declare const ACME_DIRECTORIES: {
     readonly production: 'https://acme-v02.api.letsencrypt.org/directory';
     readonly staging: 'https://acme-staging-v02.api.letsencrypt.org/directory';

package/dist/storage/compose.d.ts

@@ -0,0 +1,4 @@
+import type { ComposeApplicationRecord } from '../compose/types';
+import type { ControlPlaneStore } from '../control-plane';
+export declare function synchronizeComposeVolumes(controlPlane: ControlPlaneStore, application: ComposeApplicationRecord): void;
+export declare function completeComposeVolumeDeletion(controlPlane: ControlPlaneStore, application: ComposeApplicationRecord, removeVolumes: boolean): void;

package/dist/storage/compose.test.d.ts

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

package/dist/storage/drivers.d.ts

@@ -0,0 +1,107 @@
+import type { PersistentVolume, VolumeAttachment, VolumeCapabilities, VolumeDriver, VolumeDriverObservation, VolumeSnapshot } from './model';
+export interface DockerVolumeCommandResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+export type DockerVolumeCommand = (args: string[]) => Promise<DockerVolumeCommandResult>;
+export declare class DockerNamedVolumeDriver implements VolumeDriver {
+    private readonly command;
+    readonly provider = "docker";
+    readonly type: 'docker';
+    constructor(command?: DockerVolumeCommand);
+    capabilities(): VolumeCapabilities;
+    private run;
+    private inspect;
+    discover(_projectId?: string, _environmentId?: string): Promise<VolumeDriverObservation[]>;
+    create(volume: PersistentVolume): Promise<VolumeDriverObservation>;
+    attach(_volume: PersistentVolume, _attachment: VolumeAttachment): Promise<void>;
+    detach(_volume: PersistentVolume, _attachment: VolumeAttachment): Promise<void>;
+    resize(): Promise<VolumeDriverObservation>;
+    snapshot(): Promise<{
+        providerId?: string;
+        sizeBytes?: number;
+        checksum?: string;
+    }>;
+    restore(_volume: PersistentVolume, _snapshot: VolumeSnapshot, _target: PersistentVolume): Promise<VolumeDriverObservation>;
+    delete(volume: PersistentVolume): Promise<void>;
+    usage(volume: PersistentVolume): Promise<{
+        usedBytes?: number;
+        capacityBytes?: number;
+    }>;
+}
+export declare class ServerPathVolumeDriver implements VolumeDriver {
+    readonly provider = "server";
+    readonly type: 'server_path';
+    private readonly root;
+    constructor(root: string);
+    capabilities(): VolumeCapabilities;
+    private path;
+    discover(_projectId?: string, _environmentId?: string): Promise<VolumeDriverObservation[]>;
+    create(volume: PersistentVolume): Promise<VolumeDriverObservation>;
+    attach(_volume: PersistentVolume, _attachment: VolumeAttachment): Promise<void>;
+    detach(_volume: PersistentVolume, _attachment: VolumeAttachment): Promise<void>;
+    resize(): Promise<VolumeDriverObservation>;
+    snapshot(): Promise<{
+        providerId?: string;
+        sizeBytes?: number;
+        checksum?: string;
+    }>;
+    restore(_volume: PersistentVolume, _snapshot: VolumeSnapshot, _target: PersistentVolume): Promise<VolumeDriverObservation>;
+    delete(volume: PersistentVolume): Promise<void>;
+    usage(volume: PersistentVolume): Promise<{
+        usedBytes?: number;
+        capacityBytes?: number;
+    }>;
+}
+export interface CloudVolumeTransport {
+    list(projectId: string, environmentId?: string): Promise<VolumeDriverObservation[]>;
+    create(input: {
+        name: string;
+        projectId: string;
+        environmentId?: string;
+        capacityBytes?: number;
+        encrypted: boolean;
+        filesystem?: string;
+    }): Promise<VolumeDriverObservation>;
+    attach(providerId: string, resourceProviderId: string, targetPath: string, readOnly: boolean): Promise<void>;
+    detach(providerId: string, resourceProviderId: string, force: boolean): Promise<void>;
+    resize(providerId: string, capacityBytes: number): Promise<VolumeDriverObservation>;
+    snapshot(providerId: string, name: string): Promise<{
+        providerId?: string;
+        sizeBytes?: number;
+        checksum?: string;
+    }>;
+    restore(providerId: string, snapshotProviderId: string, targetName: string): Promise<VolumeDriverObservation>;
+    delete(providerId: string): Promise<void>;
+    usage(providerId: string): Promise<{
+        usedBytes?: number;
+        capacityBytes?: number;
+    }>;
+}
+export declare class CloudBlockVolumeDriver implements VolumeDriver {
+    readonly provider: string;
+    private readonly transport;
+    readonly type: 'ebs';
+    constructor(provider: string, transport: CloudVolumeTransport);
+    capabilities(): VolumeCapabilities;
+    discover(projectId: string, environmentId?: string): Promise<VolumeDriverObservation[]>;
+    create(volume: PersistentVolume): Promise<VolumeDriverObservation>;
+    private resource;
+    attach(volume: PersistentVolume, attachment: VolumeAttachment): Promise<void>;
+    detach(volume: PersistentVolume, attachment: VolumeAttachment, options: {
+        force: boolean;
+    }): Promise<void>;
+    resize(volume: PersistentVolume, capacityBytes: number): Promise<VolumeDriverObservation>;
+    snapshot(volume: PersistentVolume, snapshot: VolumeSnapshot): Promise<{
+        providerId?: string;
+        sizeBytes?: number;
+        checksum?: string;
+    }>;
+    restore(volume: PersistentVolume, snapshot: VolumeSnapshot, target: PersistentVolume): Promise<VolumeDriverObservation>;
+    delete(volume: PersistentVolume): Promise<void>;
+    usage(volume: PersistentVolume): Promise<{
+        usedBytes?: number;
+        capacityBytes?: number;
+    }>;
+}

package/dist/storage/drivers.test.d.ts

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

package/dist/storage/index.d.ts

@@ -0,0 +1,5 @@
+export * from './model';
+export * from './store';
+export * from './service';
+export * from './drivers';
+export * from './compose';

package/dist/storage/model.d.ts

@@ -0,0 +1,112 @@
+import type { JsonValue } from '../control-plane';
+export type VolumeType = 'server_path' | 'docker' | 'ebs' | 'efs' | 'provider';
+export type VolumeStatus = 'pending' | 'available' | 'attaching' | 'attached' | 'detaching' | 'resizing' | 'snapshotting' | 'orphaned' | 'deleting' | 'deleted' | 'error';
+export type VolumeAction = 'create' | 'attach' | 'detach' | 'resize' | 'snapshot' | 'restore' | 'delete' | 'adopt' | 'usage';
+export interface VolumeCapability {
+    supported: boolean;
+    reason?: string;
+    online?: boolean;
+    minimumBytes?: number;
+    maximumBytes?: number;
+}
+export type VolumeCapabilities = Record<VolumeAction, VolumeCapability>;
+export interface PersistentVolume {
+    id: string;
+    organizationId: string;
+    projectId: string;
+    environmentId?: string;
+    resourceId?: string;
+    name: string;
+    provider: string;
+    providerId?: string;
+    type: VolumeType;
+    status: VolumeStatus;
+    capacityBytes?: number;
+    usedBytes?: number;
+    filesystem?: string;
+    encrypted: boolean;
+    capabilities: VolumeCapabilities;
+    desiredState: Record<string, JsonValue>;
+    observedState: Record<string, JsonValue>;
+    backupPolicyId?: string;
+    lastBackupAt?: string;
+    orphanedAt?: string;
+    adoptedAt?: string;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt?: string;
+}
+export interface VolumeAttachment {
+    id: string;
+    volumeId: string;
+    resourceId: string;
+    targetPath: string;
+    readOnly: boolean;
+    uid?: number;
+    gid?: number;
+    mode?: string;
+    propagation: 'private' | 'rprivate' | 'shared' | 'rshared' | 'slave' | 'rslave';
+    driverOptions: Record<string, JsonValue>;
+    desiredState: 'attached' | 'detached';
+    observedState: 'pending' | 'attached' | 'detached' | 'error';
+    operationId?: string;
+    lastError?: string;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface VolumeSnapshot {
+    id: string;
+    volumeId: string;
+    recoveryPointId?: string;
+    providerId?: string;
+    name: string;
+    status: 'pending' | 'available' | 'restoring' | 'deleting' | 'deleted' | 'error';
+    sizeBytes?: number;
+    encrypted: boolean;
+    checksum?: string;
+    metadata: Record<string, JsonValue>;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt?: string;
+}
+export interface VolumeInventoryItem extends PersistentVolume {
+    attachments: VolumeAttachment[];
+    snapshots: VolumeSnapshot[];
+    orphaned: boolean;
+    usagePercent?: number;
+    backupState: 'protected' | 'stale' | 'unprotected';
+}
+export interface VolumeDriverObservation {
+    providerId: string;
+    capacityBytes?: number;
+    usedBytes?: number;
+    filesystem?: string;
+    encrypted?: boolean;
+    attachedResourceIds?: string[];
+    raw?: Record<string, JsonValue>;
+}
+export interface VolumeDriver {
+    readonly provider: string;
+    readonly type: VolumeType;
+    capabilities(volume?: PersistentVolume): VolumeCapabilities;
+    discover(projectId: string, environmentId?: string): Promise<VolumeDriverObservation[]>;
+    create(volume: PersistentVolume): Promise<VolumeDriverObservation>;
+    attach(volume: PersistentVolume, attachment: VolumeAttachment): Promise<void>;
+    detach(volume: PersistentVolume, attachment: VolumeAttachment, options: {
+        force: boolean;
+    }): Promise<void>;
+    resize(volume: PersistentVolume, capacityBytes: number): Promise<VolumeDriverObservation>;
+    snapshot(volume: PersistentVolume, snapshot: VolumeSnapshot): Promise<{
+        providerId?: string;
+        sizeBytes?: number;
+        checksum?: string;
+    }>;
+    restore(volume: PersistentVolume, snapshot: VolumeSnapshot, target: PersistentVolume): Promise<VolumeDriverObservation>;
+    delete(volume: PersistentVolume): Promise<void>;
+    usage(volume: PersistentVolume): Promise<{
+        usedBytes?: number;
+        capacityBytes?: number;
+    }>;
+}