hereya-cli 0.55.0 → 0.57.0

package/dist/commands/import/index.js

@@ -135,8 +135,9 @@ export default class Import extends Command {
                                 const configManager = getConfigManager();
                                 await configManager.addPackage({
                                     metadata: ctx.importOutput.metadata,
-                                    package: ctx.package,
+                                    package: ctx.importOutput.pkgName,
                                     projectRootDir,
+                                    version: ctx.importOutput.version,
                                 });
                                 await delay(500);
                             },

package/dist/commands/publish/index.d.ts

@@ -0,0 +1,32 @@
+import { Command } from '@oclif/core';
+interface HereyarcConfig {
+    description: string;
+    iac: string;
+    infra: string;
+    name: string;
+    onDeploy?: {
+        pkg: string;
+        version: string;
+    };
+    version: string;
+    visibility?: 'PRIVATE' | 'private' | 'PUBLIC' | 'public';
+}
+export default class Publish extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        chdir: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    calculateGitArchiveSha256(packageDir: string): Promise<string>;
+    displayPublishError(reason: string, config: HereyarcConfig): void;
+    getGitInfo(packageDir: string): Promise<{
+        commit: string;
+        repository: string;
+        sha256: string;
+    }>;
+    loadConfig(packageDir: string): Promise<HereyarcConfig>;
+    loadReadme(packageDir: string): string | undefined;
+    run(): Promise<void>;
+    validateConfig(config: HereyarcConfig): void;
+}
+export {};

package/dist/commands/publish/index.js

