@stacksjs/ts-cloud-core 0.1.3 → 0.1.7

package/dist/aws/signature.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Detect service and region from AWS URL
+ * Supports standard AWS endpoints, Lambda URLs, R2, and Backblaze B2
+ */
+export declare function detectServiceRegion(url: string | URL): { service: string, region: string };
+/**
+ * Sign an AWS request using Signature Version 4
+ */
+export declare function signRequest(options: SignatureOptions): SignedRequest;
+/**
+ * Sign an AWS request using Signature Version 4 (async - browser compatible)
+ * Use this in browser environments where crypto.subtle is available
+ */
+export declare function signRequestAsync(options: SignatureOptions): Promise<SignedRequest>;
+/**
+ * Generate a presigned URL for AWS requests (e.g., S3 GetObject, PutObject)
+ */
+export declare function createPresignedUrl(options: PresignedUrlOptions): string;
+/**
+ * Generate a presigned URL for AWS requests (async - browser compatible)
+ */
+export declare function createPresignedUrlAsync(options: PresignedUrlOptions): Promise<string>;
+/**
+ * Make a signed AWS API request with automatic retry
+ */
+export declare function makeAWSRequest(options: SignatureOptions, retryOptions?: RetryOptions): Promise<Response>;
+/**
+ * Make a signed AWS API request without retry (for backwards compatibility)
+ */
+export declare function makeAWSRequestOnce(options: SignatureOptions): Promise<Response>;
+/**
+ * Make a signed AWS API request with automatic retry (async - browser compatible)
+ * Use this in browser environments where crypto.subtle is available
+ */
+export declare function makeAWSRequestAsync(options: SignatureOptions, retryOptions?: RetryOptions): Promise<Response>;
+/**
+ * Parse XML response from AWS
+ */
+export declare function parseXMLResponse<T = any>(response: Response): Promise<T>;
+/**
+ * Parse JSON response from AWS
+ */
+export declare function parseJSONResponse<T = any>(response: Response): Promise<T>;
+/**
+ * Clear the internal signing key cache
+ * Call this when credentials change or for testing
+ */
+export declare function clearSigningKeyCache(): void;
+/**
+ * Get current cache size (for diagnostics)
+ */
+export declare function getSigningKeyCacheSize(): number;
+/**
+ * Check if Node.js crypto is available (for sync operations)
+ * Returns true in Node.js/Bun, false in browser
+ */
+export declare function isNodeCryptoAvailable(): boolean;
+/**
+ * Check if Web Crypto API is available (for async operations)
+ * Returns true in modern browsers and Node.js 15+
+ */
+export declare function isWebCryptoAvailable(): boolean;
+export declare interface SignatureOptions {
+  method: string
+  url: string
+  service?: string
+  region?: string
+  headers?: Record<string, string>
+  body?: string
+  accessKeyId: string
+  secretAccessKey: string
+  sessionToken?: string
+  cache?: Map<string, Buffer | Uint8Array>
+  signQuery?: boolean
+  expiresIn?: number
+  datetime?: string
+}
+export declare interface SignedRequest {
+  url: string
+  method: string
+  headers: Record<string, string>
+  body?: string
+}
+export declare interface PresignedUrlOptions {
+  url: string
+  method?: string
+  accessKeyId: string
+  secretAccessKey: string
+  sessionToken?: string
+  service?: string
+  region?: string
+  expiresIn?: number
+  cache?: Map<string, Buffer | Uint8Array>
+}
+export declare interface RetryOptions {
+  maxRetries?: number
+  initialDelayMs?: number
+  maxDelayMs?: number
+  retryableStatusCodes?: number[]
+  timeoutMs?: number
+}

