@terminals-tech/sdk 1.0.0-rc.1 → 1.0.0-rc.2

package/dist/chunk-NTMBOESX.js

@@ -0,0 +1,152 @@
+// ../../lib/terminals-tech/core/base/retry.ts
+function calculateDelay(attempt, baseDelayMs, maxDelayMs, jitter = 0) {
+  let delay = baseDelayMs * Math.pow(2, attempt);
+  delay = Math.min(delay, maxDelayMs);
+  if (jitter > 0) {
+    const jitterAmount = delay * jitter * Math.random();
+    delay = delay + jitterAmount - jitter * delay / 2;
+    delay = Math.max(baseDelayMs, delay);
+  }
+  return Math.floor(delay);
+}
+function exponentialBackoff(options = {}) {
+  return {
+    maxAttempts: options.maxAttempts ?? 3,
+    baseDelayMs: options.baseDelayMs ?? 100,
+    maxDelayMs: options.maxDelayMs ?? 1e4,
+    jitter: options.jitter ?? 0.1,
+    shouldRetry: options.shouldRetry ?? defaultShouldRetry
+  };
+}
+function defaultShouldRetry(error, _attempt) {
+  if (error.name === "TypeError" && error.message.includes("fetch")) {
+    return true;
+  }
+  if (error.name === "AbortError") {
+    return false;
+  }
+  if ("status" in error) {
+    const status = error.status;
+    return status >= 500 || status === 429;
+  }
+  return true;
+}
+async function withRetry(fn, strategyOrOptions = {}) {
+  const strategy = "maxAttempts" in strategyOrOptions && "shouldRetry" in strategyOrOptions ? strategyOrOptions : exponentialBackoff(strategyOrOptions);
+  const options = strategyOrOptions;
+  let lastError = null;
+  for (let attempt = 0; attempt < strategy.maxAttempts; attempt++) {
+    if (options.signal?.aborted) {
+      throw new DOMException("Operation was aborted", "AbortError");
+    }
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      const isLastAttempt = attempt >= strategy.maxAttempts - 1;
+      if (isLastAttempt || !strategy.shouldRetry(lastError, attempt)) {
+        throw lastError;
+      }
+      const delay = calculateDelay(
+        attempt,
+        strategy.baseDelayMs,
+        strategy.maxDelayMs,
+        strategy.jitter
+      );
+      options.onRetry?.(lastError, attempt + 1, delay);
+      await new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(resolve, delay);
+        if (options.signal) {
+          const abortHandler = () => {
+            clearTimeout(timeoutId);
+            reject(new DOMException("Operation was aborted", "AbortError"));
+          };
+          options.signal.addEventListener("abort", abortHandler, {
+            once: true
+          });
+        }
+      });
+    }
+  }
+  throw lastError ?? new Error("Retry failed");
+}
+function createCircuitBreaker(options) {
+  const state = {
+    failures: 0,
+    lastFailure: null,
+    isOpen: false,
+    nextAttempt: null
+  };
+  let halfOpenInFlight = 0;
+  return {
+    /**
+     * Execute function with circuit breaker protection.
+     *
+     * States:
+     *   CLOSED  — failures < threshold, all requests pass through
+     *   OPEN    — failures >= threshold, fast-fails until resetTimeoutMs elapses
+     *   HALF_OPEN — resetTimeoutMs elapsed, allows `halfOpenRequests` concurrent probes
+     *
+     * Transitions:
+     *   T1: CLOSED → CLOSED (success resets failures)
+     *   T2: CLOSED → OPEN   (failure hits threshold)
+     *   T3: OPEN   → OPEN   (fast-fail, time not elapsed)
+     *   T4: OPEN   → HALF_OPEN (time elapsed, probe allowed)
+     *   T5: HALF_OPEN → CLOSED (probe succeeds)
+     *   T6: HALF_OPEN → OPEN   (probe fails)
+     */
+    async execute(fn) {
+      if (state.isOpen) {
+        const now = Date.now();
+        if (state.nextAttempt && now < state.nextAttempt) {
+          throw new Error("Circuit breaker is open");
+        }
+        if (options.halfOpenRequests != null && halfOpenInFlight >= options.halfOpenRequests) {
+          throw new Error("Circuit breaker half-open \u2014 probe limit reached");
+        }
+        halfOpenInFlight++;
+      }
+      try {
+        const result = await fn();
+        state.failures = 0;
+        state.isOpen = false;
+        state.nextAttempt = null;
+        halfOpenInFlight = 0;
+        return result;
+      } catch (error) {
+        if (state.isOpen) {
+          halfOpenInFlight = Math.max(0, halfOpenInFlight - 1);
+        }
+        state.failures++;
+        state.lastFailure = Date.now();
+        if (state.failures >= options.failureThreshold) {
+          state.isOpen = true;
+          state.nextAttempt = Date.now() + options.resetTimeoutMs;
+          halfOpenInFlight = 0;
+        }
+        throw error;
+      }
+    },
+    /**
+     * Get current state
+     */
+    getState() {
+      return { ...state };
+    },
+    /**
+     * Manually reset the circuit breaker
+     */
+    reset() {
+      state.failures = 0;
+      state.lastFailure = null;
+      state.isOpen = false;
+      state.nextAttempt = null;
+      halfOpenInFlight = 0;
+    }
+  };
+}
+
+export {
+  withRetry,
+  createCircuitBreaker
+};

