@zintrust/core 0.1.28 → 0.1.30

package/src/common/AwsSigV4.js

@@ -0,0 +1,69 @@
+import { createHash, createHmac } from '../node-singletons/crypto.js';
+export const AwsSigV4 = Object.freeze({
+    sha256Hex(data) {
+        return createHash('sha256').update(data).digest('hex');
+    },
+    hmacSha256(key, data) {
+        return createHmac('sha256', key).update(data).digest();
+    },
+    toAmzDate(date) {
+        const yyyy = String(date.getUTCFullYear());
+        const mm = String(date.getUTCMonth() + 1).padStart(2, '0');
+        const dd = String(date.getUTCDate()).padStart(2, '0');
+        const hh = String(date.getUTCHours()).padStart(2, '0');
+        const mi = String(date.getUTCMinutes()).padStart(2, '0');
+        const ss = String(date.getUTCSeconds()).padStart(2, '0');
+        const dateStamp = `${yyyy}${mm}${dd}`;
+        const amzDate = `${dateStamp}T${hh}${mi}${ss}Z`;
+        return { amzDate, dateStamp };
+    },
+    deriveSigningKey(params) {
+        const kDate = this.hmacSha256(`AWS4${params.secretAccessKey}`, params.dateStamp);
+        const kRegion = this.hmacSha256(kDate, params.region);
+        const kService = this.hmacSha256(kRegion, params.service);
+        return this.hmacSha256(kService, 'aws4_request');
+    },
+    canonicalizeHeaders(headers) {
+        const sortedHeaderKeys = Object.keys(headers).sort((a, b) => a.localeCompare(b));
+        const canonicalHeaders = sortedHeaderKeys
+            .map((k) => `${k}:${String(headers[k]).trim().replaceAll(/\s+/g, ' ')}`)
+            .join('\n');
+        const signedHeaders = sortedHeaderKeys.join(';');
+        return { canonicalHeaders, signedHeaders };
+    },
+    buildAuthorization(params) {
+        const sessionToken = params.credentials.sessionToken;
+        if (typeof sessionToken === 'string' &&
+            sessionToken.trim() !== '' &&
+            params.headers['x-amz-security-token'] === undefined) {
+            params.headers['x-amz-security-token'] = sessionToken;
+        }
+        const { canonicalHeaders, signedHeaders } = this.canonicalizeHeaders(params.headers);
+        const canonicalRequest = [
+            params.method,
+            params.canonicalUri,
+            params.canonicalQueryString,
+            `${canonicalHeaders}\n`,
+            signedHeaders,
+            params.payloadHash,
+        ].join('\n');
+        const algorithm = 'AWS4-HMAC-SHA256';
+        const credentialScope = `${params.dateStamp}/${params.region}/${params.service}/aws4_request`;
+        const stringToSign = [
+            algorithm,
+            params.amzDate,
+            credentialScope,
+            this.sha256Hex(canonicalRequest),
+        ].join('\n');
+        const signingKey = this.deriveSigningKey({
+            secretAccessKey: params.credentials.secretAccessKey,
+            dateStamp: params.dateStamp,
+            region: params.region,
+            service: params.service,
+        });
+        const signature = createHmac('sha256', signingKey).update(stringToSign).digest('hex');
+        const authorization = `${algorithm} Credential=${params.credentials.accessKeyId}/${credentialScope}, ` +
+            `SignedHeaders=${signedHeaders}, Signature=${signature}`;
+        return { authorization, signedHeaders };
+    },
+});