package/dist/backup/disaster-recovery.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Global disaster recovery manager instance
+ */
+export declare const drManager: DisasterRecoveryManager;
+/**
+ * Disaster Recovery Module
+ * Automated failover, recovery runbooks, and DR testing
+ */
+export declare interface DisasterRecoveryPlan {
+  id: string
+  name: string
+  primaryRegion: string
+  secondaryRegion: string
+  rto: number
+  rpo: number
+  resources: DRResource[]
+  runbook: RecoveryRunbook
+  testSchedule?: string
+}
+export declare interface DRResource {
+  resourceId: string
+  resourceType: 'rds' | 'dynamodb' | 'efs' | 's3' | 'ec2' | 'ecs'
+  primaryArn: string
+  secondaryArn?: string
+  replicationEnabled: boolean
+}
+export declare interface RecoveryRunbook {
+  steps: RecoveryStep[]
+  estimatedDuration: number
+  requiredApprovals?: string[]
+}
+export declare interface RecoveryStep {
+  order: number
+  name: string
+  description: string
+  action: string
+  automatable: boolean
+  estimatedDuration: number
+  rollbackable: boolean
+}
+export declare interface FailoverTest {
+  id: string
+  planId: string
+  status: 'scheduled' | 'running' | 'completed' | 'failed'
+  startTime: Date
+  endTime?: Date
+  results?: FailoverTestResult[]
+}
+export declare interface FailoverTestResult {
+  step: string
+  status: 'success' | 'failed' | 'skipped'
+  duration: number
+  message?: string
+}
+/**
+ * Disaster recovery manager
+ */
+export declare class DisasterRecoveryManager {
+  private drPlans: Map<string, DisasterRecoveryPlan>;
+  private failoverTests: Map<string, FailoverTest>;
+  private planCounter: any;
+  private testCounter: any;
+  createDRPlan(plan: Omit<DisasterRecoveryPlan, 'id'>): DisasterRecoveryPlan;
+  createRDSDRPlan(options: {
+    primaryDbArn: string
+    secondaryDbArn: string
+    primaryRegion: string
+    secondaryRegion: string
+    rto?: number
+    rpo?: number
+  }): DisasterRecoveryPlan;
+  createDynamoDBDRPlan(options: {
+    tableArn: string
+    regions: string[]
+    rto?: number
+    rpo?: number
+  }): DisasterRecoveryPlan;
+  private generateRDSRunbook(primaryRegion: string, secondaryRegion: string): RecoveryRunbook;
+  private generateDynamoDBRunbook(regions: string[]): RecoveryRunbook;
+  executeFailover(planId: string, dryRun?: boolean): Promise<{
+    success: boolean
+    duration: number
+    completedSteps: number
+    failedStep?: string
+  }>;
+  scheduleFailoverTest(planId: string, testDate: Date): FailoverTest;
+  runFailoverTest(planId: string): Promise<FailoverTest>;
+  getDRPlan(id: string): DisasterRecoveryPlan | undefined;
+  listDRPlans(): DisasterRecoveryPlan[];
+  getFailoverTest(id: string): FailoverTest | undefined;
+  listFailoverTests(): FailoverTest[];
+  validateDRPlan(plan: DisasterRecoveryPlan): {
+    valid: boolean
+    warnings: string[]
+    errors: string[]
+  };
+  clear(): void;
+}

package/{src/backup/index.ts → dist/backup/index.d.ts}

@@ -1,14 +1,3 @@
-/**
- * Backup & Disaster Recovery
- * Automated backup schedules and disaster recovery planning
- */
-
-// Backup Manager
-export {
-  BackupManager,
-  backupManager,
-} from './manager'
-
 export type {
   BackupPlan,
   BackupResource,
@@ -16,14 +5,7 @@ export type {
   BackupVault,
   RestoreJob,
   ContinuousBackup,
-} from './manager'
-
-// Disaster Recovery
-export {
-  DisasterRecoveryManager,
-  drManager,
-} from './disaster-recovery'
-
+} from './manager';
 export type {
   DisasterRecoveryPlan,
   DRResource,
@@ -31,4 +13,12 @@ export type {
   RecoveryStep,
   FailoverTest,
   FailoverTestResult,
-} from './disaster-recovery'
+} from './disaster-recovery';
+export {
+  BackupManager,
+  backupManager,
+} from './manager';
+export {
+  DisasterRecoveryManager,
+  drManager,
+} from './disaster-recovery';