package/dist/chunk-OSSRZOGC.js

@@ -0,0 +1,190 @@
+// ../../lib/errors/types.ts
+var ErrorCodes = {
+  // Auth errors
+  AUTH_TOKEN_EXPIRED: "AUTH_TOKEN_EXPIRED",
+  AUTH_TOKEN_REFRESH_FAILED: "AUTH_TOKEN_REFRESH_FAILED",
+  AUTH_SESSION_INVALID: "AUTH_SESSION_INVALID",
+  AUTH_INIT_RACE: "AUTH_INIT_RACE",
+  AUTH_PROVIDER_UNAVAILABLE: "AUTH_PROVIDER_UNAVAILABLE",
+  // Inference errors
+  INFERENCE_PROVIDER_UNAVAILABLE: "INFERENCE_PROVIDER_UNAVAILABLE",
+  INFERENCE_CIRCUIT_OPEN: "INFERENCE_CIRCUIT_OPEN",
+  INFERENCE_TIMEOUT: "INFERENCE_TIMEOUT",
+  INFERENCE_RATE_LIMITED: "INFERENCE_RATE_LIMITED",
+  INFERENCE_API_ERROR: "INFERENCE_API_ERROR",
+  // Sync errors
+  SYNC_CONFLICT: "SYNC_CONFLICT",
+  SYNC_OFFLINE: "SYNC_OFFLINE",
+  SYNC_FAILED: "SYNC_FAILED",
+  SYNC_LEADER_CHANGED: "SYNC_LEADER_CHANGED",
+  // MCP errors
+  MCP_CONNECTION_FAILED: "MCP_CONNECTION_FAILED",
+  MCP_TOOL_EXECUTION_FAILED: "MCP_TOOL_EXECUTION_FAILED",
+  MCP_SERVER_UNAVAILABLE: "MCP_SERVER_UNAVAILABLE",
+  // WebContainer errors
+  WEBCONTAINER_NOT_SUPPORTED: "WEBCONTAINER_NOT_SUPPORTED",
+  WEBCONTAINER_COOP_MISSING: "WEBCONTAINER_COOP_MISSING",
+  WEBCONTAINER_BOOT_FAILED: "WEBCONTAINER_BOOT_FAILED",
+  WEBCONTAINER_FS_ERROR: "WEBCONTAINER_FS_ERROR",
+  // Network errors
+  NETWORK_OFFLINE: "NETWORK_OFFLINE",
+  NETWORK_TIMEOUT: "NETWORK_TIMEOUT",
+  NETWORK_DNS_FAILED: "NETWORK_DNS_FAILED",
+  // Storage errors
+  STORAGE_QUOTA_EXCEEDED: "STORAGE_QUOTA_EXCEEDED",
+  STORAGE_ACCESS_DENIED: "STORAGE_ACCESS_DENIED",
+  STORAGE_CORRUPTED: "STORAGE_CORRUPTED",
+  // Platform errors
+  PLATFORM_STACK_FAILED: "PLATFORM_STACK_FAILED",
+  PLATFORM_NODE_FAILED: "PLATFORM_NODE_FAILED",
+  PLATFORM_TRAINING_FAILED: "PLATFORM_TRAINING_FAILED",
+  PLATFORM_TRAINING_NOT_CONFIGURED: "PLATFORM_TRAINING_NOT_CONFIGURED",
+  PLATFORM_TRAINING_UNAUTHORIZED: "PLATFORM_TRAINING_UNAUTHORIZED",
+  PLATFORM_TRAINING_OFFLINE: "PLATFORM_TRAINING_OFFLINE",
+  PLATFORM_TRAINING_RATE_LIMITED: "PLATFORM_TRAINING_RATE_LIMITED",
+  PLATFORM_TRAINING_INVALID_REQUEST: "PLATFORM_TRAINING_INVALID_REQUEST",
+  // Generic
+  UNKNOWN_ERROR: "UNKNOWN_ERROR",
+  RUNAWAY_ERRORS: "RUNAWAY_ERRORS"
+};
+var DEFAULT_ERROR_BUS_CONFIG = {
+  dedupWindowMs: 5e3,
+  maxErrorsBeforeCutoff: 100,
+  retentionMs: 5 * 60 * 1e3,
+  maxPerSourcePerMinute: 10,
+  cutoffPauseMs: 3e4
+};
+
+// ../../lib/errors/base.ts
+var TerminalsError = class _TerminalsError extends Error {
+  /** Error source domain */
+  source;
+  /** Machine-readable error code */
+  code;
+  /** Error severity level */
+  severity;
+  /** Whether the operation can be retried */
+  retryable;
+  /** Whether error should be shown to user */
+  userFacing;
+  /** Additional context/metadata */
+  metadata;
+  /** Original error if this wraps another error */
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = this.constructor.name;
+    this.source = options.source;
+    this.code = options.code;
+    this.severity = options.severity ?? "error";
+    this.retryable = options.retryable ?? false;
+    this.userFacing = options.userFacing ?? false;
+    this.metadata = options.metadata;
+    this.cause = options.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Convert to ErrorInput for error bus emission.
+   */
+  toErrorInput() {
+    return {
+      source: this.source,
+      severity: this.severity,
+      message: this.message,
+      code: this.code,
+      userFacing: this.userFacing,
+      retryable: this.retryable,
+      metadata: {
+        ...this.metadata,
+        errorName: this.name,
+        ...this.cause && {
+          causeName: this.cause.name,
+          causeMessage: this.cause.message
+        }
+      }
+    };
+  }
+  /**
+   * Serialize for logging/transmission.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      source: this.source,
+      code: this.code,
+      severity: this.severity,
+      retryable: this.retryable,
+      userFacing: this.userFacing,
+      metadata: this.metadata,
+      stack: this.stack,
+      cause: this.cause ? { name: this.cause.name, message: this.cause.message } : void 0
+    };
+  }
+  /**
+   * Create from an unknown error.
+   */
+  static fromUnknown(error, source = "unknown") {
+    if (error instanceof _TerminalsError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      return new _TerminalsError(error.message, {
+        source,
+        code: ErrorCodes.UNKNOWN_ERROR,
+        severity: "error",
+        cause: error
+      });
+    }
+    return new _TerminalsError(String(error), {
+      source,
+      code: ErrorCodes.UNKNOWN_ERROR,
+      severity: "error"
+    });
+  }
+};
+var SyncError = class extends TerminalsError {
+  constructor(message, code = ErrorCodes.SYNC_FAILED, metadata) {
+    super(message, {
+      source: "sync",
+      code,
+      severity: code === ErrorCodes.SYNC_CONFLICT ? "warn" : "error",
+      retryable: code !== ErrorCodes.SYNC_CONFLICT,
+      userFacing: code === ErrorCodes.SYNC_OFFLINE,
+      metadata
+    });
+  }
+};
+var MCPError = class extends TerminalsError {
+  constructor(message, code = ErrorCodes.MCP_CONNECTION_FAILED, metadata) {
+    super(message, {
+      source: "mcp",
+      code,
+      severity: code === ErrorCodes.MCP_SERVER_UNAVAILABLE ? "warn" : "error",
+      retryable: code !== ErrorCodes.MCP_TOOL_EXECUTION_FAILED,
+      userFacing: true,
+      metadata
+    });
+  }
+};
+var WebContainerError = class extends TerminalsError {
+  constructor(message, code = ErrorCodes.WEBCONTAINER_BOOT_FAILED, metadata) {
+    super(message, {
+      source: "webcontainer",
+      code,
+      severity: code === ErrorCodes.WEBCONTAINER_NOT_SUPPORTED ? "info" : "error",
+      retryable: code === ErrorCodes.WEBCONTAINER_BOOT_FAILED,
+      userFacing: true,
+      metadata
+    });
+  }
+};
+
+export {
+  ErrorCodes,
+  SyncError,
+  MCPError,
+  WebContainerError
+};