@kadi.build/deploy-ability 0.0.1

package/dist/errors/wallet-error.js

@@ -0,0 +1,154 @@
+/**
+ * Wallet-related error classes
+ *
+ * Errors specific to wallet connection, signing, and balance operations
+ *
+ * @module errors/wallet-error
+ */
+import { DeploymentError } from './deployment-error.js';
+/**
+ * Wallet error codes
+ */
+export const WalletErrorCodes = {
+    /** Wallet extension not found (e.g., Keplr not installed) */
+    WALLET_NOT_FOUND: 'WALLET_NOT_FOUND',
+    /** User rejected wallet connection */
+    CONNECTION_REJECTED: 'CONNECTION_REJECTED',
+    /** Wallet is locked */
+    WALLET_LOCKED: 'WALLET_LOCKED',
+    /** Insufficient funds for transaction */
+    INSUFFICIENT_FUNDS: 'INSUFFICIENT_FUNDS',
+    /** Transaction signing failed */
+    SIGNING_FAILED: 'SIGNING_FAILED',
+    /** WalletConnect initialization failed */
+    WALLETCONNECT_INIT_FAILED: 'WALLETCONNECT_INIT_FAILED',
+    /** QR code modal was closed */
+    QR_MODAL_CLOSED: 'QR_MODAL_CLOSED',
+    /** Network mismatch (wallet on wrong network) */
+    NETWORK_MISMATCH: 'NETWORK_MISMATCH',
+    /** Account not found */
+    ACCOUNT_NOT_FOUND: 'ACCOUNT_NOT_FOUND',
+    /** WalletConnect project ID missing or invalid */
+    MISSING_PROJECT_ID: 'MISSING_PROJECT_ID',
+    /** WalletConnect client initialization failed */
+    INIT_FAILED: 'INIT_FAILED',
+    /** Failed to generate connection URI */
+    URI_GENERATION_FAILED: 'URI_GENERATION_FAILED',
+    /** WalletConnect connection failed */
+    CONNECTION_FAILED: 'CONNECTION_FAILED',
+    /** No accounts in WalletConnect session */
+    NO_ACCOUNTS: 'NO_ACCOUNTS',
+    /** Connection approval timed out */
+    APPROVAL_TIMEOUT: 'APPROVAL_TIMEOUT',
+    /** User rejected connection approval */
+    APPROVAL_REJECTED: 'APPROVAL_REJECTED',
+    /** Approval process failed */
+    APPROVAL_FAILED: 'APPROVAL_FAILED',
+    /** No accounts available from signer */
+    NO_SIGNER_ACCOUNTS: 'NO_SIGNER_ACCOUNTS',
+    /** Failed to create wallet context */
+    CONTEXT_CREATION_FAILED: 'CONTEXT_CREATION_FAILED',
+    /** Failed to disconnect wallet */
+    DISCONNECT_FAILED: 'DISCONNECT_FAILED',
+    /** Feature not yet implemented */
+    NOT_IMPLEMENTED: 'NOT_IMPLEMENTED',
+    /** Generic wallet error */
+    WALLET_ERROR: 'WALLET_ERROR',
+};
+/**
+ * Wallet connection or operation error
+ *
+ * Thrown when wallet-related operations fail, including:
+ * - Wallet not found/installed
+ * - Connection rejected by user
+ * - Signing failures
+ * - Insufficient balance
+ *
+ * @example
+ * throw new WalletError(
+ *   'Keplr wallet not found',
+ *   WalletErrorCodes.WALLET_NOT_FOUND,
+ *   {},
+ *   false,
+ *   'Please install the Keplr browser extension from https://keplr.app'
+ * );
+ */
+export class WalletError extends DeploymentError {
+    constructor(message, code = WalletErrorCodes.WALLET_ERROR, context = {}, recoverable = false, suggestion, severity = 'error', cause) {
+        super(message, code, context, recoverable, suggestion, severity, cause);
+        // Maintain proper prototype chain
+        Object.setPrototypeOf(this, WalletError.prototype);
+        this.name = 'WalletError';
+    }
+}
+/**
+ * Create a wallet not found error
+ *
+ * @param walletType - Type of wallet that wasn't found
+ * @returns WalletError instance
+ */
+export function walletNotFoundError(walletType) {
+    const suggestions = {
+        keplr: 'Please install the Keplr browser extension from https://keplr.app',
+        walletconnect: 'Please provide a valid WalletConnect project ID or use Keplr instead',
+    };
+    return new WalletError(`${walletType === 'keplr' ? 'Keplr' : 'WalletConnect'} wallet not found`, WalletErrorCodes.WALLET_NOT_FOUND, { walletType }, false, suggestions[walletType], 'error');
+}
+/**
+ * Create a connection rejected error
+ *
+ * @returns WalletError instance
+ */
+export function connectionRejectedError() {
+    return new WalletError('Wallet connection was rejected by user', WalletErrorCodes.CONNECTION_REJECTED, {}, true, 'Please approve the connection request in your wallet', 'warning');
+}
+/**
+ * Create an insufficient funds error
+ *
+ * @param required - Amount required
+ * @param available - Amount available
+ * @param denom - Token denomination
+ * @returns WalletError instance
+ */
+export function insufficientFundsError(required, available, denom = 'uakt') {
+    const shortfall = required - available;
+    return new WalletError(`Insufficient funds: need ${required} ${denom}, have ${available} ${denom}`, WalletErrorCodes.INSUFFICIENT_FUNDS, { required, available, shortfall, denom }, false, `Please add at least ${shortfall} ${denom} to your wallet`, 'error');
+}
+/**
+ * Create a wallet locked error
+ *
+ * @returns WalletError instance
+ */
+export function walletLockedError() {
+    return new WalletError('Wallet is locked', WalletErrorCodes.WALLET_LOCKED, {}, true, 'Please unlock your wallet and try again', 'warning');
+}
+/**
+ * Create a signing failed error
+ *
+ * @param operation - The operation that failed
+ * @param cause - Original error
+ * @returns WalletError instance
+ */
+export function signingFailedError(operation, cause) {
+    return new WalletError(`Failed to sign ${operation}`, WalletErrorCodes.SIGNING_FAILED, { operation }, true, 'Please try the operation again. If the problem persists, check your wallet connection.', 'error', cause);
+}
+/**
+ * Create a network mismatch error
+ *
+ * @param expected - Expected network
+ * @param actual - Actual network
+ * @returns WalletError instance
+ */
+export function networkMismatchError(expected, actual) {
+    return new WalletError(`Network mismatch: expected ${expected}, wallet is on ${actual}`, WalletErrorCodes.NETWORK_MISMATCH, { expected, actual }, true, `Please switch your wallet to the ${expected} network`, 'error');
+}
+/**
+ * Type guard to check if an error is a WalletError
+ *
+ * @param error - The error to check
+ * @returns True if error is a WalletError
+ */
+export function isWalletError(error) {
+    return error instanceof WalletError;
+}
+//# sourceMappingURL=wallet-error.js.map

