@alienplatform/sdk 1.14.1 → 2.0.1

package/src/bindings/worker.ts

@@ -1,164 +0,0 @@
-/**
- * Worker binding implementation.
- *
- * Provides direct worker-to-worker invocation.
- */
-
-import { type Channel, createClient } from "nice-grpc"
-import {
-  type WorkerServiceClient as GeneratedClient,
-  WorkerServiceDefinition,
-} from "../generated/worker.js"
-import { wrapGrpcCall } from "../grpc-utils.js"
-import type { WorkerInvokeRequest, WorkerInvokeResponse } from "../types.js"
-
-/**
- * Worker binding for direct worker invocation.
- *
- * @example
- * ```typescript
- * import { worker } from "@alienplatform/sdk"
- *
- * const processor = worker("image-processor")
- *
- * // Invoke with JSON body
- * const response = await processor.invokeJson("resize-image", {
- *   imageUrl: "https://...",
- *   width: 800,
- *   height: 600,
- * })
- *
- * // Get worker URL
- * const url = await processor.getUrl()
- * ```
- */
-export class WorkerBinding {
-  private readonly client: GeneratedClient
-  private readonly bindingName: string
-
-  constructor(channel: Channel, bindingName: string) {
-    this.client = createClient(WorkerServiceDefinition, channel)
-    this.bindingName = bindingName
-  }
-
-  /**
-   * Invoke a worker with raw request data.
-   *
-   * @param request - Invocation request
-   * @returns Worker response
-   */
-  async invoke(request: WorkerInvokeRequest): Promise<WorkerInvokeResponse> {
-    return await wrapGrpcCall(
-      "WorkerService",
-      "Invoke",
-      async () => {
-        const response = await this.client.invoke({
-          bindingName: this.bindingName,
-          targetWorker: request.targetWorker,
-          method: request.method,
-          path: request.path,
-          headers: request.headers ?? {},
-          body: request.body ?? new Uint8Array(),
-          timeoutSeconds: request.timeoutMs ? Math.floor(request.timeoutMs / 1000) : undefined,
-        })
-        return {
-          status: response.status,
-          headers: response.headers,
-          body: response.body,
-        }
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-
-  /**
-   * Invoke a worker with a JSON body.
-   *
-   * @param targetWorker - Target worker identifier
-   * @param body - JSON body
-   * @param options - Optional request options
-   * @returns Parsed JSON response
-   */
-  async invokeJson<TRequest, TResponse = unknown>(
-    targetWorker: string,
-    body: TRequest,
-    options?: {
-      method?: string
-      path?: string
-      headers?: Record<string, string>
-      timeoutMs?: number
-    },
-  ): Promise<TResponse> {
-    const response = await this.invoke({
-      targetWorker,
-      method: options?.method ?? "POST",
-      path: options?.path ?? "/",
-      headers: {
-        "content-type": "application/json",
-        ...options?.headers,
-      },
-      body: new TextEncoder().encode(JSON.stringify(body)),
-      timeoutMs: options?.timeoutMs,
-    })
-
-    if (response.status >= 400) {
-      const errorText = new TextDecoder().decode(response.body)
-      throw new Error(`Worker invocation failed with status ${response.status}: ${errorText}`)
-    }
-
-    const responseText = new TextDecoder().decode(response.body)
-    return JSON.parse(responseText) as TResponse
-  }
-
-  /**
-   * Invoke a worker with GET request.
-   *
-   * @param targetWorker - Target worker identifier
-   * @param path - Request path
-   * @param options - Optional request options
-   * @returns Parsed JSON response
-   */
-  async get<TResponse = unknown>(
-    targetWorker: string,
-    path = "/",
-    options?: {
-      headers?: Record<string, string>
-      timeoutMs?: number
-    },
-  ): Promise<TResponse> {
-    const response = await this.invoke({
-      targetWorker,
-      method: "GET",
-      path,
-      headers: options?.headers,
-      timeoutMs: options?.timeoutMs,
-    })
-
-    if (response.status >= 400) {
-      const errorText = new TextDecoder().decode(response.body)
-      throw new Error(`Worker GET failed with status ${response.status}: ${errorText}`)
-    }
-
-    const responseText = new TextDecoder().decode(response.body)
-    return JSON.parse(responseText) as TResponse
-  }
-
-  /**
-   * Get the public URL of the worker.
-   *
-   * @returns Worker URL if available
-   */
-  async getUrl(): Promise<string | undefined> {
-    return await wrapGrpcCall(
-      "WorkerService",
-      "GetWorkerUrl",
-      async () => {
-        const response = await this.client.getWorkerUrl({
-          bindingName: this.bindingName,
-        })
-        return response.url
-      },
-      { bindingName: this.bindingName },
-    )
-  }
-}

package/src/channel.ts

@@ -1,102 +0,0 @@
-/**
- * gRPC channel management for the Alien bindings SDK.
- */
-
-import { AlienError } from "@alienplatform/core"
-import type { ChannelOptions } from "@grpc/grpc-js"
-import { type Channel, createChannel } from "nice-grpc"
-import { GrpcConnectionError, MissingEnvVarError } from "./errors.js"
-
-/** Default channel options for gRPC connections */
-const DEFAULT_CHANNEL_OPTIONS: ChannelOptions = {
-  // Explicit message size limits (128 MB) to avoid platform-specific defaults
-  "grpc.max_send_message_length": 128 * 1024 * 1024,
-  "grpc.max_receive_message_length": 128 * 1024 * 1024,
-}
-
-/** Environment variable containing the gRPC endpoint */
-const GRPC_ENDPOINT_VAR = "ALIEN_BINDINGS_GRPC_ADDRESS"
-
-/** Cached channels by address */
-const channelCache = new Map<string, Channel>()
-
-/** Re-export the Channel type */
-export type GrpcChannel = Channel
-
-/**
- * Get the gRPC endpoint from environment variables.
- */
-export function getGrpcEndpoint(): string {
-  const endpoint = process.env[GRPC_ENDPOINT_VAR]
-  if (!endpoint) {
-    throw new AlienError(
-      MissingEnvVarError.create({
-        variable: GRPC_ENDPOINT_VAR,
-        description:
-          "This variable is set by alien-runtime when running inside the Alien environment.",
-      }),
-    )
-  }
-  return endpoint
-}
-
-/**
- * Create a gRPC channel to the specified address.
- *
- * @param address - The gRPC server address
- * @returns The created channel
- */
-export async function createGrpcChannel(address: string): Promise<Channel> {
-  try {
-    return createChannel(address, undefined, DEFAULT_CHANNEL_OPTIONS)
-  } catch (error) {
-    throw (await AlienError.from(error)).withContext(
-      GrpcConnectionError.create({
-        endpoint: address,
-        reason: error instanceof Error ? error.message : String(error),
-      }),
-    )
-  }
-}
-
-/**
- * Get or create a cached gRPC channel to the specified address.
- *
- * @param address - The gRPC server address
- * @returns The cached or newly created channel
- */
-export async function getOrCreateChannel(address: string): Promise<Channel> {
-  let channel = channelCache.get(address)
-  if (!channel) {
-    channel = await createGrpcChannel(address)
-    channelCache.set(address, channel)
-  }
-  return channel
-}
-
-/**
- * Get a gRPC channel to the alien-runtime using the default env var.
- * The channel is cached for reuse across all bindings.
- */
-export async function getChannel(): Promise<Channel> {
-  const endpoint = getGrpcEndpoint()
-  return await getOrCreateChannel(endpoint)
-}
-
-/**
- * Close all cached gRPC channels.
- * This should be called when shutting down the application.
- */
-export function closeChannel(): void {
-  for (const channel of channelCache.values()) {
-    channel.close()
-  }
-  channelCache.clear()
-}
-
-/**
- * Reset the cached channels (useful for testing).
- */
-export function resetChannel(): void {
-  channelCache.clear()
-}

package/src/commands/client.ts

@@ -1,446 +0,0 @@
-/**
- * Commands Client - Lightweight client for deployment command invocation
- *
- * Handles command invocation with automatic:
- * - Base64 encoding/decoding of params and responses
- * - Large payload upload/download via storage
- * - Polling with exponential backoff
- * - Error handling and timeout
- */
-
-import { AlienError } from "@alienplatform/core"
-import {
-  CommandCreationFailedError,
-  CommandExpiredError,
-  CommandTimeoutError,
-  DeploymentCommandError,
-  ManagerHttpError,
-  ResponseDecodingFailedError,
-  StorageOperationFailedError,
-} from "./errors.js"
-import type {
-  BodySpec,
-  CommandResponse,
-  CommandState,
-  CommandStatusResponse,
-  CommandsClientConfig,
-  CreateCommandResponse,
-  InvokeOptions,
-} from "./types.js"
-
-/**
- * Base64 encode data
- */
-function base64Encode(data: string | Record<string, unknown>): string {
-  const json = typeof data === "string" ? data : JSON.stringify(data)
-  if (typeof btoa !== "undefined") {
-    // Browser
-    return btoa(json)
-  }
-  // Node.js
-  return Buffer.from(json, "utf-8").toString("base64")
-}
-
-/**
- * Base64 decode data
- */
-function base64Decode(encoded: string): string {
-  if (typeof atob !== "undefined") {
-    // Browser
-    return atob(encoded)
-  }
-  // Node.js
-  return Buffer.from(encoded, "base64").toString("utf-8")
-}
-
-/**
- * Create inline body spec. Always sends inline — the server handles storage
- * decisions transparently (auto-promoting to blob if needed).
- */
-function createBodySpec(data: string | Record<string, unknown>): BodySpec {
-  const json = typeof data === "string" ? data : JSON.stringify(data)
-  return {
-    mode: "inline",
-    inlineBase64: base64Encode(json),
-  }
-}
-
-/**
- * Decode response body spec
- */
-async function decodeBodySpec(
-  body: BodySpec,
-  commandId: string,
-  command: string,
-  allowLocalStorage: boolean,
-): Promise<unknown> {
-  if (body.mode === "inline") {
-    const json = base64Decode(body.inlineBase64)
-    return JSON.parse(json)
-  }
-
-  if (body.mode === "storage") {
-    // Storage mode - download from presigned URL
-    if (!body.storageGetRequest) {
-      throw new AlienError(
-        ResponseDecodingFailedError.create({
-          commandId,
-          command,
-          reason: "Storage response missing storageGetRequest",
-        }),
-      )
-    }
-
-    const request = body.storageGetRequest
-
-    // Check if request has expired
-    const expiration = new Date(request.expiration)
-    if (Date.now() > expiration.getTime()) {
-      throw new AlienError(
-        StorageOperationFailedError.create({
-          operation: "download",
-          url: request.backend.type === "http" ? request.backend.url : "local",
-          reason: `Presigned request expired at ${expiration.toISOString()}`,
-        }),
-      )
-    }
-
-    // Handle different backend types
-    if (request.backend.type === "http") {
-      // HTTP backend (AWS S3, GCP GCS, Azure Blob)
-      try {
-        const response = await fetch(request.backend.url, {
-          method: request.backend.method,
-          headers: request.backend.headers,
-        })
-
-        if (!response.ok) {
-          throw new AlienError(
-            StorageOperationFailedError.create({
-              operation: "download",
-              url: request.backend.url,
-              reason: `HTTP ${response.status} ${response.statusText}`,
-            }),
-          )
-        }
-
-        const text = await response.text()
-        return JSON.parse(text)
-      } catch (error) {
-        if (error instanceof AlienError) {
-          throw error
-        }
-
-        // Wrap fetch/parse errors
-        const alienError = await AlienError.from(error)
-        throw alienError.withContext(
-          StorageOperationFailedError.create({
-            operation: "download",
-            url: request.backend.url,
-            reason: error instanceof Error ? error.message : String(error),
-          }),
-        )
-      }
-    } else if (request.backend.type === "local") {
-      // Local backend: Only enabled when explicitly allowed (local dev/testing)
-      if (!allowLocalStorage) {
-        throw new AlienError(
-          StorageOperationFailedError.create({
-            operation: "download",
-            url: `local://${request.backend.filePath}`,
-            reason: "Local storage backend not enabled (set allowLocalStorage: true for local dev)",
-          }),
-        )
-      }
-
-      // Validate path doesn't contain path traversal attempts
-      const filePath = request.backend.filePath
-      if (filePath.includes("..")) {
-        throw new AlienError(
-          StorageOperationFailedError.create({
-            operation: "download",
-            url: `local://${filePath}`,
-            reason: "Path traversal not allowed in local storage paths",
-          }),
-        )
-      }
-
-      // Dynamically import fs/promises only when needed (local dev)
-      try {
-        const { readFile } = await import("node:fs/promises")
-        const content = await readFile(filePath, "utf-8")
-        return JSON.parse(content)
-      } catch (error) {
-        if (error instanceof AlienError) {
-          throw error
-        }
-
-        // Wrap filesystem/parse errors
-        const alienError = await AlienError.from(error)
-        throw alienError.withContext(
-          StorageOperationFailedError.create({
-            operation: "download",
-            url: `local://${filePath}`,
-            reason: error instanceof Error ? error.message : String(error),
-          }),
-        )
-      }
-    } else {
-      throw new AlienError(
-        StorageOperationFailedError.create({
-          operation: "download",
-          url: "unknown",
-          reason: `Unknown storage backend type: ${(request.backend as any).type}`,
-        }),
-      )
-    }
-  }
-
-  throw new AlienError(
-    ResponseDecodingFailedError.create({
-      commandId,
-      command,
-      reason: `Unknown body mode: ${(body as any).mode}`,
-    }),
-  )
-}
-
-/**
- * Check if state is terminal
- */
-function isTerminalState(state: CommandState): boolean {
-  return state === "SUCCEEDED" || state === "FAILED" || state === "EXPIRED"
-}
-
-/**
- * Commands client for invoking deployment commands
- */
-export class CommandsClient {
-  private readonly managerUrl: string
-  private readonly deploymentId: string
-  private readonly token: string
-  private readonly defaultTimeout: number
-  private readonly allowLocalStorage: boolean
-
-  constructor(config: CommandsClientConfig) {
-    this.managerUrl = config.managerUrl.replace(/\/+$/, "")
-    this.deploymentId = config.deploymentId
-    this.token = config.token
-    this.defaultTimeout = config.timeout ?? 60_000
-    this.allowLocalStorage = config.allowLocalStorage ?? false
-  }
-
-  /**
-   * Invoke a command on the deployment and wait for response
-   *
-   * @param command - Command name (e.g., "generate-report")
-   * @param params - Command parameters (JSON-serializable)
-   * @param options - Invocation options
-   * @returns Decoded response data
-   */
-  async invoke<TParams = unknown, TResponse = unknown>(
-    command: string,
-    params: TParams,
-    options?: InvokeOptions,
-  ): Promise<TResponse> {
-    const timeout = options?.timeout ?? this.defaultTimeout
-    const startTime = Date.now()
-
-    // Step 1: Create command
-    const createResponse = await this.createCommand(command, params, options)
-
-    // Step 2: Poll for completion
-    const pollInterval = options?.pollInterval ?? 500
-    const maxPollInterval = options?.maxPollInterval ?? 5000
-    const pollBackoff = options?.pollBackoff ?? 1.5
-    let currentInterval = pollInterval
-
-    while (Date.now() - startTime < timeout) {
-      await this.sleep(currentInterval)
-
-      const status = await this.getCommandStatus(createResponse.commandId)
-
-      if (isTerminalState(status.state)) {
-        return await this.handleTerminalState(command, status)
-      }
-
-      // Exponential backoff
-      currentInterval = Math.min(currentInterval * pollBackoff, maxPollInterval)
-    }
-
-    // Timeout
-    const finalStatus = await this.getCommandStatus(createResponse.commandId)
-    throw new AlienError(
-      CommandTimeoutError.create({
-        commandId: createResponse.commandId,
-        command,
-        timeoutMs: timeout,
-        lastState: finalStatus.state,
-      }),
-    )
-  }
-
-  /**
-   * Create a command
-   */
-  private async createCommand(
-    command: string,
-    params: unknown,
-    options?: InvokeOptions,
-  ): Promise<CreateCommandResponse> {
-    const url = `${this.managerUrl}/v1/commands`
-    const body = {
-      deploymentId: this.deploymentId,
-      command,
-      params: createBodySpec(params as string | Record<string, unknown>),
-      deadline: options?.deadline?.toISOString(),
-      idempotencyKey: options?.idempotencyKey,
-    }
-
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.token}`,
-        },
-        body: JSON.stringify(body),
-      })
-
-      if (!response.ok) {
-        const errorBody = await response.text().catch(() => "")
-        throw new AlienError(
-          ManagerHttpError.create({
-            method: "POST",
-            url,
-            status: response.status,
-            statusText: response.statusText,
-            body: errorBody,
-          }),
-        )
-      }
-
-      return (await response.json()) as CreateCommandResponse
-    } catch (error) {
-      if (error instanceof AlienError) {
-        throw error
-      }
-
-      const alienError = await AlienError.from(error)
-      throw alienError.withContext(
-        CommandCreationFailedError.create({
-          deploymentId: this.deploymentId,
-          command,
-          reason: error instanceof Error ? error.message : String(error),
-        }),
-      )
-    }
-  }
-
-  /**
-   * Get command status
-   */
-  private async getCommandStatus(commandId: string): Promise<CommandStatusResponse> {
-    const url = `${this.managerUrl}/v1/commands/${commandId}`
-
-    try {
-      const response = await fetch(url, {
-        method: "GET",
-        headers: {
-          Authorization: `Bearer ${this.token}`,
-        },
-      })
-
-      if (!response.ok) {
-        const errorBody = await response.text().catch(() => "")
-        throw new AlienError(
-          ManagerHttpError.create({
-            method: "GET",
-            url,
-            status: response.status,
-            statusText: response.statusText,
-            body: errorBody,
-          }),
-        )
-      }
-
-      return (await response.json()) as CommandStatusResponse
-    } catch (error) {
-      if (error instanceof AlienError) {
-        throw error
-      }
-
-      throw await AlienError.from(error)
-    }
-  }
-
-  /**
-   * Handle terminal state and return response
-   */
-  private async handleTerminalState<TResponse>(
-    command: string,
-    status: CommandStatusResponse,
-  ): Promise<TResponse> {
-    if (status.state === "EXPIRED") {
-      throw new AlienError(
-        CommandExpiredError.create({
-          commandId: status.commandId,
-          command,
-        }),
-      )
-    }
-
-    if (!status.response) {
-      throw new AlienError(
-        ResponseDecodingFailedError.create({
-          commandId: status.commandId,
-          command,
-          reason: "Terminal state but no response present",
-        }),
-      )
-    }
-
-    const response: CommandResponse = status.response
-
-    if (response.status === "error") {
-      throw new AlienError(
-        DeploymentCommandError.create({
-          commandId: status.commandId,
-          command,
-          errorCode: response.code,
-          errorMessage: response.message,
-          errorDetails: response.details ?? undefined,
-        }),
-      )
-    }
-
-    // Decode success response
-    try {
-      return (await decodeBodySpec(
-        response.response,
-        status.commandId,
-        command,
-        this.allowLocalStorage,
-      )) as TResponse
-    } catch (error) {
-      if (error instanceof AlienError) {
-        throw error
-      }
-
-      throw new AlienError(
-        ResponseDecodingFailedError.create({
-          commandId: status.commandId,
-          command,
-          reason: error instanceof Error ? error.message : String(error),
-        }),
-      )
-    }
-  }
-
-  /**
-   * Sleep helper
-   */
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms))
-  }
-}