@@ -0,0 +1,239 @@
+import { Command, Flags } from '@oclif/core';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { simpleGit } from 'simple-git';
+import * as yaml from 'yaml';
+import { getBackend } from '../../backend/index.js';
+export default class Publish extends Command {
+    static description = 'Publish a package to the Hereya registry';
+    static examples = [
+        '$ hereya publish',
+        '$ hereya publish --chdir=/path/to/package',
+    ];
+    static flags = {
+        chdir: Flags.string({
+            description: `
+        Directory where the command will be executed.
+        If not specified, it defaults to the current working directory.
+      `,
+            required: false,
+        }),
+    };
+    async calculateGitArchiveSha256(packageDir) {
+        const { exec } = await import('node:child_process');
+        const { promisify } = await import('node:util');
+        const execAsync = promisify(exec);
+        try {
+            // Create a tar archive of HEAD and calculate its SHA256
+            const { stdout } = await execAsync('git archive --format=tar HEAD | shasum -a 256', {
+                cwd: packageDir,
+                encoding: 'utf8',
+                maxBuffer: 50 * 1024 * 1024 // 50MB buffer for large repos
+            });
+            // The shasum output is "hash  -" so we take the first part
+            const sha256 = stdout.trim().split(' ')[0];
+            if (!sha256 || sha256.length !== 64) {
+                this.error('Failed to calculate SHA256 hash of the repository');
+            }
+            return sha256;
+        }
+        catch (error) {
+            this.error(`Failed to calculate SHA256: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    displayPublishError(reason, config) {
+        this.log('\n❌ Failed to publish package\n');
+        // Handle specific error cases with helpful messages
+        if (reason.toLowerCase().includes('already exists')) {
+            this.log(`Package ${config.name}@${config.version} already exists in the registry.`);
+            this.log('\nPossible solutions:');
+            this.log('  • Increment the version number in hereyarc.yaml');
+            this.log('  • Use a different package name');
+            this.log('  • If you own this package, delete the existing version first');
+        }
+        else if (reason.toLowerCase().includes('permission')) {
+            this.log('You do not have permission to publish this package.');
+            this.log('\nPossible reasons:');
+            this.log('  • The package namespace is owned by another user/organization');
+            this.log('  • Your account does not have publishing privileges');
+            this.log('  • Contact the namespace owner for access');
+        }
+        else if (reason.toLowerCase().includes('authentication')) {
+            this.log('Authentication failed.');
+            this.log('\nPlease run: hereya login');
+        }
+        else if (reason.includes('\n')) {
+            // Multiple validation errors
+            this.log('Validation errors:');
+            const errors = reason.split('\n');
+            for (const error of errors) {
+                this.log(`  • ${error}`);
+            }
+        }
+        else {
+            // Single error message
+            this.log(`Error: ${reason}`);
+        }
+        this.log(''); // Empty line for spacing
+        this.error('Package publication failed', { exit: 1 });
+    }
+    async getGitInfo(packageDir) {
+        const git = simpleGit(packageDir);
+        // Check if it's a git repository
+        const isRepo = await git.checkIsRepo();
+        if (!isRepo) {
+            this.error('The current directory is not a git repository');
+        }
+        // Get current commit SHA
+        const commit = await git.revparse(['HEAD']);
+        if (!commit) {
+            this.error('Could not get current commit SHA');
+        }
+        // Get repository URL
+        const remotes = await git.getRemotes(true);
+        if (remotes.length === 0) {
+            this.error('No git remotes found');
+        }
+        // Use origin remote by default, or the first one available
+        const origin = remotes.find((r) => r.name === 'origin') || remotes[0];
+        if (!origin || !origin.refs.fetch) {
+            this.error('Could not find repository URL');
+        }
+        let repository = origin.refs.fetch;
+        // Convert SSH URLs to HTTPS
+        if (repository.startsWith('git@github.com:')) {
+            repository = repository.replace('git@github.com:', 'https://github.com/');
+        }
+        // Remove .git suffix if present
+        if (repository.endsWith('.git')) {
+            repository = repository.slice(0, -4);
+        }
+        // Calculate SHA256 of the git archive
+        const sha256 = await this.calculateGitArchiveSha256(packageDir);
+        return { commit: commit.trim(), repository, sha256 };
+    }
+    async loadConfig(packageDir) {
+        // Look for hereyarc.yaml or hereyarc.yml
+        let configPath = join(packageDir, 'hereyarc.yaml');
+        if (!existsSync(configPath)) {
+            configPath = join(packageDir, 'hereyarc.yml');
+            if (!existsSync(configPath)) {
+                this.error('No hereyarc.yaml or hereyarc.yml file found in the current directory');
+            }
+        }
+        // Parse the configuration file
+        const configContent = readFileSync(configPath, 'utf8');
+        const config = yaml.parse(configContent);
+        // Validate required fields
+        this.validateConfig(config);
+        return config;
+    }
+    loadReadme(packageDir) {
+        // Check for README files in various formats
+        const readmeVariants = [
+            'README.md',
+            'readme.md',
+            'Readme.md',
+            'README.MD',
+            'README',
+            'readme',
+            'README.txt',
+            'readme.txt',
+        ];
+        for (const variant of readmeVariants) {
+            const readmePath = join(packageDir, variant);
+            if (existsSync(readmePath)) {
+                try {
+                    const content = readFileSync(readmePath, 'utf8');
+                    if (content.trim()) {
+                        this.log(`   README: Found ${variant}`);
+                        return content;
+                    }
+                }
+                catch {
+                    // Ignore read errors and try next variant
+                    continue;
+                }
+            }
+        }
+        this.log('   README: Not found (optional)');
+        return undefined;
+    }
+    async run() {
+        const { flags } = await this.parse(Publish);
+        const packageDir = flags.chdir || process.cwd();
+        try {
+            // Load and validate configuration
+            const config = await this.loadConfig(packageDir);
+            // Display package info
+            this.log(`\n📦 Preparing package ${config.name}@${config.version}`);
+            this.log(`   Description: ${config.description}`);
+            this.log(`   Infrastructure: ${config.infra} (${config.iac})`);
+            if (config.visibility) {
+                this.log(`   Visibility: ${config.visibility}`);
+            }
+            // Get git information (including SHA256 of git archive)
+            this.log('\n🔍 Analyzing repository...');
+            const gitInfo = await this.getGitInfo(packageDir);
+            const { commit, repository, sha256 } = gitInfo;
+            this.log(`   Repository: ${repository}`);
+            this.log(`   Commit: ${commit.slice(0, 8)}`);
+            this.log(`   SHA256: ${sha256.slice(0, 16)}...`);
+            // Load README content if available
+            const readmeContent = this.loadReadme(packageDir);
+            // Load backend configuration and check if it's cloud backend
+            this.log('\n🔐 Checking authentication...');
+            const backend = await getBackend();
+            if (!backend.publishPackage) {
+                this.log('\n❌ Authentication failed\n');
+                this.error('Publishing packages is only supported with the cloud backend. Please run `hereya login` first.');
+            }
+            this.log('   ✓ Authenticated with Hereya Cloud');
+            // Prepare the publish input (normalize visibility to uppercase)
+            const publishInput = {
+                commit: commit.trim(),
+                description: config.description,
+                doc: readmeContent,
+                iac: config.iac,
+                infra: config.infra,
+                name: config.name,
+                onDeployPkg: config.onDeploy?.pkg,
+                onDeployVersion: config.onDeploy?.version,
+                repository,
+                sha256,
+                version: config.version,
+                visibility: config.visibility?.toUpperCase(),
+            };
+            this.log('\n📤 Publishing to registry...');
+            // Publish the package
+            const result = await backend.publishPackage(publishInput);
+            if (!result.success) {
+                this.displayPublishError(result.reason, config);
+                return;
+            }
+            this.log(`\n✅ Successfully published ${result.package.name}@${result.package.version}`);
+            this.log(`   Package ID: ${result.package.id}`);
+            this.log('');
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+    validateConfig(config) {
+        if (!config.name) {
+            this.error('Missing required field "name" in hereyarc.yaml');
+        }
+        if (!config.version) {
+            this.error('Missing required field "version" in hereyarc.yaml');
+        }
+        if (!config.description) {
+            this.error('Missing required field "description" in hereyarc.yaml');
+        }
+        if (!config.iac) {
+            this.error('Missing required field "iac" in hereyarc.yaml');
+        }
+        if (!config.infra) {
+            this.error('Missing required field "infra" in hereyarc.yaml');
+        }
+    }
+}

package/dist/commands/remove/index.js

@@ -68,9 +68,21 @@ export default class Remove extends Command {
                                     throw new Error(validation.message);
                                 }
                                 const { config } = loadConfigOutput;
-                                if (!(ctx.package in (config.packages ?? {})) && !(ctx.package in (config.deploy ?? {}))) {
-                                    throw new Error(`Package ${ctx.package} not found in the project.`);
+                                // Parse package name to extract name and version
+                                const [packageNameWithoutVersion, userSpecifiedVersion] = ctx.package.split('@');
+                                // Check if package exists in config (using clean name without version)
+                                const packageInfo = config.packages?.[packageNameWithoutVersion] || config.deploy?.[packageNameWithoutVersion];
+                                if (!packageInfo) {
+                                    throw new Error(`Package ${packageNameWithoutVersion} not found in the project.`);
                                 }
+                                // Get the installed version from config
+                                const installedVersion = packageInfo.version || '';
+                                // If user specified a version, validate it matches the installed version
+                                if (userSpecifiedVersion && userSpecifiedVersion !== installedVersion) {
+                                    throw new Error(`Package ${packageNameWithoutVersion} version mismatch: installed version is ${installedVersion || 'unspecified'}, but you specified ${userSpecifiedVersion}. ` +
+                                        `Please use 'hereya remove ${packageNameWithoutVersion}' to remove the installed version.`);
+                                }
+                                ctx.packageWithInstalledVersion = installedVersion ? `${packageNameWithoutVersion}@${installedVersion}` : packageNameWithoutVersion;
                                 await delay(500);
                             },
                             title: 'Loading project config',
@@ -102,7 +114,7 @@ export default class Remove extends Command {
                                 const { executor } = executor$;
                                 const destroyOutput = await executor.destroy({
                                     logger: getLogger(task),
-                                    package: ctx.package,
+                                    package: ctx.packageWithInstalledVersion,
                                     parameters: ctx.parametersOutput.parameters,
                                     project: ctx.configOutput.config.project,
                                     projectRootDir,
@@ -134,7 +146,7 @@ export default class Remove extends Command {
                                 const configManager = getConfigManager();
                                 await configManager.removePackage({
                                     metadata: ctx.destroyOutput.metadata,
-                                    package: ctx.package,
+                                    package: ctx.destroyOutput.pkgName,
                                     projectRootDir,
                                 });
                                 await delay(500);

package/dist/commands/undeploy/index.js

@@ -98,14 +98,42 @@ export default class Undeploy extends Command {
                         },
                         {
                             async task(ctx) {
-                                const deployPackages = Object.keys(ctx.configOutput.config.deploy ?? {});
-                                const savedDeployPackages = Object.keys(ctx.savedStateOutput?.config.deploy ?? {});
-                                const removedDeployPackages = savedDeployPackages.filter((packageName) => !deployPackages.includes(packageName));
-                                ctx.deployPackages = [...removedDeployPackages, ...deployPackages];
-                                const packages = Object.keys(ctx.configOutput.config.packages ?? {});
-                                const savedPackages = Object.keys(ctx.savedStateOutput?.config.packages ?? {});
-                                const removedPackages = savedPackages.filter((packageName) => !packages.includes(packageName));
-                                ctx.packages = [...removedPackages, ...packages];
+                                // Get deploy packages with versions from config
+                                const configDeployPackages = ctx.configOutput.config.deploy ?? {};
+                                const deployPackagesWithVersions = Object.entries(configDeployPackages).map(([name, info]) => ({
+                                    name,
+                                    packageSpec: info.version ? `${name}@${info.version}` : name,
+                                    version: info.version || ''
+                                }));
+                                // Get removed deploy packages with versions from saved state
+                                const savedDeployPackages = ctx.savedStateOutput?.config.deploy ?? {};
+                                const currentDeployPackageNames = Object.keys(configDeployPackages);
+                                const removedDeployPackages = Object.entries(savedDeployPackages)
+                                    .filter(([name]) => !currentDeployPackageNames.includes(name))
+                                    .map(([name, info]) => ({
+                                    name,
+                                    packageSpec: info.version ? `${name}@${info.version}` : name,
+                                    version: info.version || ''
+                                }));
+                                ctx.deployPackages = [...removedDeployPackages, ...deployPackagesWithVersions];
+                                // Get regular packages with versions from config
+                                const configPackages = ctx.configOutput.config.packages ?? {};
+                                const packagesWithVersions = Object.entries(configPackages).map(([name, info]) => ({
+                                    name,
+                                    packageSpec: info.version ? `${name}@${info.version}` : name,
+                                    version: info.version || ''
+                                }));
+                                // Get removed packages with versions from saved state
+                                const savedPackages = ctx.savedStateOutput?.config.packages ?? {};
+                                const currentPackageNames = Object.keys(configPackages);
+                                const removedPackages = Object.entries(savedPackages)
+                                    .filter(([name]) => !currentPackageNames.includes(name))
+                                    .map(([name, info]) => ({
+                                    name,
+                                    packageSpec: info.version ? `${name}@${info.version}` : name,
+                                    version: info.version || ''
+                                }));
+                                ctx.packages = [...removedPackages, ...packagesWithVersions];
                                 await delay(500);
                             },
                             title: 'Identifying removed packages',
@@ -113,7 +141,7 @@ export default class Undeploy extends Command {
                         {
                             skip: (ctx) => ctx.deployPackages.length === 0,
                             async task(ctx, task) {
-                                return task.newListr(ctx.deployPackages.map((packageName) => ({
+                                return task.newListr(ctx.deployPackages.map((pkg) => ({
                                     rendererOptions: {
                                         persistentOutput: isDebug(),
                                     },
@@ -122,7 +150,7 @@ export default class Undeploy extends Command {
                                         const backend = await getBackend();
                                         const profile = await getProfileFromWorkspace(backend, ctx.workspace, ctx.configOutput.config.project);
                                         const { parameters } = await parameterManager.getPackageParameters({
-                                            package: packageName,
+                                            package: pkg.name,
                                             profile,
                                             projectRootDir,
                                         });
@@ -134,7 +162,7 @@ export default class Undeploy extends Command {
                                         const destroyOutput = await executor.destroy({
                                             isDeploying: true,
                                             logger: getLogger(task),
-                                            package: packageName,
+                                            package: pkg.packageSpec,
                                             parameters,
                                             project: ctx.configOutput.config.project,
                                             projectEnv: ctx.projectEnv,
@@ -145,7 +173,7 @@ export default class Undeploy extends Command {
                                             throw new Error(destroyOutput.reason);
                                         }
                                     },
-                                    title: `Destroying package ${packageName}`,
+                                    title: `Destroying package ${pkg.name}`,
                                 })), { concurrent: false, rendererOptions: { collapseSubtasks: !isDebug() } });
                             },
                             title: 'Destroying deployment packages',
@@ -153,7 +181,7 @@ export default class Undeploy extends Command {
                         {
                             skip: (ctx) => !ctx.packages || ctx.packages.length === 0,
                             async task(ctx, task) {
-                                return task.newListr(ctx.packages.map((packageName) => ({
+                                return task.newListr(ctx.packages.map((pkg) => ({
                                     rendererOptions: {
                                         persistentOutput: isDebug(),
                                     },
@@ -162,7 +190,7 @@ export default class Undeploy extends Command {
                                         const backend = await getBackend();
                                         const profile = await getProfileFromWorkspace(backend, ctx.workspace, ctx.configOutput.config.project);
                                         const { parameters } = await parameterManager.getPackageParameters({
-                                            package: packageName,
+                                            package: pkg.name,
                                             profile,
                                             projectRootDir,
                                         });
@@ -174,7 +202,7 @@ export default class Undeploy extends Command {
                                         const destroyOutput = await executor.destroy({
                                             isDeploying: true,
                                             logger: getLogger(task),
-                                            package: packageName,
+                                            package: pkg.packageSpec,
                                             parameters,
                                             project: ctx.configOutput.config.project,
                                             projectRootDir,
@@ -185,10 +213,10 @@ export default class Undeploy extends Command {
                                         }
                                         const { env, metadata } = destroyOutput;
                                         const output = ctx.destroyed || [];
-                                        output.push({ env, metadata, packageName });
+                                        output.push({ env, metadata, packageName: pkg.name });
                                         ctx.destroyed = output;
                                     },
-                                    title: `Destroying ${packageName}`,
+                                    title: `Destroying ${pkg.name}`,
                                 })), { concurrent: true, rendererOptions: { collapseSubtasks: !isDebug() } });
                             },
                             title: `Destroying packages`,

package/dist/commands/up/index.js

@@ -85,14 +85,39 @@ export default class Up extends Command {
                         },
                         {
                             async task(ctx) {
-                                const packages = Object.keys(ctx.configOutput.config.packages ?? {});
+                                // Get packages with their versions from config
+                                const configPackages = ctx.configOutput.config.packages ?? {};
+                                const packagesWithVersions = Object.entries(configPackages).map(([name, info]) => ({
+                                    name,
+                                    packageSpec: info.version ? `${name}@${info.version}` : name,
+                                    version: info.version || ''
+                                }));
                                 const savedPackages = Object.keys(ctx.savedStateOutput?.config?.packages ?? {});
-                                const removedPackages = savedPackages.filter((packageName) => !packages.includes(packageName));
+                                const removedPackages = savedPackages.filter((packageName) => !configPackages[packageName]);
                                 ctx.removedPackages = removedPackages;
-                                ctx.packages =
-                                    flags.select.length > 0
-                                        ? packages.filter((packageName) => flags.select.includes(packageName))
-                                        : packages;
+                                // Handle --select flag with version validation
+                                if (flags.select.length > 0) {
+                                    const selectedPackages = [];
+                                    for (const selectedPkg of flags.select) {
+                                        // Parse the selected package to extract name and version
+                                        const [selectedName, selectedVersion] = selectedPkg.split('@');
+                                        // Find the package in the config
+                                        const configPkg = packagesWithVersions.find(pkg => pkg.name === selectedName);
+                                        if (!configPkg) {
+                                            throw new Error(`Package ${selectedName} not found in project`);
+                                        }
+                                        // If user specified a version, validate it matches the installed version
+                                        if (selectedVersion && selectedVersion !== configPkg.version) {
+                                            throw new Error(`Package ${selectedName} version mismatch: installed version is ${configPkg.version || 'unspecified'}, but you specified ${selectedVersion}. ` +
+                                                `Please use 'hereya up -s ${selectedName}' to use the installed version, or update the package to version ${selectedVersion} first.`);
+                                        }
+                                        selectedPackages.push(configPkg);
+                                    }
+                                    ctx.packages = selectedPackages;
+                                }
+                                else {
+                                    ctx.packages = packagesWithVersions;
+                                }
                                 await delay(500);
                             },
                             title: 'Searching for removed packages',
@@ -150,7 +175,7 @@ export default class Up extends Command {
                                 if (!ctx.packages || ctx.packages.length === 0) {
                                     return;
                                 }
-                                return task.newListr(ctx.packages.map((packageName) => ({
+                                return task.newListr(ctx.packages.map((pkg) => ({
                                     rendererOptions: {
                                         persistentOutput: isDebug(),
                                     },
@@ -159,7 +184,7 @@ export default class Up extends Command {
                                         const backend = await getBackend();
                                         const profile = await getProfileFromWorkspace(backend, ctx.workspace, ctx.configOutput.config.project);
                                         const { parameters } = await parameterManager.getPackageParameters({
-                                            package: packageName,
+                                            package: pkg.name,
                                             profile,
                                             projectRootDir,
                                         });
@@ -171,7 +196,7 @@ export default class Up extends Command {
                                         const provisionOutput = await executor.provision({
                                             isDeploying: flags.deploy,
                                             logger: getLogger(task),
-                                            package: packageName,
+                                            package: pkg.packageSpec,
                                             parameters,
                                             project: ctx.configOutput.config.project,
                                             projectRootDir,
@@ -182,10 +207,10 @@ export default class Up extends Command {
                                         }
                                         const { env, metadata } = provisionOutput;
                                         const output = ctx.added || [];
-                                        output.push({ env, metadata, packageName });
+                                        output.push({ env, metadata, packageName: pkg.name });
                                         ctx.added = output;
                                     },
-                                    title: `Provisioning ${packageName}`,
+                                    title: `Provisioning ${pkg.name}`,
                                 })), { concurrent: true, rendererOptions: { collapseSubtasks: !isDebug() } });
                             },
                             title: `Provisioning packages`,

package/dist/commands/workspace/install/index.js

@@ -106,7 +106,7 @@ export default class WorkspaceInstall extends Command {
                                 const output = await backend.addPackageToWorkspace({
                                     env,
                                     infra: metadata.infra,
-                                    package: args.package,
+                                    package: ctx.provisionOutput.pkgName,
                                     parameters: ctx.parameters,
                                     workspace: flags.workspace,
                                 });

package/dist/commands/workspace/uninstall/index.js

@@ -54,9 +54,20 @@ export default class WorkspaceUninstall extends Command {
                                 if (loadWorkspaceOutput.workspace.mirrorOf) {
                                     throw new Error(`Workspace ${flags.workspace} is a mirror of ${loadWorkspaceOutput.workspace.mirrorOf}`);
                                 }
-                                if (!(args.package in (loadWorkspaceOutput.workspace.packages ?? {}))) {
-                                    throw new Error(`Package ${args.package} not found in workspace ${flags.workspace}`);
+                                // Parse package name to extract name and version
+                                const [packageNameWithoutVersion, userSpecifiedVersion] = args.package.split('@');
+                                const packageInfo = loadWorkspaceOutput.workspace.packages?.[packageNameWithoutVersion];
+                                if (!packageInfo) {
+                                    throw new Error(`Package ${packageNameWithoutVersion} not found in workspace ${flags.workspace}`);
                                 }
+                                // Get the installed version from workspace
+                                const installedVersion = packageInfo.version || '';
+                                // If user specified a version, validate it matches the installed version
+                                if (userSpecifiedVersion && userSpecifiedVersion !== installedVersion) {
+                                    throw new Error(`Package ${packageNameWithoutVersion} version mismatch: installed version is ${installedVersion || 'unspecified'}, but you specified ${userSpecifiedVersion}. ` +
+                                        `Please use 'hereya workspace uninstall ${packageNameWithoutVersion} -w ${flags.workspace}' to uninstall the installed version.`);
+                                }
+                                ctx.packageWithInstalledVersion = installedVersion ? `${packageNameWithoutVersion}@${installedVersion}` : packageNameWithoutVersion;
                                 ctx.workspace = loadWorkspaceOutput;
                                 await delay(500);
                             },
@@ -73,8 +84,10 @@ export default class WorkspaceUninstall extends Command {
                                     }
                                     parametersFromFile = data;
                                 }
+                                // Use the clean package name to get stored parameters
+                                const packageNameWithoutVersion = args.package.split('@')[0];
                                 const parameters = {
-                                    ...ctx.workspace.workspace.packages?.[args.package].parameters,
+                                    ...ctx.workspace.workspace.packages?.[packageNameWithoutVersion].parameters,
                                     ...parametersFromFile,
                                     ...parametersInCmdline,
                                 };
@@ -95,7 +108,7 @@ export default class WorkspaceUninstall extends Command {
                                 const { executor } = executor$;
                                 const destroyOutput = await executor.destroy({
                                     logger: getLogger(task),
-                                    package: args.package,
+                                    package: ctx.packageWithInstalledVersion,
                                     parameters: ctx.parameters,
                                     workspace: flags.workspace,
                                 });
@@ -113,7 +126,7 @@ export default class WorkspaceUninstall extends Command {
                                 const output = await backend.removePackageFromWorkspace({
                                     env,
                                     infra: metadata.infra,
-                                    package: args.package,
+                                    package: ctx.destroyOutput.pkgName,
                                     workspace: flags.workspace,
                                 });
                                 if (!output.success) {

package/dist/executor/interface.d.ts

@@ -21,7 +21,9 @@ export type ExecutorProvisionOutput = {
         [key: string]: string;
     };
     metadata: IPackageMetadata;
+    pkgName: string;
     success: true;
+    version?: string;
 } | {
     reason: string;
     success: false;
@@ -61,6 +63,7 @@ export type ExecutorUnsetEnvVarInput = {
     workspace: string;
 };
 export type ExecutorImportInput = {
+    logger?: Logger;
     package: string;
     project: string;
     projectRootDir?: string;
@@ -69,7 +72,9 @@ export type ExecutorImportInput = {
 };
 export type ExecutorImportOutput = {
     metadata: IPackageMetadata;
+    pkgName: string;
     success: true;
+    version?: string;
 } | {
     reason: string;
     success: false;