@objectstack/cli 4.0.4 → 4.0.5

package/src/commands/plugin/remove.ts

@@ -1,97 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import { Args, Command, Flags } from '@oclif/core';
-import chalk from 'chalk';
-import fs from 'fs';
-import path from 'path';
-import { resolveConfigPath } from '../../utils/config.js';
-import { printHeader, printSuccess, printError } from '../../utils/format.js';
-
-function escapeRegex(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-/**
- * Remove a plugin reference from objectstack.config.ts.
- *
- * Removes matching import line and the entry from the plugins array.
- */
-function removePluginFromConfig(configPath: string, pluginName: string): void {
-  let content = fs.readFileSync(configPath, 'utf-8');
-
-  // Remove the import line that references this plugin (exact package name match)
-  const importRegex = new RegExp(`^import .+['"]${escapeRegex(pluginName)}['"]\\s*;?\\s*$\\n?`, 'gm');
-  const hadImport = importRegex.test(content);
-  // Reset regex lastIndex after test()
-  importRegex.lastIndex = 0;
-  content = content.replace(importRegex, '');
-
-  // Also try to remove by a derived variable name
-  const shortName = pluginName
-    .replace(/^@[^/]+\//, '')
-    .replace(/^plugin-/, '')
-    .replace(/-+/g, '-')
-    .replace(/^-|-$/g, '');
-  const varName = shortName.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase()) + 'Plugin';
-
-  // Remove import by variable name if it wasn't caught above
-  if (!hadImport) {
-    const varImportRegex = new RegExp(`^import .* ${escapeRegex(varName)} .+$\\n?`, 'gm');
-    content = content.replace(varImportRegex, '');
-  }
-
-  // Remove the entry from the plugins array
-  // Match: varName, or 'package-name', or "package-name"
-  const entryPatterns = [
-    new RegExp(`\\s*${escapeRegex(varName)},?\\n?`, 'g'),
-    new RegExp(`\\s*['"]${escapeRegex(pluginName)}['"],?\\n?`, 'g'),
-  ];
-
-  for (const pattern of entryPatterns) {
-    content = content.replace(pattern, '\n');
-  }
-
-  // Clean up empty plugins array: plugins: [\n  ],
-  content = content.replace(/plugins\s*:\s*\[\s*\],?\n?/g, '');
-
-  fs.writeFileSync(configPath, content);
-}
-
-export { removePluginFromConfig };
-
-export default class PluginRemove extends Command {
-  static override description = 'Remove a plugin from objectstack.config.ts';
-
-  static override aliases = ['plugin rm'];
-
-  static override args = {
-    name: Args.string({ description: 'Plugin name or package name to remove', required: true }),
-  };
-
-  static override flags = {
-    config: Flags.string({ char: 'c', description: 'Configuration file path' }),
-  };
-
-  async run(): Promise<void> {
-    const { args, flags } = await this.parse(PluginRemove);
-
-    try {
-      const configPath = resolveConfigPath(flags.config);
-
-      printHeader('Remove Plugin');
-      console.log(`  ${chalk.dim('Plugin:')} ${chalk.white(args.name)}`);
-      console.log(`  ${chalk.dim('Config:')} ${chalk.white(path.relative(process.cwd(), configPath))}`);
-      console.log('');
-
-      removePluginFromConfig(configPath, args.name);
-      printSuccess(`Removed ${chalk.cyan(args.name)} from config`);
-
-      console.log('');
-      console.log(chalk.dim('  Tip: Run `pnpm remove ' + args.name + '` to uninstall the package'));
-      console.log('');
-    } catch (error: any) {
-      printError(error.message || String(error));
-      this.exit(1);
-    }
-  }
-}

package/src/commands/plugin/validate.ts

@@ -1,268 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import { Args, Command, Flags } from '@oclif/core';
-import chalk from 'chalk';
-import path from 'path';
-import fs from 'fs';
-import crypto from 'crypto';
-import { createTimer, printHeader, printKV, printStep, printSuccess, printError, printWarning, printInfo } from '../../utils/format.js';
-
-/**
- * Validate a plugin artifact (.tgz) for structural integrity, checksum
- * correctness, digital signature, and platform compatibility.
- *
- * Architecture alignment: `npm pack --dry-run`, `helm lint`, `vsce ls`.
- */
-export default class PluginValidate extends Command {
-  static override description = 'Validate a plugin artifact for integrity and compliance';
-
-  static override args = {
-    artifact: Args.string({ description: 'Path to the artifact file', required: true }),
-  };
-
-  static override flags = {
-    verifySignature: Flags.boolean({ description: 'Verify digital signature', default: true, allowNo: true }),
-    publicKeyPath: Flags.string({ description: 'Path to public key for signature verification' }),
-    verifyChecksums: Flags.boolean({ description: 'Verify SHA-256 checksums', default: true, allowNo: true }),
-    validateMetadata: Flags.boolean({ description: 'Validate metadata schema compliance', default: true, allowNo: true }),
-    platformVersion: Flags.string({ description: 'Target platform version for compatibility check' }),
-    json: Flags.boolean({ description: 'Output result as JSON' }),
-  };
-
-  async run(): Promise<void> {
-    const { args, flags } = await this.parse(PluginValidate);
-    const timer = createTimer();
-
-    if (!flags.json) {
-      printHeader('Plugin Validate');
-    }
-
-    try {
-      const artifactPath = path.resolve(process.cwd(), args.artifact);
-
-      if (!fs.existsSync(artifactPath)) {
-        throw new Error(`Artifact not found: ${artifactPath}`);
-      }
-
-      if (!flags.json) {
-        printKV('Artifact', path.relative(process.cwd(), artifactPath));
-        printStep('Reading artifact...');
-      }
-
-      const artifactBuffer = fs.readFileSync(artifactPath);
-      const findings: Array<{ severity: string; rule: string; message: string; path?: string }> = [];
-
-      // 1. Verify file existence and basic structure
-      if (artifactBuffer.length === 0) {
-        findings.push({ severity: 'error', rule: 'artifact.empty', message: 'Artifact file is empty' });
-      }
-
-      // 2. Try to parse as JSON manifest
-      let manifest: Record<string, unknown> | undefined;
-      try {
-        manifest = JSON.parse(artifactBuffer.toString('utf-8'));
-        findings.push({ severity: 'info', rule: 'manifest.parsed', message: 'Manifest parsed successfully' });
-      } catch {
-        findings.push({ severity: 'error', rule: 'manifest.invalid', message: 'Artifact does not contain valid JSON manifest' });
-      }
-
-      // 3. Validate required manifest fields
-      if (manifest) {
-        if (!flags.json) printStep('Validating manifest fields...');
-
-        if (!(manifest as any).manifest && !(manifest as any).name) {
-          findings.push({ severity: 'warning', rule: 'manifest.name', message: 'No package name found in manifest' });
-        }
-        if (!(manifest as any).manifest?.version && !(manifest as any).version) {
-          findings.push({ severity: 'warning', rule: 'manifest.version', message: 'No version found in manifest' });
-        }
-      }
-
-      // 4. Checksum verification
-      let checksumResult: { passed: boolean; mismatches?: string[] } | undefined;
-      if (flags.verifyChecksums) {
-        if (!flags.json) printStep('Verifying checksums...');
-        const checksumFile = artifactPath + '.sha256';
-        if (fs.existsSync(checksumFile)) {
-          const checksumContent = fs.readFileSync(checksumFile, 'utf-8').trim();
-          const expectedHash = checksumContent.split(/\s+/)[0];
-          const actualHash = crypto.createHash('sha256').update(artifactBuffer).digest('hex');
-          if (expectedHash === actualHash) {
-            checksumResult = { passed: true };
-            findings.push({ severity: 'info', rule: 'checksum.sha256', message: 'SHA-256 checksum verified' });
-          } else {
-            checksumResult = { passed: false, mismatches: ['artifact'] };
-            findings.push({ severity: 'error', rule: 'checksum.sha256', message: `SHA-256 mismatch: expected ${expectedHash.slice(0, 16)}..., got ${actualHash.slice(0, 16)}...` });
-          }
-        } else {
-          findings.push({ severity: 'warning', rule: 'checksum.missing', message: 'No .sha256 checksum file found alongside artifact' });
-        }
-      }
-
-      // 5. Signature verification
-      let signatureResult: { passed: boolean; failureReason?: string } | undefined;
-      if (flags.verifySignature) {
-        if (!flags.json) printStep('Verifying signature...');
-        const sigFile = artifactPath + '.sig';
-        if (fs.existsSync(sigFile) && flags.publicKeyPath && fs.existsSync(flags.publicKeyPath)) {
-          try {
-            const publicKey = fs.readFileSync(flags.publicKeyPath, 'utf-8');
-            const signature = fs.readFileSync(sigFile, 'utf-8');
-            const verifier = crypto.createVerify('RSA-SHA256');
-            verifier.update(artifactBuffer);
-            const valid = verifier.verify(publicKey, signature, 'base64');
-            signatureResult = { passed: valid, failureReason: valid ? undefined : 'Signature does not match' };
-            findings.push({
-              severity: valid ? 'info' : 'error',
-              rule: 'signature.verify',
-              message: valid ? 'Digital signature verified' : 'Digital signature verification failed',
-            });
-          } catch (e: any) {
-            signatureResult = { passed: false, failureReason: e.message };
-            findings.push({ severity: 'error', rule: 'signature.verify', message: `Signature verification error: ${e.message}` });
-          }
-        } else if (fs.existsSync(sigFile) && !flags.publicKeyPath) {
-          findings.push({ severity: 'warning', rule: 'signature.nokey', message: 'Signature file found but no --publicKeyPath provided' });
-        } else if (!fs.existsSync(sigFile)) {
-          findings.push({ severity: 'info', rule: 'signature.absent', message: 'No signature file found (unsigned artifact)' });
-        }
-      }
-
-      // 6. Platform compatibility check
-      let platformResult: { compatible: boolean; requiredRange?: string; targetVersion?: string } | undefined;
-      if (flags.platformVersion && manifest) {
-        if (!flags.json) printStep('Checking platform compatibility...');
-        const engine = (manifest as any).manifest?.engine || (manifest as any).engine;
-        const required = engine?.objectstack as string | undefined;
-        if (required) {
-          // Semver range check supporting >=, >, ^, ~, and exact versions
-          const parseSemver = (v: string) => {
-            const parts = v.replace(/^v/, '').split('.').map(p => parseInt(p, 10));
-            return { major: parts[0] || 0, minor: parts[1] || 0, patch: parts[2] || 0 };
-          };
-
-          const target = parseSemver(flags.platformVersion);
-          let compatible = false;
-          let matched = false;
-
-          // >=X.Y.Z — greater than or equal
-          const gteMatch = required.match(/^>=\s*([\d.]+)/);
-          if (gteMatch) {
-            const req = parseSemver(gteMatch[1]);
-            compatible = (target.major > req.major) ||
-              (target.major === req.major && target.minor > req.minor) ||
-              (target.major === req.major && target.minor === req.minor && target.patch >= req.patch);
-            matched = true;
-          }
-
-          // >X.Y.Z — strictly greater than
-          if (!matched) {
-            const gtMatch = required.match(/^>\s*([\d.]+)/);
-            if (gtMatch) {
-              const req = parseSemver(gtMatch[1]);
-              compatible = (target.major > req.major) ||
-                (target.major === req.major && target.minor > req.minor) ||
-                (target.major === req.major && target.minor === req.minor && target.patch > req.patch);
-              matched = true;
-            }
-          }
-
-          // ^X.Y.Z — caret range (same major, >= minor.patch)
-          if (!matched) {
-            const caretMatch = required.match(/^\^\s*([\d.]+)/);
-            if (caretMatch) {
-              const req = parseSemver(caretMatch[1]);
-              compatible = target.major === req.major &&
-                ((target.minor > req.minor) ||
-                  (target.minor === req.minor && target.patch >= req.patch));
-              matched = true;
-            }
-          }
-
-          // ~X.Y.Z — tilde range (same major.minor, >= patch)
-          if (!matched) {
-            const tildeMatch = required.match(/^~\s*([\d.]+)/);
-            if (tildeMatch) {
-              const req = parseSemver(tildeMatch[1]);
-              compatible = target.major === req.major && target.minor === req.minor && target.patch >= req.patch;
-              matched = true;
-            }
-          }
-
-          // Exact version match
-          if (!matched && /^\d+\.\d+\.\d+$/.test(required)) {
-            const req = parseSemver(required);
-            compatible = target.major === req.major && target.minor === req.minor && target.patch === req.patch;
-            matched = true;
-          }
-
-          if (matched) {
-            platformResult = { compatible, requiredRange: required, targetVersion: flags.platformVersion };
-            findings.push({
-              severity: compatible ? 'info' : 'error',
-              rule: 'platform.compatibility',
-              message: compatible
-                ? `Compatible with platform v${flags.platformVersion}`
-                : `Requires platform ${required}, but target is v${flags.platformVersion}`,
-            });
-          }
-        } else {
-          platformResult = { compatible: true, targetVersion: flags.platformVersion };
-          findings.push({ severity: 'info', rule: 'platform.noreq', message: 'No platform version requirement specified — assumed compatible' });
-        }
-      }
-
-      // 7. Summary
-      const errors = findings.filter(f => f.severity === 'error').length;
-      const warns = findings.filter(f => f.severity === 'warning').length;
-      const infos = findings.filter(f => f.severity === 'info').length;
-      const valid = errors === 0;
-
-      const result = {
-        valid,
-        checksumVerification: checksumResult,
-        signatureVerification: signatureResult,
-        platformCompatibility: platformResult,
-        findings,
-        summary: { errors, warnings: warns, infos },
-      };
-
-      if (flags.json) {
-        console.log(JSON.stringify(result, null, 2));
-        return;
-      }
-
-      console.log('');
-      if (valid) {
-        printSuccess(`Validation passed ${chalk.dim(`(${timer.display()})`)}`);
-      } else {
-        printError(`Validation failed ${chalk.dim(`(${timer.display()})`)}`);
-      }
-
-      console.log('');
-      for (const finding of findings) {
-        const icon = finding.severity === 'error' ? chalk.red('✗')
-          : finding.severity === 'warning' ? chalk.yellow('⚠')
-            : chalk.blue('ℹ');
-        console.log(`  ${icon} ${chalk.dim(`[${finding.rule}]`)} ${finding.message}`);
-      }
-
-      console.log('');
-      printKV('Errors', errors);
-      printKV('Warnings', warns);
-      printKV('Info', infos);
-      console.log('');
-
-      if (!valid) {
-        this.exit(1);
-      }
-    } catch (error: any) {
-      if (flags.json) {
-        console.log(JSON.stringify({ valid: false, findings: [{ severity: 'error', rule: 'system', message: error.message }], summary: { errors: 1, warnings: 0, infos: 0 } }));
-        this.exit(1);
-      }
-      printError(error.message || String(error));
-      this.exit(1);
-    }
-  }
-}