package/dist/errors/wallet-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-error.js","sourceRoot":"","sources":["../../src/errors/wallet-error.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * deploy-ability - Programmatic deployment library for KADI
+ *
+ * Deploy applications to Akash Network, local Docker, or other platforms
+ * without CLI dependencies.
+ *
+ * @example Quick Start - Akash
+ * ```typescript
+ * import { deployToAkash } from 'deploy-ability';
+ *
+ * const result = await deployToAkash({
+ *   projectRoot: process.cwd(),
+ *   profile: 'production'
+ * });
+ *
+ * if (result.success) {
+ *   console.log(`Deployed! DSEQ: ${result.data.dseq}`);
+ *   console.log(`Provider: ${result.data.providerUri}`);
+ * } else {
+ *   console.error(`Deployment failed: ${result.error.message}`);
+ * }
+ * ```
+ *
+ * @example Quick Start - Local
+ * ```typescript
+ * import { deployToLocal } from 'deploy-ability';
+ *
+ * const result = await deployToLocal({
+ *   projectRoot: process.cwd(),
+ *   profile: 'local-dev',
+ *   engine: 'docker'
+ * });
+ *
+ * if (result.success) {
+ *   console.log('Deployed locally!');
+ *   console.log('Services:', result.data.services);
+ *   console.log('Endpoints:', result.data.endpoints);
+ * }
+ * ```
+ *
+ * @module deploy-ability
+ */
+export type * from './types/index.js';
+export * from './errors/index.js';
+export * from './utils/index.js';
+export * from './constants.js';
+export { deployToLocal } from './targets/local/index.js';
+export * from './targets/akash/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAGH,mBAAmB,kBAAkB,CAAC;AAGtC,cAAc,mBAAmB,CAAC;AAGlC,cAAc,kBAAkB,CAAC;AAGjC,cAAc,gBAAgB,CAAC;AAG/B,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAGzD,cAAc,0BAA0B,CAAC"}