package/src/common/ExternalServiceUtils.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Shared Utilities for External Service Drivers
+ * Common patterns for API calls, environment variable reading, and error handling
+ */
+/**
+ * Environment variable reader with fallback support
+ * Handles both Env.get() and process.env for maximum compatibility
+ */
+export declare const readEnvString: (key: string, fallback?: string) => string;
+/**
+ * Validate required parameters for external service calls
+ */
+export declare const validateRequiredParams: (params: Record<string, unknown>, required: string[]) => void;
+/**
+ * Create standardized API error response
+ */
+export declare const createApiError: (message: string, service: string) => Error;
+/**
+ * Common fetch wrapper with error handling
+ */
+export declare const safeFetch: (url: string, options: RequestInit) => Promise<Response>;
+/**
+ * Standard API response builder
+ */
+export declare const buildApiResponse: <T>(success: boolean, data?: T, error?: string) => {
+    success: boolean;
+    data?: T;
+    error?: string;
+};
+/**
+ * Health check utilities
+ */
+export declare const HealthUtils: {
+    /**
+     * Get process uptime safely
+     */
+    getUptime(): number;
+    /**
+     * Get current timestamp
+     */
+    getTimestamp(): string;
+    /**
+     * Check if in production
+     */
+    isProduction(environment: string): boolean;
+    /**
+     * Build health response
+     */
+    buildHealthResponse(status: "healthy" | "unhealthy" | "alive" | "ready" | "not_ready", environment: string, extra?: Record<string, unknown>): {
+        status: "ready" | "unhealthy" | "healthy" | "alive" | "not_ready";
+        timestamp: string;
+        environment: string;
+    };
+    /**
+     * Build error health response
+     */
+    buildErrorResponse(status: "unhealthy" | "not_ready", environment: string, error: Error, extra?: Record<string, unknown>): {
+        status: "ready" | "unhealthy" | "healthy" | "alive" | "not_ready";
+        timestamp: string;
+        environment: string;
+    };
+};
+//# sourceMappingURL=ExternalServiceUtils.d.ts.map

package/src/common/ExternalServiceUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExternalServiceUtils.d.ts","sourceRoot":"","sources":["../../../src/common/ExternalServiceUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH;;;GAGG;AACH,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,iBAAa,KAAG,MAS1D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,GACjC,QAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,UAAU,MAAM,EAAE,KACjB,IAWF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,EAAE,SAAS,MAAM,KAAG,KAEjE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,GAAU,KAAK,MAAM,EAAE,SAAS,WAAW,KAAG,OAAO,CAAC,QAAQ,CAcnF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAChC,SAAS,OAAO,EAChB,OAAO,CAAC,EACR,QAAQ,MAAM,KACb;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAY9C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW;IACtB;;OAEG;iBACU,MAAM;IAMnB;;OAEG;oBACa,MAAM;IAItB;;OAEG;8BACuB,MAAM,GAAG,OAAO;IAI1C;;OAEG;gCAEO,SAAS,GAAG,WAAW,GAAG,OAAO,GAAG,OAAO,GAAG,WAAW,eACpD,MAAM,UACX,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;IAYjC;;OAEG;+BAEO,WAAW,GAAG,WAAW,eACpB,MAAM,SACZ,KAAK,UACJ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;CASlC,CAAC"}

package/src/common/ExternalServiceUtils.js

