hereya-cli 0.56.0 → 0.57.1

package/dist/lib/package/cloud.js

@@ -0,0 +1,226 @@
+import { createHash, randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileExists, isNotEmpty } from '../filesystem.js';
+export class CloudPackageManager {
+    backend;
+    logger;
+    constructor(backend, logger) {
+        this.backend = backend;
+        this.logger = logger;
+    }
+    async downloadAndValidatePackage(registryPackage, destPath) {
+        if (!registryPackage.repository) {
+            throw new Error(`No repository URL for package ${registryPackage.name}`);
+        }
+        if (await isNotEmpty(destPath)) {
+            return destPath;
+        }
+        await fs.mkdir(destPath, { recursive: true });
+        const tmpFolder = path.join(os.homedir(), '.hereya', 'downloads', randomUUID());
+        try {
+            // Use simple-git to clone the repository at specific commit
+            const { simpleGit } = await import('simple-git');
+            const git = simpleGit();
+            if (registryPackage.commit) {
+                // Clone repository and checkout specific commit
+                await git.clone(registryPackage.repository, tmpFolder, ['--no-checkout']);
+                const repoGit = simpleGit(tmpFolder);
+                await repoGit.checkout(registryPackage.commit);
+            }
+            else {
+                // Clone repository at default branch
+                await git.clone(registryPackage.repository, tmpFolder, ['--depth=1']);
+            }
+            // If checksum is provided, validate it
+            if (registryPackage.sha256) {
+                // Create tar archive from the cloned repository for checksum validation
+                const repoGit = simpleGit(tmpFolder);
+                const archiveBuffer = await repoGit.raw(['archive', '--format=tar', registryPackage.commit || 'HEAD']);
+                const hash = createHash('sha256');
+                hash.update(archiveBuffer);
+                const actualChecksum = hash.digest('hex');
+                if (actualChecksum !== registryPackage.sha256) {
+                    throw new Error(`Checksum mismatch for package ${registryPackage.name}@${registryPackage.version}. Expected: ${registryPackage.sha256}, Got: ${actualChecksum}`);
+                }
+            }
+            // Move files from temp folder to destination
+            const files = await fs.readdir(tmpFolder);
+            await Promise.all(files.map(async (file) => {
+                if (file !== '.git') {
+                    await fs.rename(path.join(tmpFolder, file), path.join(destPath, file));
+                }
+            }));
+            // Clean up temp folder
+            await fs.rm(tmpFolder, { force: true, recursive: true });
+        }
+        catch (error) {
+            // Clean up on error
+            try {
+                await fs.rm(tmpFolder, { force: true, recursive: true });
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            throw error;
+        }
+        return destPath;
+    }
+    async downloadPackage(pkgUrl, destPath) {
+        // Parse the package URL to extract repository and commit
+        // Format: <repository_url>#<commit_sha>
+        const [repoUrl, commitSha] = pkgUrl.split('#');
+        // For downloading packages during provision/deploy, we use downloadAndValidatePackage
+        // but we don't have SHA256 here. The validation happens in getRepoContent instead
+        // where we have access to the full registry metadata
+        const registryPackage = {
+            commit: commitSha,
+            description: '',
+            id: '',
+            name: '',
+            repository: repoUrl,
+            version: '',
+            // SHA256 not available here - validation happens in getRepoContent
+        };
+        return this.downloadAndValidatePackage(registryPackage, destPath);
+    }
+    async getFileFromRepository(repoUrl, commit, filePath, sha256) {
+        this.logger?.debug(`getFileFromRepository: trying to get ${filePath} from ${repoUrl}${commit ? `@${commit}` : ''}`);
+        const tmpFolder = path.join(os.homedir(), '.hereya', 'downloads', randomUUID());
+        try {
+            const { simpleGit } = await import('simple-git');
+            const git = simpleGit();
+            this.logger?.debug(`getFileFromRepository: cloning ${repoUrl}...`);
+            if (commit) {
+                // Clone repository and checkout specific commit
+                await git.clone(repoUrl, tmpFolder, ['--no-checkout']);
+                const repoGit = simpleGit(tmpFolder);
+                await repoGit.checkout(commit);
+                // Validate checksum if provided (for cloud packages)
+                if (sha256) {
+                    this.logger?.debug('Validating package checksum...');
+                    const archiveBuffer = await repoGit.raw(['archive', '--format=tar', commit]);
+                    const hash = createHash('sha256');
+                    hash.update(archiveBuffer);
+                    const actualChecksum = hash.digest('hex');
+                    if (actualChecksum !== sha256) {
+                        await fs.rm(tmpFolder, { recursive: true });
+                        return {
+                            found: false,
+                            reason: `Checksum validation failed for repository ${repoUrl}@${commit}. Expected: ${sha256}, Got: ${actualChecksum}. This may indicate the package has been tampered with or corrupted.`,
+                        };
+                    }
+                    this.logger?.debug('Checksum validation successful');
+                }
+            }
+            else {
+                // Clone repository at default branch
+                await git.clone(repoUrl, tmpFolder, ['--depth=1']);
+            }
+            const fullFilePath = path.join(tmpFolder, filePath);
+            this.logger?.debug(`getFileFromRepository: checking if file exists at ${fullFilePath}`);
+            if (await fileExists(fullFilePath)) {
+                this.logger?.debug(`getFileFromRepository: file found, reading content...`);
+                const content = await fs.readFile(fullFilePath, 'utf8');
+                await fs.rm(tmpFolder, { recursive: true });
+                return {
+                    content,
+                    found: true,
+                    pkgUrl: commit ? `${repoUrl}#${commit}` : repoUrl,
+                };
+            }
+            // List files to debug what's actually in the package
+            const files = await fs.readdir(tmpFolder);
+            this.logger?.debug(`getFileFromRepository: file ${filePath} not found. Available files: ${files.join(', ')}`);
+            await fs.rm(tmpFolder, { recursive: true });
+            return {
+                found: false,
+                reason: `File '${filePath}' not found in repository '${repoUrl}'. Available files: ${files.join(', ')}. This package may not be compatible with hereya or may be missing required metadata files.`,
+            };
+        }
+        catch (error) {
+            // Clean up on error
+            try {
+                await fs.rm(tmpFolder, { recursive: true });
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            return {
+                found: false,
+                reason: `Failed to download repository '${repoUrl}': ${error.message}. This could be due to network issues, repository access problems, or authentication issues.`,
+            };
+        }
+    }
+    async getRepoContent({ owner, path: filePath, repo, version }) {
+        // For cloud packages, owner/repo represent the package name in the registry
+        // The actual repository URL comes from the registry metadata
+        // Reconstruct package name from owner/repo
+        // - If owner is empty → package name is just 'repo' (simple name)
+        // - Otherwise → package name is 'owner/repo' (org/name format)
+        const packageName = owner ? `${owner}/${repo}` : repo;
+        // Include version if provided
+        const packageSpec = version ? `${packageName}@${version}` : packageName;
+        this.logger?.debug(`getRepoContent: trying to get ${filePath} from registry package '${packageSpec}'`);
+        // Resolve package from registry to get repository URL
+        const packageInfo = await this.resolvePackage(packageSpec);
+        if (!packageInfo) {
+            this.logger?.debug(`getRepoContent: package '${packageName}' not found in registry`);
+            return {
+                found: false,
+                reason: `Package '${packageName}' not found in registry`,
+            };
+        }
+        // Now we have the actual repository URL and commit from registry
+        const repoUrl = packageInfo.registryPackage.repository;
+        const { commit } = packageInfo.registryPackage;
+        if (!repoUrl) {
+            return {
+                found: false,
+                reason: `Package '${packageName}' in registry has no repository URL`,
+            };
+        }
+        this.logger?.debug(`getRepoContent: downloading from ${repoUrl}${commit ? `@${commit}` : ''}`);
+        // Use the getFileFromRepository method to download from the actual repository
+        // Pass SHA256 for checksum validation if available
+        return this.getFileFromRepository(repoUrl, commit, filePath, packageInfo.registryPackage.sha256);
+    }
+    async resolvePackage(packageSpec) {
+        // Parse package specification: name, org/name, name@version, or org/name@version
+        const { packageName, version } = this.parsePackageSpec(packageSpec);
+        try {
+            // Try to get package from registry
+            // Registry API accepts both 'name' and 'org/name' formats
+            const result = version
+                ? await this.backend.getPackageByVersion(packageName, version)
+                : await this.backend.getPackageLatest(packageName);
+            if (result.success && result.package) {
+                return {
+                    name: packageName,
+                    registryPackage: result.package,
+                    version: result.package.version,
+                };
+            }
+            // Package not found in registry or API error
+            if (!result.success) {
+                this.logger?.debug(`Registry API returned error for ${packageName}: ${result.reason}`);
+            }
+        }
+        catch (error) {
+            // Network error or other exception
+            this.logger?.debug(`Registry API exception for ${packageName}: ${error.message}`);
+        }
+        return null;
+    }
+    parsePackageSpec(spec) {
+        // Parse package specification
+        // Formats: name, org/name, name@version, org/name@version
+        const match = spec.match(/^([^@]+)(?:@(.+))?$/);
+        if (!match) {
+            return { packageName: spec };
+        }
+        const [, packageName, version] = match;
+        return { packageName, version };
+    }
+}

package/dist/lib/package/common.d.ts

@@ -7,6 +7,7 @@ export type GetRepoContentInput = {
     path: string;
     projectRootDir?: string;
     repo: string;
+    version?: string;
 };
 export type GetRepoContentOutput = {
     content: string;

package/dist/lib/package/github.d.ts

@@ -3,5 +3,5 @@ export declare class GitHubPackageManager implements PackageManager {
     private readonly registryUrl;
     constructor(registryUrl?: string);
     downloadPackage(pkgUrl: string, destPath: string): Promise<string>;
-    getRepoContent({ owner, path: filePath, repo }: GetRepoContentInput): Promise<GetRepoContentOutput>;
+    getRepoContent({ owner, path: filePath, repo, version }: GetRepoContentInput): Promise<GetRepoContentOutput>;
 }

package/dist/lib/package/github.js

@@ -16,30 +16,57 @@ export class GitHubPackageManager {
         await fs.mkdir(destPath, { recursive: true });
         // Initialize simple-git
         const git = simpleGit();
-        // Clone repository into temp directory
-        await git.clone(pkgUrl, destPath, ['--depth=1']);
+        // Parse version from URL if present (format: url#version)
+        const [repoUrl, version] = pkgUrl.split('#');
+        if (version) {
+            // Clone repository and checkout specific version tag
+            await git.clone(repoUrl, destPath, ['--no-checkout']);
+            const repoGit = simpleGit(destPath);
+            try {
+                // Try to checkout the version as a tag (e.g., v1.2.3 or 1.2.3)
+                await repoGit.checkout(`v${version}`);
+            }
+            catch {
+                try {
+                    // If v-prefixed tag doesn't exist, try without prefix
+                    await repoGit.checkout(version);
+                }
+                catch {
+                    // If neither tag exists, fail with clear error
+                    throw new Error(`Version '${version}' not found in repository ${repoUrl}. Available tags can be found at ${repoUrl}/tags`);
+                }
+            }
+        }
+        else {
+            // Clone repository at default branch
+            await git.clone(pkgUrl, destPath, ['--depth=1']);
+        }
         return destPath;
     }
-    async getRepoContent({ owner, path: filePath, repo }) {
+    async getRepoContent({ owner, path: filePath, repo, version }) {
         const pkgUrl = `${this.registryUrl}/${owner}/${repo}`;
         const tmpFolder = path.join(os.homedir(), '.hereya', 'downloads', randomUUID());
         try {
-            const destPath = await this.downloadPackage(pkgUrl, tmpFolder);
+            // Build URL with version if provided
+            const versionedPkgUrl = version ? `${pkgUrl}#${version}` : pkgUrl;
+            const destPath = await this.downloadPackage(versionedPkgUrl, tmpFolder);
             if (await fileExists(path.join(destPath, filePath))) {
                 const content = await fs.readFile(path.join(destPath, filePath), 'utf8');
                 // remove the tmp folder
                 await fs.rm(destPath, { recursive: true });
+                // Include version in the pkgUrl if provided
+                const finalPkgUrl = version ? `${pkgUrl}#${version}` : pkgUrl;
                 return {
                     content,
                     found: true,
-                    pkgUrl,
+                    pkgUrl: finalPkgUrl,
                 };
             }
             // remove the tmp folder
             await fs.rm(destPath, { recursive: true });
             return {
                 found: false,
-                reason: `File ${filePath} not found in ${pkgUrl}`,
+                reason: `File ${filePath} not found in ${pkgUrl}${version ? ` at version ${version}` : ''}`,
             };
         }
         catch (error) {

package/dist/lib/package/index.d.ts

@@ -1,16 +1,20 @@
 import { z } from 'zod';
+import { Backend } from '../../backend/common.js';
 import { IacType } from '../../iac/common.js';
 import { InfrastructureType } from '../../infrastructure/common.js';
+import { Logger } from '../log.js';
 import { PackageManager } from './common.js';
 import { LocalPackageManager } from './local.js';
-export declare const packageManager: PackageManager;
+export declare const githubPackageManager: PackageManager;
 export declare const localPackageManager: LocalPackageManager;
-export declare function getPackageManager(protocol: string): PackageManager;
+export declare function getPackageManager(protocol: string, logger?: Logger): Promise<PackageManager>;
 export declare function resolvePackage(input: ResolvePackageInput): Promise<ResolvePackageOutput>;
 export declare function getPackageCanonicalName(packageName: string): string;
 export declare function downloadPackage(pkgUrl: string, destPath: string): Promise<string>;
 export type ResolvePackageInput = {
+    backend?: Backend;
     isDeploying?: boolean;
+    logger?: Logger;
     package: string;
     projectRootDir?: string;
 };
@@ -20,6 +24,7 @@ export type ResolvePackageOutput = {
     metadata: z.infer<typeof PackageMetadata>;
     packageUri: string;
     pkgName: string;
+    version?: string;
 } | {
     found: false;
     reason: string;
@@ -41,8 +46,8 @@ export declare const PackageMetadata: z.ZodObject<{
     }>>;
     originalInfra: z.ZodOptional<z.ZodNativeEnum<typeof InfrastructureType>>;
 }, "strip", z.ZodTypeAny, {
-    iac: IacType;
     infra: InfrastructureType;
+    iac: IacType;
     dependencies?: Record<string, string> | undefined;
     deploy?: boolean | undefined;
     onDeploy?: {
@@ -51,8 +56,8 @@ export declare const PackageMetadata: z.ZodObject<{
     } | undefined;
     originalInfra?: InfrastructureType | undefined;
 }, {
-    iac: IacType;
     infra: InfrastructureType;
+    iac: IacType;
     dependencies?: Record<string, string> | undefined;
     deploy?: boolean | undefined;
     onDeploy?: {

package/dist/lib/package/index.js

@@ -1,42 +1,139 @@
 import * as yaml from 'yaml';
 import { z } from 'zod';
+import { getCurrentBackendType } from '../../backend/config.js';
+import { BackendType, getBackend } from '../../backend/index.js';
 import { IacType } from '../../iac/common.js';
 import { InfrastructureType } from '../../infrastructure/common.js';
+import { CloudPackageManager } from './cloud.js';
 import { GitHubPackageManager } from './github.js';
 import { LocalPackageManager } from './local.js';
-export const packageManager = new GitHubPackageManager();
+export const githubPackageManager = new GitHubPackageManager();
 export const localPackageManager = new LocalPackageManager();
-export function getPackageManager(protocol) {
+export async function getPackageManager(protocol, logger) {
     if (protocol === 'local') {
         return localPackageManager;
     }
-    return packageManager;
+    if (protocol === 'cloud') {
+        const backend = await getBackend();
+        return new CloudPackageManager(backend, logger);
+    }
+    // Default to GitHub
+    return githubPackageManager;
 }
 export async function resolvePackage(input) {
-    if (input.package.includes('.')) {
+    // Parse package spec to extract name and version
+    const { packageName, version } = parsePackageSpec(input.package);
+    // Validate package name format
+    if (packageName.includes('.')) {
         return { found: false, reason: 'Invalid package format. Package name cannot contain dots (.) nor double dashes (--)' };
     }
-    if (input.package.includes('--')) {
+    if (packageName.includes('--')) {
         return { found: false, reason: 'Invalid package format. Package name cannot contain dots (.) nor double dashes (--)' };
     }
-    const isLocal = input.package.startsWith('local/');
+    const isLocal = packageName.startsWith('local/');
+    // Try cloud first if not local and backend is cloud
+    if (!isLocal) {
+        const backendType = await getCurrentBackendType();
+        if (backendType === BackendType.Cloud) {
+            const result = await tryCloudResolution(input);
+            if (result.found) {
+                return result; // Success
+            }
+            // Failed - check if we should fallback to GitHub or return the error
+            if (!packageName.includes('/')) {
+                // Simple package names can't fallback to GitHub, return the detailed error
+                return result;
+            }
+            // For owner/repo format, we can fallback to GitHub
+            input.logger?.debug(`Package ${packageName} not found in registry, trying GitHub...`);
+            input.logger?.debug(`Registry error: ${result.reason}`);
+        }
+    }
+    // Determine protocol for standard resolution
+    const protocol = isLocal ? 'local' : '';
+    // Standard resolution (GitHub or local)  
+    return resolveWithStandardManager(protocol, input, packageName, version);
+}
+export function getPackageCanonicalName(packageName) {
+    return packageName.replaceAll('/', '--');
+}
+export async function downloadPackage(pkgUrl, destPath) {
+    // Determine protocol based on URL characteristics
+    let protocol = '';
+    if (pkgUrl.startsWith('local/')) {
+        protocol = 'local';
+    }
+    else if (pkgUrl.includes('#')) {
+        // Registry package URLs contain commit SHA
+        const backendType = await getCurrentBackendType();
+        if (backendType === BackendType.Cloud) {
+            protocol = 'cloud';
+        }
+    }
+    // Otherwise defaults to GitHub
+    const packageManager = await getPackageManager(protocol);
+    return packageManager.downloadPackage(pkgUrl, destPath);
+}
+export const PackageMetadata = z.object({
+    dependencies: z.record(z.string()).optional(),
+    deploy: z.boolean().optional(),
+    iac: z.nativeEnum(IacType),
+    infra: z.nativeEnum(InfrastructureType),
+    onDeploy: z
+        .object({
+        pkg: z.string(),
+        version: z.string(),
+    })
+        .optional(),
+    originalInfra: z.nativeEnum(InfrastructureType).optional(),
+});
+// Helper function to parse package spec into name and version
+function parsePackageSpec(spec) {
+    const match = spec.match(/^([^@]+)(?:@(.+))?$/);
+    if (!match) {
+        return { packageName: spec };
+    }
+    const [, packageName, version] = match;
+    return { packageName, version };
+}
+// Helper function to try cloud resolution
+async function tryCloudResolution(input) {
+    const cloudManager = await getPackageManager('cloud', input.logger);
+    const cloudPackageInfo = await cloudManager.resolvePackage(input.package);
+    if (cloudPackageInfo) {
+        // Successfully found in registry, now get metadata
+        input.logger?.debug(`Found package in registry: ${cloudPackageInfo.name}@${cloudPackageInfo.version}`);
+        const result = await resolveCloudPackage(cloudPackageInfo, cloudManager, input);
+        input.logger?.debug(`Metadata resolution result: ${result.found ? 'success' : result.reason}`);
+        return result; // Return success or failure with detailed reason
+    }
+    // Package not found in registry at all
+    return {
+        found: false,
+        reason: `Package '${input.package}' not found in cloud registry. Make sure the package name is correct and you have access to it.`
+    };
+}
+// Helper function for standard (GitHub/local) resolution
+async function resolveWithStandardManager(protocol, input, packageName, version) {
+    // Standard managers don't support logger yet
+    // Parse owner/repo from package name
     let [owner, repo] = ['', ''];
-    if (isLocal) {
+    if (protocol === 'local') {
         owner = 'local';
-        repo = input.package.replace('local/', '');
+        repo = packageName.replace('local/', '');
     }
     else {
-        const pkgParts = input.package.split('/');
+        const pkgParts = packageName.split('/');
         if (pkgParts.length !== 2) {
-            return { found: false, reason: 'Invalid package format. Use owner/repository' };
+            return { found: false, reason: 'Invalid package format. Use owner/repository or org/name' };
         }
         ;
         [owner, repo] = pkgParts;
     }
-    const packageManager = getPackageManager(isLocal ? 'local' : '');
+    const packageManager = await getPackageManager(protocol);
     const metadataContentCandidates = (await Promise.all([
-        packageManager.getRepoContent({ owner, path: 'hereyarc.yaml', projectRootDir: input.projectRootDir, repo }),
-        packageManager.getRepoContent({ owner, path: 'hereyarc.yml', projectRootDir: input.projectRootDir, repo }),
+        packageManager.getRepoContent({ owner, path: 'hereyarc.yaml', projectRootDir: input.projectRootDir, repo, version }),
+        packageManager.getRepoContent({ owner, path: 'hereyarc.yml', projectRootDir: input.projectRootDir, repo, version }),
     ])).filter((content$) => content$.found);
     if (metadataContentCandidates.length === 0) {
         return { found: false, reason: `No hereya metadata file found in ${input.package}` };
@@ -48,37 +145,83 @@ export async function resolvePackage(input) {
             return { found: false, reason: 'Package has dependencies but is not a deploy package' };
         }
         if (input.isDeploying && metadata.onDeploy) {
-            return resolvePackage({ package: metadata.onDeploy.pkg, projectRootDir: input.projectRootDir });
+            return resolvePackage({ ...input, package: metadata.onDeploy.pkg });
         }
         return {
-            canonicalName: getPackageCanonicalName(input.package),
+            canonicalName: getPackageCanonicalName(packageName),
             found: true,
             metadata,
             packageUri: metadataContent$.pkgUrl,
-            pkgName: input.package,
+            pkgName: packageName,
+            version: version || '',
         };
     }
     catch (error) {
         return { found: false, reason: error.message };
     }
 }
-export function getPackageCanonicalName(packageName) {
-    return packageName.replaceAll('/', '--');
-}
-export async function downloadPackage(pkgUrl, destPath) {
-    const packageManager = getPackageManager(pkgUrl.startsWith('local/') ? 'local' : '');
-    return packageManager.downloadPackage(pkgUrl, destPath);
+// Helper function to resolve cloud package metadata
+async function resolveCloudPackage(packageInfo, cloudManager, input) {
+    // Parse package name to determine owner/repo for getRepoContent interface
+    // For simple names like 'mongo', owner will be empty
+    // For org/name format like 'hereya/mongo', split into owner and repo
+    const parts = packageInfo.name.split('/');
+    const owner = parts.length === 2 ? parts[0] : '';
+    const repo = parts.length === 2 ? parts[1] : packageInfo.name;
+    // Get metadata using the standard getRepoContent interface
+    // CloudPackageManager will reconstruct the package name and look it up in registry
+    const metadataContentCandidates = (await Promise.all([
+        cloudManager.getRepoContent({
+            owner,
+            path: 'hereyarc.yaml',
+            projectRootDir: input.projectRootDir,
+            repo,
+            version: packageInfo.version,
+        }),
+        cloudManager.getRepoContent({
+            owner,
+            path: 'hereyarc.yml',
+            projectRootDir: input.projectRootDir,
+            repo,
+            version: packageInfo.version,
+        }),
+    ])).filter((content$) => content$.found);
+    if (metadataContentCandidates.length === 0) {
+        // Try to get more detailed error from the last attempt
+        const lastAttempt = await cloudManager.getRepoContent({
+            owner,
+            path: 'hereyarc.yaml',
+            projectRootDir: input.projectRootDir,
+            repo,
+        });
+        const detailedReason = !lastAttempt.found && lastAttempt.reason
+            ? lastAttempt.reason
+            : `No hereya metadata file (hereyarc.yaml or hereyarc.yml) found for package '${packageInfo.name}'`;
+        return { found: false, reason: detailedReason };
+    }
+    const metadataContent$ = metadataContentCandidates[0];
+    try {
+        const metadata = PackageMetadata.parse(yaml.parse(metadataContent$.content));
+        if (!metadata.deploy && metadata.dependencies) {
+            return { found: false, reason: 'Package has dependencies but is not a deploy package' };
+        }
+        if (input.isDeploying && metadata.onDeploy) {
+            return resolvePackage({ ...input, package: metadata.onDeploy.pkg });
+        }
+        // Build packageUri with repository and commit
+        const packageUri = packageInfo.registryPackage.commit
+            ? `${packageInfo.registryPackage.repository}#${packageInfo.registryPackage.commit}`
+            : packageInfo.registryPackage.repository || metadataContent$.pkgUrl;
+        return {
+            canonicalName: getPackageCanonicalName(packageInfo.name),
+            found: true,
+            metadata,
+            packageUri,
+            pkgName: packageInfo.name,
+            version: packageInfo.version,
+        };
+    }
+    catch (error) {
+        return { found: false, reason: error.message };
+    }
 }
-export const PackageMetadata = z.object({
-    dependencies: z.record(z.string()).optional(),
-    deploy: z.boolean().optional(),
-    iac: z.nativeEnum(IacType),
-    infra: z.nativeEnum(InfrastructureType),
-    onDeploy: z
-        .object({
-        pkg: z.string(),
-        version: z.string(),
-    })
-        .optional(),
-    originalInfra: z.nativeEnum(InfrastructureType).optional(),
-});

package/dist/lib/package/local.js

@@ -7,6 +7,7 @@ export class LocalPackageManager {
         return destPath;
     }
     async getRepoContent({ path: filePath, projectRootDir, repo }) {
+        // Local packages don't have versions, version parameter is ignored
         try {
             const pkgRootDir = path.join(projectRootDir ?? process.cwd(), repo);
             const resolvedPath = path.join(pkgRootDir, filePath);

package/oclif.manifest.json

@@ -1877,5 +1877,5 @@
       ]
     }
   },
-  "version": "0.56.0"
+  "version": "0.57.1"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hereya-cli",
   "description": "Infrastructure as Package",
-  "version": "0.56.0",
+  "version": "0.57.1",
   "author": "Hereya Developers",
   "bin": {
     "hereya": "./bin/run.js"
@@ -24,7 +24,7 @@
     "ignore": "^7.0.3",
     "keytar": "^7.9.0",
     "listr2": "^8.2.5",
-    "marked": "^16.1.2",
+    "marked": "^15.0.12",
     "marked-terminal": "7.3.0",
     "node-machine-id": "^1.1.12",
     "open": "^10.1.1",
@@ -43,6 +43,8 @@
     "@types/mock-fs": "^4.13.4",
     "@types/node": "^22",
     "@types/sinon": "^17.0.3",
+    "@types/sinon-chai": "^4.0.0",
+    "@types/tar": "^6.1.13",
     "@types/unzip-stream": "^0.3.4",
     "chai": "^5.1.2",
     "eslint": "^9.20.1",
@@ -56,6 +58,7 @@
     "oclif": "^4.17.27",
     "shx": "^0.3.4",
     "sinon": "^19.0.2",
+    "sinon-chai": "^4.0.0",
     "tsx": "^4.20.3",
     "typescript": "^5.7.3"
   },