@alienplatform/bindings 1.0.0 → 2.0.0

package/scripts/generate-proto.sh

@@ -1,46 +0,0 @@
-#!/bin/bash
-
-# Generate TypeScript types from proto files using ts-proto + nice-grpc
-
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PACKAGE_DIR="$(dirname "$SCRIPT_DIR")"
-PROTO_DIR="$PACKAGE_DIR/../../crates/alien-bindings/proto"
-OUT_DIR="$PACKAGE_DIR/src/generated"
-
-# Clean and create output directory
-rm -rf "$OUT_DIR"
-mkdir -p "$OUT_DIR"
-
-# Find protoc - prefer system installation
-if command -v protoc &> /dev/null; then
-  PROTOC="protoc"
-else
-  echo "Error: protoc not found. Install via 'brew install protobuf' on macOS."
-  exit 1
-fi
-
-# Find ts-proto plugin
-TS_PROTO_PLUGIN="$PACKAGE_DIR/node_modules/.bin/protoc-gen-ts_proto"
-
-if [ ! -f "$TS_PROTO_PLUGIN" ]; then
-  echo "Error: protoc-gen-ts_proto not found. Run 'pnpm install' first."
-  exit 1
-fi
-
-echo "Using protoc: $PROTOC"
-echo "Using ts-proto plugin: $TS_PROTO_PLUGIN"
-echo "Generating TypeScript types from proto files..."
-
-# Generate types for all proto files
-# Using nice-grpc options as per the playbook
-"$PROTOC" \
-  --plugin="protoc-gen-ts_proto=$TS_PROTO_PLUGIN" \
-  --ts_proto_out="$OUT_DIR" \
-  --ts_proto_opt=outputServices=nice-grpc,outputServices=generic-definitions,useExactTypes=false,esModuleInterop=true,importSuffix=.js \
-  --proto_path="$PROTO_DIR" \
-  "$PROTO_DIR"/*.proto
-
-echo "Generated TypeScript types in $OUT_DIR"
-echo "Done!"

package/src/bindings/AGENTS.md

@@ -1,105 +0,0 @@
-# Binding Implementations
-
-Each TypeScript binding must match its Rust counterpart in `alien-bindings/src/providers/<name>/grpc.rs`.
-
-**Examples:**
-- `kv.ts` → `providers/kv/grpc.rs`
-- `storage.ts` → `providers/storage/grpc.rs`
-- `build.ts` → `providers/build/grpc.rs`
-
-## Core Pattern: Public API → gRPC → Public API
-
-```
-┌─────────────────┐       ┌─────────────────┐       ┌─────────────────┐
-│   Public API    │  →    │   gRPC Proto    │  →    │   Public API    │
-│   (SDK types)   │       │   (wire format) │       │   (SDK types)   │
-└─────────────────┘       └─────────────────┘       └─────────────────┘
-     User calls              Internal only            User receives
-```
-
-**Public API types** come from `@alienplatform/core` or `../types.ts`. Proto types are **internal only** - never exposed to users.
-
-```typescript
-// ❌ Bad - exposing proto types
-async getStatus(buildId: string): Promise<BuildExecutionProto>
-
-// ✅ Good - convert proto to public types
-async getStatus(buildId: string): Promise<BuildExecution> {
-  const response = await this.client.getBuildStatus({ ... })
-  return this.fromProtoExecution(response.execution!)  // Transform here
-}
-```
-
-## Guidelines
-
-### 1. Match All Rust Trait Methods
-Every method in the Rust trait must have a TypeScript equivalent. Check for missing methods when adding bindings.
-
-### 2. Match Rust Enum Fallbacks Exactly
-Rust often maps unknown/unspecified enum values to a specific fallback. TypeScript must match:
-
-```rust
-// Rust: maps Unspecified → Failed
-BuildStatus::Unspecified => BuildStatus::Failed,
-```
-```typescript
-// TypeScript: must match
-[BuildStatusProto.BUILD_STATUS_UNSPECIFIED]: "FAILED",  // NOT "QUEUED"
-```
-
-### 3. Transform Types in Private Helpers
-Keep transformations consistent and testable:
-
-```typescript
-private fromProtoExecution(proto: BuildExecutionProto): BuildExecution {
-  return {
-    id: proto.id,
-    status: statusMap[proto.status] ?? "FAILED",
-    startTime: proto.startTime ? new Date(proto.startTime) : undefined,
-  }
-}
-
-private toProtoConfig(config: BuildStartConfig): BuildConfigProto {
-  return {
-    script: config.script,
-    computeType: computeTypeMap[config.computeType] ?? ComputeType.UNSPECIFIED,
-  }
-}
-```
-
-### 4. Convert Units Consistently
-Rust uses `Duration`, TypeScript uses milliseconds:
-
-```typescript
-ttlSeconds: options.ttlMs ? Math.floor(options.ttlMs / 1000) : undefined
-timeoutSeconds: request.timeoutMs ? Math.floor(request.timeoutMs / 1000) : undefined
-```
-
-### 5. Use wrapGrpcCall for Error Handling
-Always wrap gRPC calls with context for proper error mapping:
-
-```typescript
-return await wrapGrpcCall(
-  "BuildService",
-  "GetBuildStatus",
-  async () => { ... },
-  { bindingName: this.bindingName },  // Context for error mapping
-)
-```
-
-### 6. Handle Optional Proto Fields
-Rust `Option<T>` becomes `T | undefined`. Use nullish coalescing:
-
-```typescript
-uri: proto.uri ?? "",
-createdAt: proto.createdAt ? new Date(proto.createdAt) : undefined,
-```
-
-## Convenience Methods
-
-TypeScript may add convenience methods not in Rust (e.g., `getJson()`, `exists()`, `waitForCompletion()`). These are fine if they build on core methods.
-
-## See Also
-
-- Parent: `packages/bindings/AGENTS.md` - Package overview and type architecture
-- Proto definitions: `crates/alien-bindings/proto/`

package/src/bindings/artifact-registry.ts

@@ -1,314 +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/bindings"
- *
- * 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 {
-      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,
-        },
-        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,
-        },
-      }
-    }
-    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 "function":
-        return ComputeServiceTypeProto.FUNCTION
-      default:
-        return ComputeServiceTypeProto.UNRECOGNIZED
-    }
-  }
-
-  private protoToComputeServiceType(st: ComputeServiceTypeProto): ComputeServiceType | undefined {
-    switch (st) {
-      case ComputeServiceTypeProto.FUNCTION:
-        return "function"
-      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/bindings"
- *
- * 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,
-    }
-  }
-}