@@ -0,0 +1,116 @@
+/**
+ * Shared Utilities for External Service Drivers
+ * Common patterns for API calls, environment variable reading, and error handling
+ */
+import { Env } from '../config/env.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+/**
+ * Environment variable reader with fallback support
+ * Handles both Env.get() and process.env for maximum compatibility
+ */
+export const readEnvString = (key, fallback = '') => {
+    const anyEnv = Env;
+    const fromEnv = typeof anyEnv.get === 'function' ? anyEnv.get(key, '') : '';
+    if (typeof fromEnv === 'string' && fromEnv.trim() !== '')
+        return fromEnv;
+    if (typeof process !== 'undefined') {
+        const raw = process.env?.[key];
+        if (typeof raw === 'string')
+            return raw;
+    }
+    return fromEnv ?? fallback;
+};
+/**
+ * Validate required parameters for external service calls
+ */
+export const validateRequiredParams = (params, required) => {
+    for (const param of required) {
+        const value = params[param];
+        if (value === null ||
+            value === undefined ||
+            (typeof value === 'string' && value.length === 0)) {
+            throw ErrorFactory.createValidationError(`${param} is required`);
+        }
+    }
+};
+/**
+ * Create standardized API error response
+ */
+export const createApiError = (message, service) => {
+    return ErrorFactory.createValidationError(`${service} API error: ${message}`);
+};
+/**
+ * Common fetch wrapper with error handling
+ */
+export const safeFetch = async (url, options) => {
+    try {
+        const response = await globalThis.fetch(url, options);
+        if (!response.ok) {
+            throw ErrorFactory.createValidationError(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        return response;
+    }
+    catch (error) {
+        throw ErrorFactory.createValidationError(error instanceof Error ? error.message : 'Unknown fetch error');
+    }
+};
+/**
+ * Standard API response builder
+ */
+export const buildApiResponse = (success, data, error) => {
+    const response = { success };
+    if (data !== undefined) {
+        response.data = data;
+    }
+    if (error !== undefined) {
+        response.error = error;
+    }
+    return response;
+};
+/**
+ * Health check utilities
+ */
+export const HealthUtils = {
+    /**
+     * Get process uptime safely
+     */
+    getUptime() {
+        return typeof process !== 'undefined' && typeof process.uptime === 'function'
+            ? process.uptime()
+            : 0;
+    },
+    /**
+     * Get current timestamp
+     */
+    getTimestamp() {
+        return new Date().toISOString();
+    },
+    /**
+     * Check if in production
+     */
+    isProduction(environment) {
+        return environment === 'production';
+    },
+    /**
+     * Build health response
+     */
+    buildHealthResponse(status, environment, extra) {
+        const base = {
+            status,
+            timestamp: HealthUtils.getTimestamp(),
+            environment,
+            ...extra,
+        };
+        return base;
+    },
+    /**
+     * Build error health response
+     */
+    buildErrorResponse(status, environment, error, extra) {
+        const isProd = HealthUtils.isProduction(environment);
+        return HealthUtils.buildHealthResponse(status, environment, {
+            error: isProd ? 'Service unavailable' : error.message,
+            ...extra,
+        });
+    },
+};

package/src/common/HealthRoutes.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared Health Route Handlers
+ * Extracted to eliminate duplication between CoreRoutes.ts and routes/health.ts
+ */
+import type { IRouter } from '../routes/Router';
+/**
+ * Register all health routes
+ */
+export declare const registerHealthRoutes: (router: IRouter) => void;
+//# sourceMappingURL=HealthRoutes.d.ts.map

package/src/common/HealthRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HealthRoutes.d.ts","sourceRoot":"","sources":["../../../src/common/HealthRoutes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AA4HnD;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,OAAO,KAAG,IAItD,CAAC"}

package/src/common/HealthRoutes.js

@@ -0,0 +1,114 @@
+/**
+ * Shared Health Route Handlers
+ * Extracted to eliminate duplication between CoreRoutes.ts and routes/health.ts
+ */
+import { appConfig } from '../config/app.js';
+import { RuntimeHealthProbes } from '../health/RuntimeHealthProbes.js';
+import { HealthUtils } from './ExternalServiceUtils.js';
+import { Env } from '../config/env.js';
+import { Logger } from '../config/logger.js';
+import { Router } from '../routes/Router.js';
+import { useDatabase } from '../orm/Database.js';
+import { QueryBuilder } from '../orm/QueryBuilder.js';
+/**
+ * Health check endpoint handler
+ */
+async function handleHealthRoute(_req, res) {
+    const environment = Env.NODE_ENV ?? 'development';
+    try {
+        const db = useDatabase();
+        const maybeIsConnected = db.isConnected;
+        const maybeConnect = db.connect;
+        if (typeof maybeIsConnected === 'function' && maybeIsConnected.call(db) === false) {
+            if (typeof maybeConnect === 'function') {
+                await maybeConnect.call(db);
+            }
+        }
+        await QueryBuilder.ping(db);
+        const uptime = HealthUtils.getUptime();
+        res.json(HealthUtils.buildHealthResponse('healthy', environment, {
+            uptime,
+            database: 'connected',
+        }));
+    }
+    catch (error) {
+        Logger.error('Health check failed:', error);
+        res.setStatus(503).json(HealthUtils.buildErrorResponse('unhealthy', environment, error, {
+            database: 'disconnected',
+        }));
+    }
+}
+/**
+ * Liveness probe endpoint handler
+ */
+function handleHealthLiveRoute(_req, res) {
+    const uptime = HealthUtils.getUptime();
+    res.json(HealthUtils.buildHealthResponse('alive', Env.NODE_ENV ?? 'development', {
+        uptime,
+    }));
+}
+/**
+ * Readiness probe endpoint handler
+ */
+async function handleHealthReadyRoute(_req, res) {
+    const startTime = Date.now();
+    const environment = appConfig.environment;
+    let databaseResponseTime = null;
+    let cacheResponseTime = null;
+    try {
+        const db = useDatabase();
+        const maybeIsConnected = db.isConnected;
+        const maybeConnect = db.connect;
+        if (typeof maybeIsConnected === 'function' && maybeIsConnected.call(db) === false) {
+            if (typeof maybeConnect === 'function') {
+                await maybeConnect.call(db);
+            }
+        }
+        await QueryBuilder.ping(db);
+        databaseResponseTime = Date.now() - startTime;
+        cacheResponseTime = await RuntimeHealthProbes.pingKvCache(2000);
+        res.json(HealthUtils.buildHealthResponse('ready', environment, {
+            dependencies: {
+                database: {
+                    status: 'ready',
+                    responseTime: databaseResponseTime,
+                },
+                ...(cacheResponseTime === null
+                    ? {}
+                    : {
+                        cache: {
+                            status: 'ready',
+                            responseTime: cacheResponseTime,
+                        },
+                    }),
+            },
+        }));
+    }
+    catch (error) {
+        Logger.error('Readiness check failed:', error);
+        const responseTime = Date.now() - startTime;
+        const dependencies = {
+            database: {
+                status: databaseResponseTime === null ? 'unavailable' : 'ready',
+                responseTime: databaseResponseTime ?? responseTime,
+            },
+        };
+        if (RuntimeHealthProbes.getCacheDriverName() === 'kv') {
+            dependencies['cache'] = {
+                status: 'unavailable',
+                responseTime: cacheResponseTime ?? responseTime,
+            };
+        }
+        res.setStatus(503).json(HealthUtils.buildErrorResponse('not_ready', environment, error, {
+            dependencies,
+        }));
+    }
+}
+/**
+ * Register all health routes
+ */
+export const registerHealthRoutes = (router) => {
+    Router.get(router, '/health', handleHealthRoute);
+    Router.get(router, '/health/live', handleHealthLiveRoute);
+    Router.get(router, '/health/ready', handleHealthReadyRoute);
+};

package/src/common/RemoteSignedJson.d.ts

@@ -0,0 +1,21 @@
+export type RemoteSignedJsonSettings = {
+    baseUrl: string;
+    keyId: string;
+    secret: string;
+    timeoutMs: number;
+    missingUrlMessage: string;
+    missingCredentialsMessage: string;
+    messages: {
+        unauthorized: string;
+        forbidden: string;
+        rateLimited: string;
+        rejected: string;
+        error: string;
+        timedOut: string;
+    };
+};
+export declare const RemoteSignedJson: Readonly<{
+    request<T>(settings: RemoteSignedJsonSettings, path: string, payload: Record<string, unknown>): Promise<T>;
+}>;
+export default RemoteSignedJson;
+//# sourceMappingURL=RemoteSignedJson.d.ts.map

package/src/common/RemoteSignedJson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RemoteSignedJson.d.ts","sourceRoot":"","sources":["../../../src/common/RemoteSignedJson.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAElB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,yBAAyB,EAAE,MAAM,CAAC;IAElC,QAAQ,EAAE;QACR,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH,CAAC;AAoCF,eAAO,MAAM,gBAAgB;YACb,CAAC,YACH,wBAAwB,QAC5B,MAAM,WACH,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,OAAO,CAAC,CAAC,CAAC;EAqDb,CAAC;AAEH,eAAe,gBAAgB,CAAC"}

package/src/common/RemoteSignedJson.js

@@ -0,0 +1,86 @@
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { SignedRequest } from '../security/SignedRequest.js';
+const joinUrl = (baseUrl, path) => {
+    const u = new URL(baseUrl);
+    const basePath = u.pathname.endsWith('/') ? u.pathname.slice(0, -1) : u.pathname;
+    const next = path.startsWith('/') ? path : `/${path}`;
+    u.pathname = `${basePath}${next}`;
+    u.search = '';
+    return u;
+};
+const asJson = async (resp) => {
+    const text = await resp.text();
+    if (text.trim() === '')
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { message: text };
+    }
+};
+const requireConfigured = (settings) => {
+    if (settings.baseUrl.trim() === '') {
+        throw ErrorFactory.createConfigError(settings.missingUrlMessage);
+    }
+    if (settings.keyId.trim() === '' || settings.secret.trim() === '') {
+        throw ErrorFactory.createConfigError(settings.missingCredentialsMessage);
+    }
+};
+const createTimeoutSignal = (timeoutMs) => {
+    if (timeoutMs <= 0)
+        return undefined;
+    const timeout = AbortSignal.timeout;
+    return typeof timeout === 'function' ? timeout(timeoutMs) : undefined;
+};
+export const RemoteSignedJson = Object.freeze({
+    async request(settings, path, payload) {
+        requireConfigured(settings);
+        const url = joinUrl(settings.baseUrl, path);
+        const body = JSON.stringify(payload);
+        const signed = await SignedRequest.createHeaders({
+            method: 'POST',
+            url,
+            body,
+            keyId: settings.keyId,
+            secret: settings.secret,
+        });
+        try {
+            const resp = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...signed },
+                body,
+                signal: createTimeoutSignal(settings.timeoutMs),
+            });
+            if (!resp.ok) {
+                const details = await asJson(resp);
+                if (resp.status === 401) {
+                    throw ErrorFactory.createUnauthorizedError(settings.messages.unauthorized, details);
+                }
+                if (resp.status === 403) {
+                    throw ErrorFactory.createForbiddenError(settings.messages.forbidden, details);
+                }
+                if (resp.status === 429) {
+                    throw ErrorFactory.createSecurityError(settings.messages.rateLimited, details);
+                }
+                if (resp.status >= 400 && resp.status < 500) {
+                    throw ErrorFactory.createValidationError(settings.messages.rejected, details);
+                }
+                throw ErrorFactory.createConnectionError(settings.messages.error, {
+                    status: resp.status,
+                    details,
+                });
+            }
+            return (await asJson(resp));
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw ErrorFactory.createConnectionError(settings.messages.timedOut, {
+                    timeoutMs: settings.timeoutMs,
+                });
+            }
+            throw error;
+        }
+    },
+});
+export default RemoteSignedJson;