package/dist/backup/manager.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Global backup manager instance
+ */
+export declare const backupManager: BackupManager;
+/**
+ * Backup & Disaster Recovery Manager
+ * Automated backup schedules and disaster recovery
+ */
+export declare interface BackupPlan {
+  id: string
+  name: string
+  schedule: string
+  retentionDays: number
+  vaultName: string
+  resources: BackupResource[]
+  lifecycle?: BackupLifecycle
+  tags?: Record<string, string>
+}
+export declare interface BackupResource {
+  resourceArn: string
+  resourceType: 'rds' | 's3' | 'ebs' | 'efs' | 'dynamodb' | 'ec2'
+  region: string
+}
+export declare interface BackupLifecycle {
+  moveTocoldStorageAfterDays?: number
+  deleteAfterDays?: number
+}
+export declare interface BackupVault {
+  name: string
+  region: string
+  encryptionKeyArn?: string
+  accessPolicy?: any
+}
+export declare interface RestoreJob {
+  id: string
+  backupId: string
+  resourceType: string
+  status: 'pending' | 'running' | 'completed' | 'failed'
+  startTime: Date
+  endTime?: Date
+  targetRegion?: string
+  error?: string
+}
+export declare interface ContinuousBackup {
+  id: string
+  resourceId: string
+  enabled: boolean
+  retentionDays: number
+}
+/**
+ * Backup manager for automated backup and recovery
+ */
+export declare class BackupManager {
+  private backupPlans: Map<string, BackupPlan>;
+  private backupVaults: Map<string, BackupVault>;
+  private restoreJobs: Map<string, RestoreJob>;
+  private continuousBackups: Map<string, ContinuousBackup>;
+  private planCounter: any;
+  private restoreCounter: any;
+  private continuousBackupCounter: any;
+  createVault(vault: BackupVault): void;
+  getVault(name: string): BackupVault | undefined;
+  createBackupPlan(plan: Omit<BackupPlan, 'id'>): BackupPlan;
+  getBackupPlan(id: string): BackupPlan | undefined;
+  listBackupPlans(): BackupPlan[];
+  createRDSBackupPlan(options: {
+    dbInstanceArn: string
+    schedule?: string
+    retentionDays?: number
+    vaultName?: string
+  }): BackupPlan;
+  createDynamoDBBackupPlan(options: {
+    tableArn: string
+    schedule?: string
+    retentionDays?: number
+    crossRegionCopy?: string[]
+  }): BackupPlan;
+  createEFSBackupPlan(options: {
+    fileSystemArn: string
+    schedule?: string
+    retentionDays?: number
+  }): BackupPlan;
+  enableContinuousBackup(resourceId: string, retentionDays?: any): ContinuousBackup;
+  getContinuousBackup(id: string): ContinuousBackup | undefined;
+  enablePointInTimeRecovery(resourceArn: string, resourceType: 'rds' | 'dynamodb'): {
+    enabled: boolean
+    earliestRestorableTime: Date
+    latestRestorableTime: Date
+  };
+  restoreFromBackup(options: {
+    backupId: string
+    resourceType: string
+    targetRegion?: string
+  }): Promise<RestoreJob>;
+  restoreToPointInTime(options: {
+    sourceResourceArn: string
+    targetResourceName: string
+    restoreTime: Date
+    resourceType: 'rds' | 'dynamodb'
+  }): Promise<RestoreJob>;
+  getRestoreJob(id: string): RestoreJob | undefined;
+  listRestoreJobs(): RestoreJob[];
+  setupCrossRegionReplication(options: {
+    sourceVault: string
+    sourceRegion: string
+    targetRegions: string[]
+  }): void;
+  generateBackupVaultCF(vault: BackupVault): any;
+  generateBackupPlanCF(plan: BackupPlan): any;
+  generateBackupSelectionCF(plan: BackupPlan): any;
+  clear(): void;
+}

package/dist/cicd/circleci.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Generate deployment config
+ */
+export declare function generateDeploymentConfig(options?: CircleCIOptions): string;
+/**
+ * Generate multi-environment config
+ */
+export declare function generateMultiEnvConfig(options: {
+  environments: Array<{ name: string; branch: string }>
+  awsRegion?: string
+}): string;
+/**
+ * Generate scheduled workflow config
+ */
+export declare function generateScheduledConfig(options: {
+  schedule: string
+  environment: string
+  awsRegion?: string
+}): string;
+/**
+ * Generate approval workflow config
+ */
+export declare function generateApprovalConfig(options: {
+  environments: string[]
+  awsRegion?: string
+}): string;
+/**
+ * Generate parallel deployment config
+ */
+export declare function generateParallelConfig(options: {
+  regions: string[]
+  environment: string
+  awsRegion?: string
+}): string;
+/**
+ * CircleCI Configuration Generator
+ * Generate CI/CD pipelines for CircleCI
+ */
+export declare interface CircleCIOptions {
+  awsRegion?: string
+  dockerImage?: string
+  bunVersion?: string
+  deployCommand?: string
+  testCommand?: string
+  buildCommand?: string
+  workflows?: boolean
+}