package/dist/index.js

@@ -0,0 +1,53 @@
+/**
+ * deploy-ability - Programmatic deployment library for KADI
+ *
+ * Deploy applications to Akash Network, local Docker, or other platforms
+ * without CLI dependencies.
+ *
+ * @example Quick Start - Akash
+ * ```typescript
+ * import { deployToAkash } from 'deploy-ability';
+ *
+ * const result = await deployToAkash({
+ *   projectRoot: process.cwd(),
+ *   profile: 'production'
+ * });
+ *
+ * if (result.success) {
+ *   console.log(`Deployed! DSEQ: ${result.data.dseq}`);
+ *   console.log(`Provider: ${result.data.providerUri}`);
+ * } else {
+ *   console.error(`Deployment failed: ${result.error.message}`);
+ * }
+ * ```
+ *
+ * @example Quick Start - Local
+ * ```typescript
+ * import { deployToLocal } from 'deploy-ability';
+ *
+ * const result = await deployToLocal({
+ *   projectRoot: process.cwd(),
+ *   profile: 'local-dev',
+ *   engine: 'docker'
+ * });
+ *
+ * if (result.success) {
+ *   console.log('Deployed locally!');
+ *   console.log('Services:', result.data.services);
+ *   console.log('Endpoints:', result.data.endpoints);
+ * }
+ * ```
+ *
+ * @module deploy-ability
+ */
+// Re-export errors
+export * from './errors/index.js';
+// Re-export utilities
+export * from './utils/index.js';
+// Re-export constants
+export * from './constants.js';
+// Main deployment functions
+export { deployToLocal } from './targets/local/index.js';
+// Akash target - complete API exported
+export * from './targets/akash/index.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAKH,mBAAmB;AACnB,cAAc,mBAAmB,CAAC;AAElC,sBAAsB;AACtB,cAAc,kBAAkB,CAAC;AAEjC,sBAAsB;AACtB,cAAc,gBAAgB,CAAC;AAE/B,4BAA4B;AAC5B,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAEzD,uCAAuC;AACvC,cAAc,0BAA0B,CAAC"}

package/dist/targets/akash/bid-selectors.d.ts