package/src/common/index.d.ts

@@ -0,0 +1,134 @@
+export { AwsSigV4 } from './AwsSigV4';
+export declare const FileChecker: {
+    exists(filePath: string): boolean;
+};
+/**
+ * Common utilities - Sealed namespace for immutability
+ */
+export declare const CommonUtils: Readonly<{
+    /**
+     * Resolve npm executable path from Node.js installation
+     */
+    resolveNpmPath(): string;
+    /**
+     * RUNTIME UTILITIES
+     */
+    /**
+     * Async delay helper. No-ops when timers are unavailable.
+     */
+    delay(ms: number): Promise<void>;
+    /**
+     * Resolve an ESM `import.meta.url` to a filesystem path.
+     */
+    esmFilePath(metaUrl: string | URL): string;
+    /**
+     * Resolve an ESM `import.meta.url` to a filesystem directory.
+     */
+    esmDirname(metaUrl: string | URL): string;
+    /**
+     * STRING UTILITIES
+     */
+    /**
+     * Convert string to camelCase
+     */
+    camelCase(str: string): string;
+    /**
+     * Convert string to snake_case
+     */
+    toSnakeCase(str: string): string;
+    /**
+     * Convert string to PascalCase
+     */
+    toPascalCase(str: string): string;
+    /**
+     * FILE SYSTEM UTILITIES
+     */
+    /**
+     * Check if file exists
+     */
+    fileExists(filePath: string): boolean;
+    /**
+     * Ensure directory exists, create if missing
+     */
+    ensureDir(dirPath: string): void;
+    /**
+     * Best-effort variant of ensureDir() that never throws.
+     */
+    ensureDirSafe(dirPath: string): void;
+    /**
+     * Read file contents as string
+     */
+    readFile(filePath: string): string;
+    /**
+     * Read file contents as string (async)
+     */
+    readFileAsync(filePath: string): Promise<string>;
+    /**
+     * Write file with optional directory creation
+     */
+    writeFile(filePath: string, content: string, createDir?: boolean): void;
+    /**
+     * Write file with optional directory creation (async)
+     */
+    writeFileAsync(filePath: string, content: string, createDir?: boolean): Promise<void>;
+    /**
+     * Delete file if it exists
+     */
+    deleteFile(filePath: string): void;
+    /**
+     * TIMESTAMP UTILITIES
+     */
+    /**
+     * Get current timestamp in ISO format
+     */
+    getCurrentTimestamp(): string;
+    /**
+     * Format timestamp for filenames (YYYY-MM-DDTHH-MM-SS-SSSZ)
+     */
+    formatTimestamp(date?: Date): string;
+    /**
+     * Parse ISO timestamp string to Date
+     */
+    parseTimestamp(timestamp: string): Date;
+    /**
+     * VALIDATION UTILITIES
+     */
+    /**
+     * Extract error message from unknown error type
+     */
+    extractErrorMessage(error: unknown): string;
+    /**
+     * Validate options object and throw if invalid
+     */
+    validateOptions(options: Record<string, unknown>, requiredFields: string[], context: string): void;
+    /**
+     * Check if value is valid (not null, undefined, or empty string)
+     */
+    isValid(value: unknown): boolean;
+    /**
+     * Ensure value is string, throw otherwise
+     */
+    ensureString(value: unknown, fieldName: string): string;
+    /**
+     * Ensure value is object, throw otherwise
+     */
+    ensureObject(value: unknown, fieldName: string): Record<string, unknown>;
+    /**
+     * Resolve preferred package manager.
+     * If `preferred` is provided, the first value is returned. Otherwise we detect by lock files.
+     */
+    resolvePackageManager(preferred?: string[]): string;
+}>;
+export declare const resolveNpmPath: () => string;
+export declare const delay: (ms: number) => Promise<void>;
+export declare const esmFilePath: (metaUrl: string | URL) => string;
+export declare const esmDirname: (metaUrl: string | URL) => string;
+export declare const resolvePackageManager: (preferred?: string[]) => string;
+export declare const extractErrorMessage: (error: unknown) => string;
+export declare const extractErrorMessageStrict: (error: unknown) => string;
+export declare const fileExists: (filePath: string) => boolean;
+export declare const ensureDir: (dirPath: string) => void;
+export declare const ensureDirSafe: (dirPath: string) => void;
+export declare const readFile: (filePath: string) => string;
+export declare const writeFile: (filePath: string, content: string, createDir?: boolean) => void;
+//# sourceMappingURL=index.d.ts.map