package/dist/cicd/github-actions.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Generate deployment workflow
+ */
+export declare function generateDeploymentWorkflow(options?: GitHubActionsOptions): string;
+/**
+ * Generate multi-environment deployment workflow
+ */
+export declare function generateMultiEnvWorkflow(options: {
+  environments: Array<{ name: string; branch: string }>
+  awsRegion?: string
+  awsRole?: string
+}): string;
+/**
+ * Generate PR preview workflow
+ */
+export declare function generatePRPreviewWorkflow(options?: {
+  awsRegion?: string
+  awsRole?: string
+  ttl?: number
+}): string;
+/**
+ * Generate scheduled deployment workflow
+ */
+export declare function generateScheduledWorkflow(options: {
+  schedule: string
+  environment: string
+  awsRegion?: string
+  awsRole?: string
+}): string;
+/**
+ * Generate matrix deployment workflow (multiple regions/accounts)
+ */
+export declare function generateMatrixWorkflow(options: {
+  matrix: Array<{ environment: string; region: string; account?: string }>
+  awsRole?: string
+}): string;
+/**
+ * GitHub Actions Workflow Generator
+ * Generate CI/CD workflows for GitHub Actions
+ */
+export declare interface GitHubActionsOptions {
+  workflowName?: string
+  trigger?: 'push' | 'pull_request' | 'workflow_dispatch' | 'schedule'
+  branches?: string[]
+  schedule?: string
+  environments?: string[]
+  awsRegion?: string
+  awsRole?: string
+  nodeVersion?: string
+  bunVersion?: string
+  deployCommand?: string
+  testCommand?: string
+  buildCommand?: string
+  lintCommand?: string
+}

package/dist/cicd/gitlab-ci.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Generate deployment pipeline
+ */
+export declare function generateDeploymentPipeline(options?: GitLabCIOptions): string;
+/**
+ * Generate multi-environment pipeline
+ */
+export declare function generateMultiEnvPipeline(options: {
+  environments: Array<{ name: string; branch: string; manual?: boolean }>
+  awsRegion?: string
+}): string;
+/**
+ * Generate PR/MR preview pipeline
+ */
+export declare function generatePreviewPipeline(options?: {
+  awsRegion?: string
+  ttl?: number
+}): string;
+/**
+ * Generate scheduled pipeline
+ */
+export declare function generateScheduledPipeline(options: {
+  environment: string
+  awsRegion?: string
+}): string;
+/**
+ * Generate manual deployment pipeline
+ */
+export declare function generateManualPipeline(options: {
+  environments: string[]
+  awsRegion?: string
+}): string;
+/**
+ * GitLab CI/CD Pipeline Generator
+ * Generate CI/CD pipelines for GitLab
+ */
+export declare interface GitLabCIOptions {
+  stages?: string[]
+  environments?: string[]
+  awsRegion?: string
+  dockerImage?: string
+  bunVersion?: string
+  deployCommand?: string
+  testCommand?: string
+  buildCommand?: string
+}

package/dist/cicd/index.d.ts

@@ -0,0 +1,3 @@
+export * from './github-actions';
+export * from './gitlab-ci';
+export * from './circleci';