@@ -0,0 +1,251 @@
+/**
+ * Bid Selection Helpers
+ *
+ * Provides pre-built selection strategies and filtering utilities for choosing
+ * providers based on different criteria. These functions can be used directly
+ * as bidSelectors in the deployment flow, or combined to create custom
+ * selection logic.
+ *
+ * **Selection Strategies:**
+ * - `selectCheapestBid` - Lowest price (perMonth basis)
+ * - `selectMostReliableBid` - Highest uptime percentage
+ * - `selectBalancedBid` - Weighted combination of price and reliability
+ *
+ * **Filtering:**
+ * - `filterBids` - Apply multiple criteria to narrow down options
+ *
+ * @module targets/akash/bid-selectors
+ */
+import type { EnhancedBid } from './bid-types.js';
+/**
+ * Select the cheapest bid based on monthly price
+ *
+ * Compares all bids and returns the one with the lowest cost per month.
+ * Useful when price is the primary concern and provider quality is
+ * less critical (e.g., development/testing deployments).
+ *
+ * **Note:** This only considers price, not provider reliability, location,
+ * or audit status. For production deployments, consider using `filterBids`
+ * first to ensure minimum quality standards, then select the cheapest
+ * from the filtered set.
+ *
+ * @param bids - Array of enhanced bids to choose from
+ * @returns The cheapest bid, or null if array is empty
+ *
+ * @example
+ * ```typescript
+ * import { deployToAkash, selectCheapestBid } from 'deploy-ability/akash';
+ *
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'dev',
+ *   bidSelector: selectCheapestBid
+ * });
+ * ```
+ *
+ * @example With quality filtering
+ * ```typescript
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'prod',
+ *   bidSelector: (bids) => {
+ *     // Only consider audited providers with good uptime
+ *     const qualityBids = filterBids(bids, {
+ *       requireAudited: true,
+ *       minUptime: { value: 0.95, period: '7d' }
+ *     });
+ *     // Then pick cheapest among quality providers
+ *     return selectCheapestBid(qualityBids);
+ *   }
+ * });
+ * ```
+ */
+export declare function selectCheapestBid(bids: EnhancedBid[]): EnhancedBid | null;
+/**
+ * Select the most reliable provider based on uptime
+ *
+ * Chooses the provider with the highest uptime percentage for the specified
+ * time period. Providers without reliability data are considered last.
+ *
+ * **Uptime Periods:**
+ * - `1d`: Last 24 hours (most recent, but limited sample)
+ * - `7d`: Last 7 days (good balance, recommended default)
+ * - `30d`: Last 30 days (long-term stability indicator)
+ *
+ * **Fallback Behavior:**
+ * If no providers have reliability data, returns the first bid from the
+ * original array (maintains deterministic behavior).
+ *
+ * @param bids - Array of enhanced bids to choose from
+ * @param period - Uptime period to evaluate (default: '7d')
+ * @returns The most reliable bid, or null if array is empty
+ *
+ * @example
+ * ```typescript
+ * import { deployToAkash, selectMostReliableBid } from 'deploy-ability/akash';
+ *
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'production',
+ *   bidSelector: selectMostReliableBid // Uses 7d default
+ * });
+ * ```
+ *
+ * @example With custom period
+ * ```typescript
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'production',
+ *   bidSelector: (bids) => selectMostReliableBid(bids, '30d')
+ * });
+ * ```
+ */
+export declare function selectMostReliableBid(bids: EnhancedBid[], period?: '1d' | '7d' | '30d'): EnhancedBid | null;
+/**
+ * Select bid using balanced scoring (price + reliability)
+ *
+ * Calculates a composite score for each bid based on normalized price
+ * and reliability metrics, then selects the highest-scoring option.
+ *
+ * **Scoring Methodology:**
+ * - Price score: Normalized 0-1 (lower price = higher score)
+ * - Reliability score: Uptime percentage (0-1)
+ * - Total score = (price score × price weight) + (reliability score × reliability weight)
+ *
+ * **Default Weights:**
+ * Equal balance (0.5 each) - adjust based on your priorities.
+ *
+ * **Use Cases:**
+ * - Production deployments where both cost and reliability matter
+ * - Finding "best value" providers (good balance of quality and price)
+ * - Avoiding both the cheapest-but-unreliable and expensive-but-reliable extremes
+ *
+ * @param bids - Array of enhanced bids to choose from
+ * @param weights - Scoring weights (default: equal balance)
+ * @param weights.price - Weight for price score (0-1)
+ * @param weights.reliability - Weight for reliability score (0-1)
+ * @returns The best balanced bid, or null if array is empty
+ *
+ * @example Equal balance (default)
+ * ```typescript
+ * import { deployToAkash, selectBalancedBid } from 'deploy-ability/akash';
+ *
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'production',
+ *   bidSelector: selectBalancedBid // 50/50 price/reliability
+ * });
+ * ```
+ *
+ * @example Prioritize reliability
+ * ```typescript
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'critical-prod',
+ *   bidSelector: (bids) => selectBalancedBid(bids, {
+ *     price: 0.3,
+ *     reliability: 0.7
+ *   })
+ * });
+ * ```
+ *
+ * @example Prioritize cost
+ * ```typescript
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'dev',
+ *   bidSelector: (bids) => selectBalancedBid(bids, {
+ *     price: 0.8,
+ *     reliability: 0.2
+ *   })
+ * });
+ * ```
+ */
+export declare function selectBalancedBid(bids: EnhancedBid[], weights?: {
+    price: number;
+    reliability: number;
+}): EnhancedBid | null;
+/**
+ * Filter bids by multiple criteria
+ *
+ * Apply various filters to narrow down bid options based on price,
+ * reliability, audit status, location, and provider status.
+ *
+ * **All criteria are optional** - only specify the ones you care about.
+ * Multiple criteria are combined with AND logic (all must match).
+ *
+ * **Filtering Philosophy:**
+ * Use this to establish minimum quality standards, then apply a selection
+ * strategy to the filtered results. This ensures you never select a provider
+ * that doesn't meet your requirements, even if they're the cheapest.
+ *
+ * @param bids - Array of enhanced bids to filter
+ * @param criteria - Filtering criteria (all optional)
+ * @returns Filtered array of bids matching all specified criteria
+ *
+ * @example Filter by price and uptime
+ * ```typescript
+ * import { filterBids, selectCheapestBid } from 'deploy-ability/akash';
+ *
+ * const result = await deployToAkash({
+ *   wallet,
+ *   certificate,
+ *   projectRoot: './',
+ *   profile: 'prod',
+ *   bidSelector: (bids) => {
+ *     // Only providers under $50/month with >95% uptime
+ *     const filtered = filterBids(bids, {
+ *       maxPricePerMonth: { usd: 50, aktPrice: 0.45 },
+ *       minUptime: { value: 0.95, period: '7d' }
+ *     });
+ *     return selectCheapestBid(filtered);
+ *   }
+ * });
+ * ```
+ *
+ * @example Filter by audit status and location
+ * ```typescript
+ * const filtered = filterBids(bids, {
+ *   requireAudited: true,
+ *   preferredRegions: ['US', 'EU'], // Country codes
+ *   requireOnline: true
+ * });
+ * ```
+ *
+ * @example Price filtering in uAKT
+ * ```typescript
+ * const filtered = filterBids(bids, {
+ *   maxPricePerMonth: { uakt: 500_000_000 } // 500M uAKT/month
+ * });
+ * ```
+ */
+export declare function filterBids(bids: EnhancedBid[], criteria: {
+    readonly maxPricePerMonth?: {
+        uakt: number;
+    } | {
+        usd: number;
+        aktPrice: number;
+    };
+    readonly minUptime?: {
+        value: number;
+        period: '1d' | '7d' | '30d';
+    };
+    readonly requireAudited?: boolean;
+    readonly preferredRegions?: string[];
+    readonly requireOnline?: boolean;
+}): EnhancedBid[];
+//# sourceMappingURL=bid-selectors.d.ts.map

package/dist/targets/akash/bid-selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bid-selectors.d.ts","sourceRoot":"","sources":["../../../src/targets/akash/bid-selectors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,WAAW,GAAG,IAAI,CAQzE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,EAAE,EACnB,MAAM,GAAE,IAAI,GAAG,IAAI,GAAG,KAAY,GACjC,WAAW,GAAG,IAAI,CAsBpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,WAAW,EAAE,EACnB,OAAO,GAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAqC,GACjF,WAAW,GAAG,IAAI,CAiCpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,WAAW,EAAE,EACnB,QAAQ,EAAE;IACR,QAAQ,CAAC,gBAAgB,CAAC,EACtB;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAChB;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IACtC,QAAQ,CAAC,SAAS,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,IAAI,GAAG,IAAI,GAAG,KAAK,CAAA;KAAE,CAAC;IACpE,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC,GACA,WAAW,EAAE,CA+Cf"}