package/src/common/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/common/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAG5C,eAAO,MAAM,WAAW;qBACL,MAAM,GAAG,OAAO;CAOlC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW;IACtB;;OAEG;sBACe,MAAM;IAgBxB;;OAEG;IAEH;;OAEG;cACa,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWtC;;OAEG;yBACkB,MAAM,GAAG,GAAG,GAAG,MAAM;IAI1C;;OAEG;wBACiB,MAAM,GAAG,GAAG,GAAG,MAAM;IAIzC;;OAEG;IAEH;;OAEG;mBACY,MAAM,GAAG,MAAM;IAgB9B;;OAEG;qBACc,MAAM,GAAG,MAAM;IAUhC;;OAEG;sBACe,MAAM,GAAG,MAAM;IAQjC;;OAEG;IAEH;;OAEG;yBACkB,MAAM,GAAG,OAAO;IAIrC;;OAEG;uBACgB,MAAM,GAAG,IAAI;IAMhC;;OAEG;2BACoB,MAAM,GAAG,IAAI;IAQpC;;OAEG;uBACgB,MAAM,GAAG,MAAM;IAUlC;;OAEG;4BAC2B,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAWtD;;OAEG;wBACiB,MAAM,WAAW,MAAM,wBAAqB,IAAI;IAcpE;;OAEG;6BAC4B,MAAM,WAAW,MAAM,wBAAqB,OAAO,CAAC,IAAI,CAAC;IAexF;;OAEG;yBACkB,MAAM,GAAG,IAAI;IAYlC;;OAEG;IAEH;;OAEG;2BACoB,MAAM;IAI7B;;OAEG;2BACmB,IAAI,GAAgB,MAAM;IAIhD;;OAEG;8BACuB,MAAM,GAAG,IAAI;IAYvC;;OAEG;IAEH;;OAEG;+BACwB,OAAO,GAAG,MAAM;IAa3C;;OAEG;6BAEQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,kBAChB,MAAM,EAAE,WACf,MAAM,GACd,IAAI;IAWP;;OAEG;mBACY,OAAO,GAAG,OAAO;IAIhC;;OAEG;wBACiB,OAAO,aAAa,MAAM,GAAG,MAAM;IAOvD;;OAEG;wBACiB,OAAO,aAAa,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAOxE;;;OAGG;sCAC+B,MAAM,EAAE,GAAG,MAAM;EAgBnD,CAAC;AAGH,eAAO,MAAM,cAAc,QAAO,MAAsC,CAAC;AAEzE,eAAO,MAAM,KAAK,GAAU,IAAI,MAAM,KAAG,OAAO,CAAC,IAAI,CAA0B,CAAC;AAEhF,eAAO,MAAM,WAAW,GAAI,SAAS,MAAM,GAAG,GAAG,KAAG,MAA0C,CAAC;AAC/F,eAAO,MAAM,UAAU,GAAI,SAAS,MAAM,GAAG,GAAG,KAAG,MAAyC,CAAC;AAE7F,eAAO,MAAM,qBAAqB,GAAI,YAAY,MAAM,EAAE,KAAG,MAE5D,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,OAAO,OAAO,KAAG,MACb,CAAC;AAIzC,eAAO,MAAM,yBAAyB,GAAI,OAAO,OAAO,KAAG,MAM1D,CAAC;AAGF,eAAO,MAAM,UAAU,GAAI,UAAU,MAAM,KAAG,OAA2C,CAAC;AAC1F,eAAO,MAAM,SAAS,GAAI,SAAS,MAAM,KAAG,IAAsC,CAAC;AACnF,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,KAAG,IAA0C,CAAC;AAC3F,eAAO,MAAM,QAAQ,GAAI,UAAU,MAAM,KAAG,MAAwC,CAAC;AACrF,eAAO,MAAM,SAAS,GAAI,UAAU,MAAM,EAAE,SAAS,MAAM,EAAE,mBAAgB,KAAG,IAC3B,CAAC"}