package/dist/cli/history.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Format history for display
+ */
+export declare function formatHistory(entries: HistoryEntry[], options?: { maxWidth?: number }): string;
+/**
+ * Format history statistics
+ */
+export declare function formatHistoryStats(stats: ReturnType<CommandHistory['getStats']>): string;
+/**
+ * Command history with search and persistence
+ * Tracks executed commands and provides search/replay functionality
+ */
+export declare interface HistoryEntry {
+  command: string
+  timestamp: Date
+  success: boolean
+  duration?: number
+  output?: string
+}
+export declare interface HistoryOptions {
+  maxSize?: number
+  persistFile?: string
+  trackOutput?: boolean
+}
+/**
+ * Command history manager
+ */
+export declare class CommandHistory {
+  private entries: HistoryEntry[];
+  private maxSize: number;
+  private persistFile?: string;
+  private trackOutput: boolean;
+  constructor(options?: HistoryOptions);
+  add(entry: Omit<HistoryEntry, 'timestamp'>): void;
+  getAll(): HistoryEntry[];
+  getRecent(count?: number): HistoryEntry[];
+  search(query: string): HistoryEntry[];
+  searchByDate(startDate: Date, endDate: Date): HistoryEntry[];
+  getSuccessful(): HistoryEntry[];
+  getFailed(): HistoryEntry[];
+  getMostUsed(count?: number): Array<{ command: string; count: number }>;
+  getStats(): {
+    total: number
+    successful: number
+    failed: number
+    averageDuration: number
+    mostUsed: string
+  };
+  clear(): void;
+  getByIndex(index: number): HistoryEntry | undefined;
+  removeByIndex(index: number): void;
+  save(): Promise<void>;
+  load(): Promise<void>;
+  exportJSON(): string;
+  exportCSV(): string;
+  importJSON(json: string): void;
+  groupByDate(): Map<string, HistoryEntry[]>;
+  groupByCommand(): Map<string, HistoryEntry[]>;
+  replay(index: number): string | undefined;
+  getSuggestions(partial: string, limit?: number): string[];
+  analyzePatterns(): {
+    timeOfDay: Map<number, number> // hour -> count
+    dayOfWeek: Map<number, number> // day -> count
+    successRate: number
+  };
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,5 @@
+export * from './table';
+export * from './progress';
+export * from './suggestions';
+export * from './repl';
+export * from './history';

package/dist/cli/progress.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Progress tracking with ETA and status updates
+ * Provides interactive progress bars and status indicators
+ */
+export declare interface ProgressOptions {
+  total: number
+  current?: number
+  width?: number
+  format?: string
+  message?: string
+  showETA?: boolean
+  showPercentage?: boolean
+  showCounter?: boolean
+}
+/**
+ * Multi-step progress tracker
+ */
+export declare interface Step {
+  name: string
+  status: 'pending' | 'active' | 'completed' | 'failed' | 'skipped'
+  message?: string
+  error?: string
+}
+/**
+ * Task list with status tracking
+ */
+export declare interface Task {
+  title: string
+  status: 'pending' | 'running' | 'completed' | 'failed'
+  output?: string
+}
+/**
+ * Progress bar with ETA calculation
+ */
+export declare class ProgressBar {
+  private total: number;
+  private current: number;
+  private width: number;
+  private format: string;
+  private message: string;
+  private showETA: boolean;
+  private showPercentage: boolean;
+  private showCounter: boolean;
+  private startTime: number;
+  private lastUpdate: number;
+  constructor(options: ProgressOptions);
+  tick(amount?: number): void;
+  update(current: number): void;
+  setMessage(message: string): void;
+  getPercentage(): number;
+  getETA(): number;
+  getETAFormatted(): string;
+  render(): string;
+  isComplete(): boolean;
+}
+export declare class MultiStepProgress {
+  private steps: Step[];
+  private currentStepIndex: number;
+  constructor(stepNames: string[]);
+  startStep(index: number, message?: string): void;
+  completeStep(message?: string): void;
+  failStep(error: string): void;
+  skipStep(message?: string): void;
+  getStep(index: number): Step | undefined;
+  getSteps(): Step[];
+  render(): string;
+  private getStatusIcon(status: Step['status']): string;
+  isComplete(): boolean;
+  hasFailed(): boolean;
+}
+/**
+ * Spinner for indeterminate progress
+ */
+export declare class Spinner {
+  private frames: string[];
+  private currentFrame: number;
+  private message: string;
+  private interval: Timer | null;
+  constructor(message?: string);
+  start(): void;
+  stop(): void;
+  setMessage(message: string): void;
+  render(): string;
+  succeed(message?: string): string;
+  fail(message?: string): string;
+  warn(message?: string): string;
+  info(message?: string): string;
+}
+export declare class TaskList {
+  private tasks: Task[];
+  add(title: string): number;
+  start(index: number): void;
+  complete(index: number, output?: string): void;
+  fail(index: number, output?: string): void;
+  render(): string;
+  private getStatusIcon(status: Task['status']): string;
+}