@alienplatform/sdk 1.14.1 → 2.0.1

package/src/bindings/artifact-registry.ts

@@ -1,317 +0,0 @@
-/**
- * ArtifactRegistry binding implementation.
- *
- * Provides container image repository management.
- */
-
-import { type Channel, createClient } from "nice-grpc"
-import {
-  ArtifactRegistryServiceDefinition,
-  ComputeServiceType as ComputeServiceTypeProto,
-  type Credentials,
-  type CrossAccountAccess as CrossAccountAccessProto,
-  type CrossAccountPermissions as CrossAccountPermissionsProto,
-  type ArtifactRegistryServiceClient as GeneratedClient,
-  ArtifactRegistryPermissions as PermissionsProto,
-  type RepositoryResult,
-} from "../generated/artifact_registry.js"
-import { wrapGrpcCall } from "../grpc-utils.js"
-import type {
-  ArtifactRegistryCredentials,
-  ArtifactRegistryPermissions,
-  ComputeServiceType,
-  CrossAccountAccess,
-  CrossAccountPermissions,
-  RepositoryInfo,
-} from "../types.js"
-
-// Permission map
-const permissionMap: Record<ArtifactRegistryPermissions, PermissionsProto> = {
-  pull: PermissionsProto.PULL,
-  "push-pull": PermissionsProto.PUSH_PULL,
-}
-
-/**
- * ArtifactRegistry binding for container repository management.
- *
- * @example
- * ```typescript
- * import { artifactRegistry } from "@alienplatform/sdk"
- *
- * const registry = artifactRegistry("my-registry")
- *
- * // Create a repository
- * const repo = await registry.createRepository("my-app")
- * console.log("Repository URI:", repo.uri)
- *
- * // Generate push credentials
- * const creds = await registry.generateCredentials("my-app", "push-pull")
- * console.log("Username:", creds.username)
- * ```
- */
-export class ArtifactRegistry {
-  private readonly client: GeneratedClient
-  private readonly bindingName: string
-
-  constructor(channel: Channel, bindingName: string) {
-    this.client = createClient(ArtifactRegistryServiceDefinition, channel)
-    this.bindingName = bindingName
-  }
-
-  /**
-   * Create a repository.
-   *
-   * @param repoName - Name of the repository
-   * @returns Repository information
-   */
-  async createRepository(repoName: string): Promise<RepositoryInfo> {
-    return await wrapGrpcCall(
-      "ArtifactRegistryService",
-      "CreateRepository",
-      async () => {
-        const response = await this.client.createRepository({
-          bindingName: this.bindingName,
-          repoName,
-        })
-        return this.fromProtoResult(response.result!)
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  /**
-   * Get repository details.
-   *
-   * @param repoId - Repository ID
-   * @returns Repository information
-   */
-  async getRepository(repoId: string): Promise<RepositoryInfo> {
-    return await wrapGrpcCall(
-      "ArtifactRegistryService",
-      "GetRepository",
-      async () => {
-        const response = await this.client.getRepository({
-          bindingName: this.bindingName,
-          repoId,
-        })
-        return this.fromProtoResult(response.result!)
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  /**
-   * Add cross-account access to a repository.
-   *
-   * @param repoId - Repository ID
-   * @param access - Cross-account access configuration
-   */
-  async addCrossAccountAccess(repoId: string, access: CrossAccountAccess): Promise<void> {
-    await wrapGrpcCall(
-      "ArtifactRegistryService",
-      "AddCrossAccountAccess",
-      async () => {
-        await this.client.addCrossAccountAccess({
-          bindingName: this.bindingName,
-          repoId,
-          access: this.toProtoCrossAccountAccess(access),
-        })
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  /**
-   * Remove cross-account access from a repository.
-   *
-   * @param repoId - Repository ID
-   * @param access - Cross-account access configuration to remove
-   */
-  async removeCrossAccountAccess(repoId: string, access: CrossAccountAccess): Promise<void> {
-    await wrapGrpcCall(
-      "ArtifactRegistryService",
-      "RemoveCrossAccountAccess",
-      async () => {
-        await this.client.removeCrossAccountAccess({
-          bindingName: this.bindingName,
-          repoId,
-          access: this.toProtoCrossAccountAccess(access),
-        })
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  /**
-   * Get current cross-account access permissions for a repository.
-   *
-   * @param repoId - Repository ID
-   * @returns Current cross-account permissions
-   */
-  async getCrossAccountAccess(repoId: string): Promise<CrossAccountPermissions> {
-    return await wrapGrpcCall(
-      "ArtifactRegistryService",
-      "GetCrossAccountAccess",
-      async () => {
-        const response = await this.client.getCrossAccountAccess({
-          bindingName: this.bindingName,
-          repoId,
-        })
-        return this.fromProtoCrossAccountPermissions(response.permissions!)
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  /**
-   * Generate credentials for repository access.
-   *
-   * @param repoId - Repository ID
-   * @param permissions - Permission level (pull or push-pull)
-   * @param ttlSeconds - Optional TTL in seconds
-   * @returns Repository credentials
-   */
-  async generateCredentials(
-    repoId: string,
-    permissions: ArtifactRegistryPermissions,
-    ttlSeconds?: number,
-  ): Promise<ArtifactRegistryCredentials> {
-    return await wrapGrpcCall(
-      "ArtifactRegistryService",
-      "GenerateCredentials",
-      async () => {
-        const response = await this.client.generateCredentials({
-          bindingName: this.bindingName,
-          repoId,
-          permissions: permissionMap[permissions],
-          ttlSeconds,
-        })
-        return this.fromProtoCredentials(response.credentials!)
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  /**
-   * Delete a repository.
-   *
-   * @param repoId - Repository ID
-   */
-  async deleteRepository(repoId: string): Promise<void> {
-    await wrapGrpcCall(
-      "ArtifactRegistryService",
-      "DeleteRepository",
-      async () => {
-        await this.client.deleteRepository({
-          bindingName: this.bindingName,
-          repoId,
-        })
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  // Private helpers
-
-  private fromProtoResult(proto: RepositoryResult): RepositoryInfo {
-    return {
-      name: proto.name,
-      uri: proto.uri ?? "",
-      createdAt: proto.createdAt ? new Date(proto.createdAt) : undefined,
-    }
-  }
-
-  private fromProtoCredentials(proto: Credentials): ArtifactRegistryCredentials {
-    return {
-      authMethod: proto.authMethod === 1 ? "bearer" : "basic",
-      username: proto.username,
-      password: proto.password,
-      expiresAt: proto.expiresAt ? new Date(proto.expiresAt) : undefined,
-    }
-  }
-
-  private toProtoCrossAccountAccess(access: CrossAccountAccess): CrossAccountAccessProto {
-    if (access.type === "aws") {
-      return {
-        aws: {
-          accountIds: access.aws.accountIds,
-          allowedServiceTypes: access.aws.allowedServiceTypes.map(st =>
-            this.computeServiceTypeToProto(st),
-          ),
-          roleArns: access.aws.roleArns,
-          regions: access.aws.regions,
-        },
-        gcp: undefined,
-      }
-    }
-    return {
-      aws: undefined,
-      gcp: {
-        projectNumbers: access.gcp.projectNumbers,
-        allowedServiceTypes: access.gcp.allowedServiceTypes.map(st =>
-          this.computeServiceTypeToProto(st),
-        ),
-        serviceAccountEmails: access.gcp.serviceAccountEmails,
-      },
-    }
-  }
-
-  private fromProtoCrossAccountAccess(proto: CrossAccountAccessProto): CrossAccountAccess {
-    if (proto.aws) {
-      return {
-        type: "aws",
-        aws: {
-          accountIds: proto.aws.accountIds,
-          allowedServiceTypes: proto.aws.allowedServiceTypes
-            .map(st => this.protoToComputeServiceType(st))
-            .filter((st): st is ComputeServiceType => st !== undefined),
-          roleArns: proto.aws.roleArns,
-          regions: proto.aws.regions,
-        },
-      }
-    }
-    if (proto.gcp) {
-      return {
-        type: "gcp",
-        gcp: {
-          projectNumbers: proto.gcp.projectNumbers,
-          allowedServiceTypes: proto.gcp.allowedServiceTypes
-            .map(st => this.protoToComputeServiceType(st))
-            .filter((st): st is ComputeServiceType => st !== undefined),
-          serviceAccountEmails: proto.gcp.serviceAccountEmails,
-        },
-      }
-    }
-    throw new Error("Invalid CrossAccountAccess: neither aws nor gcp set")
-  }
-
-  private fromProtoCrossAccountPermissions(
-    proto: CrossAccountPermissionsProto,
-  ): CrossAccountPermissions {
-    if (!proto.access) {
-      throw new Error("Invalid CrossAccountPermissions: access is missing")
-    }
-    return {
-      access: this.fromProtoCrossAccountAccess(proto.access),
-      lastUpdated: proto.lastUpdated,
-    }
-  }
-
-  private computeServiceTypeToProto(st: ComputeServiceType): ComputeServiceTypeProto {
-    switch (st) {
-      case "worker":
-        return ComputeServiceTypeProto.WORKER
-      default:
-        return ComputeServiceTypeProto.UNRECOGNIZED
-    }
-  }
-
-  private protoToComputeServiceType(st: ComputeServiceTypeProto): ComputeServiceType | undefined {
-    switch (st) {
-      case ComputeServiceTypeProto.WORKER:
-        return "worker"
-      default:
-        return undefined
-    }
-  }
-}

package/src/bindings/build.ts

@@ -1,195 +0,0 @@
-/**
- * Build binding implementation.
- *
- * Provides build execution capabilities.
- */
-
-import type { BuildStatus } from "@alienplatform/core"
-import { type Channel, createClient } from "nice-grpc"
-import {
-  type BuildConfig as BuildConfigProto,
-  type BuildExecution as BuildExecutionProto,
-  BuildServiceDefinition,
-  BuildStatus as BuildStatusProto,
-  ComputeType,
-  type BuildServiceClient as GeneratedBuildServiceClient,
-} from "../generated/build.js"
-import { wrapGrpcCall } from "../grpc-utils.js"
-import type { BuildExecution, BuildStartConfig } from "../types.js"
-
-// Map proto status to core BuildStatus (matches Rust: Unspecified → Failed)
-const statusMap: Record<number, BuildStatus> = {
-  [BuildStatusProto.BUILD_STATUS_UNSPECIFIED]: "FAILED",
-  [BuildStatusProto.BUILD_STATUS_QUEUED]: "QUEUED",
-  [BuildStatusProto.BUILD_STATUS_RUNNING]: "RUNNING",
-  [BuildStatusProto.BUILD_STATUS_SUCCEEDED]: "SUCCEEDED",
-  [BuildStatusProto.BUILD_STATUS_FAILED]: "FAILED",
-  [BuildStatusProto.BUILD_STATUS_CANCELLED]: "CANCELLED",
-  [BuildStatusProto.BUILD_STATUS_TIMED_OUT]: "TIMED_OUT",
-}
-
-// Map compute type to proto
-const computeTypeMap: Record<string, ComputeType> = {
-  small: ComputeType.COMPUTE_TYPE_SMALL,
-  medium: ComputeType.COMPUTE_TYPE_MEDIUM,
-  large: ComputeType.COMPUTE_TYPE_LARGE,
-  "x-large": ComputeType.COMPUTE_TYPE_XLARGE,
-}
-
-/**
- * Build binding for executing build operations.
- *
- * @example
- * ```typescript
- * import { build } from "@alienplatform/sdk"
- *
- * const builder = build("my-builder")
- *
- * // Start a build
- * const execution = await builder.start({
- *   script: "npm run build",
- *   computeType: "medium",
- *   timeoutSeconds: 600,
- * })
- *
- * // Wait for completion
- * const result = await builder.waitForCompletion(execution.id)
- * console.log("Build status:", result.status)
- * ```
- */
-export class Build {
-  private readonly client: GeneratedBuildServiceClient
-  private readonly bindingName: string
-
-  constructor(channel: Channel, bindingName: string) {
-    this.client = createClient(BuildServiceDefinition, channel)
-    this.bindingName = bindingName
-  }
-
-  /**
-   * Start a new build.
-   *
-   * @param config - Build configuration
-   * @returns Build execution information
-   */
-  async start(config: BuildStartConfig): Promise<BuildExecution> {
-    const protoConfig = this.toProtoConfig(config)
-
-    return await wrapGrpcCall(
-      "BuildService",
-      "StartBuild",
-      async () => {
-        const response = await this.client.startBuild({
-          bindingName: this.bindingName,
-          config: protoConfig,
-        })
-        return this.fromProtoExecution(response.execution!)
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  /**
-   * Get the status of a build.
-   *
-   * @param buildId - Build execution ID
-   * @returns Build execution information
-   */
-  async getStatus(buildId: string): Promise<BuildExecution> {
-    return await wrapGrpcCall(
-      "BuildService",
-      "GetBuildStatus",
-      async () => {
-        const response = await this.client.getBuildStatus({
-          bindingName: this.bindingName,
-          buildId,
-        })
-        return this.fromProtoExecution(response.execution!)
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  /**
-   * Stop a running build.
-   *
-   * @param buildId - Build execution ID
-   */
-  async stop(buildId: string): Promise<void> {
-    await wrapGrpcCall(
-      "BuildService",
-      "StopBuild",
-      async () => {
-        await this.client.stopBuild({
-          bindingName: this.bindingName,
-          buildId,
-        })
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  /**
-   * Wait for a build to complete.
-   *
-   * @param buildId - Build execution ID
-   * @param options - Polling options
-   * @returns Final build execution information
-   */
-  async waitForCompletion(
-    buildId: string,
-    options?: { pollIntervalMs?: number; timeoutMs?: number },
-  ): Promise<BuildExecution> {
-    const pollInterval = options?.pollIntervalMs ?? 5000
-    const timeout = options?.timeoutMs ?? 30 * 60 * 1000 // 30 minutes default
-    const startTime = Date.now()
-
-    while (Date.now() - startTime < timeout) {
-      const execution = await this.getStatus(buildId)
-
-      if (
-        execution.status === "SUCCEEDED" ||
-        execution.status === "FAILED" ||
-        execution.status === "CANCELLED" ||
-        execution.status === "TIMED_OUT"
-      ) {
-        return execution
-      }
-
-      await new Promise(resolve => setTimeout(resolve, pollInterval))
-    }
-
-    throw new Error(`Build ${buildId} did not complete within timeout`)
-  }
-
-  // Private helpers
-
-  private toProtoConfig(config: BuildStartConfig): BuildConfigProto {
-    return {
-      script: config.script,
-      environment: config.environment ?? {},
-      computeType: config.computeType
-        ? (computeTypeMap[config.computeType] ?? ComputeType.COMPUTE_TYPE_UNSPECIFIED)
-        : ComputeType.COMPUTE_TYPE_UNSPECIFIED,
-      timeoutSeconds: config.timeoutSeconds,
-      monitoring: config.monitoring
-        ? {
-            endpoint: config.monitoring.endpoint,
-            headers: config.monitoring.headers ?? {},
-            logsUri: config.monitoring.logsUri ?? "/v1/logs",
-            tlsEnabled: config.monitoring.tlsEnabled ?? true,
-            tlsVerify: config.monitoring.tlsVerify ?? true,
-          }
-        : undefined,
-    }
-  }
-
-  private fromProtoExecution(proto: BuildExecutionProto): BuildExecution {
-    return {
-      id: proto.id,
-      status: statusMap[proto.status] ?? "QUEUED",
-      startTime: proto.startTime ? new Date(proto.startTime) : undefined,
-      endTime: proto.endTime ? new Date(proto.endTime) : undefined,
-    }
-  }
-}

package/src/bindings/index.ts

@@ -1,13 +0,0 @@
-/**
- * Binding exports.
- */
-
-export { Storage } from "./storage.js"
-export { Kv } from "./kv.js"
-export { Queue } from "./queue.js"
-export { Vault } from "./vault.js"
-export { Build } from "./build.js"
-export { ArtifactRegistry } from "./artifact-registry.js"
-export { WorkerBinding } from "./worker.js"
-export { ServiceAccount } from "./service-account.js"
-export { getPostgresConnection, type PostgresConnection } from "./postgres.js"