create-dry-monorepo 0.0.0-stage → 0.1.3

package/bin/index.js

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const https = require('https');
+const http = require('http');
+const { spawnSync } = require('child_process');
+
+const platform = os.platform();
+const arch = os.arch();
+
+const REPO = 'momanamjad/iframe';
+const VERSION = (() => {
+  try {
+    return require('../package.json').version || '0.1.0';
+  } catch {
+    return '0.1.0';
+  }
+})();
+
+const getArtifactName = () => {
+  const map = {
+    'win32-x64': 'dry-monorepo-win32-x64.exe',
+    'darwin-arm64': 'dry-monorepo-darwin-arm64',
+    'darwin-x64': 'dry-monorepo-darwin-x64',
+    'linux-x64': 'dry-monorepo-linux-x64',
+    'linux-arm64': 'dry-monorepo-linux-arm64',
+  };
+  return map[`${platform}-${arch}`];
+};
+
+const getPackageName = () => {
+  const map = {
+    'win32-x64': '@dry-monorepo/cli-win32-x64',
+    'win32-arm64': '@dry-monorepo/cli-win32-arm64',
+    'darwin-x64': '@dry-monorepo/cli-darwin-x64',
+    'darwin-arm64': '@dry-monorepo/cli-darwin-arm64',
+    'linux-x64': '@dry-monorepo/cli-linux-x64',
+    'linux-arm64': '@dry-monorepo/cli-linux-arm64',
+  };
+  return map[`${platform}-${arch}`];
+};
+
+const downloadToBuffer = (url) => {
+  return new Promise((resolve, reject) => {
+    const request = (currentUrl, redirects = 0) => {
+      if (redirects > 5) {
+        return reject(new Error('Too many HTTP redirects'));
+      }
+
+      const client = currentUrl.startsWith('https') ? https : http;
+      client
+        .get(currentUrl, (response) => {
+          if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+            return request(response.headers.location, redirects + 1);
+          }
+
+          if (response.statusCode !== 200) {
+            return reject(new Error(`Download failed with status ${response.statusCode}`));
+          }
+
+          const chunks = [];
+          response.on('data', (chunk) => chunks.push(chunk));
+          response.on('end', () => resolve(Buffer.concat(chunks)));
+        })
+        .on('error', reject);
+    };
+
+    request(url);
+  });
+};
+
+/**
+ * Download and parse the checksums file from GitHub Releases.
+ * Returns a Map of filename -> sha256 hash.
+ */
+const downloadChecksums = async () => {
+  const url = `https://github.com/${REPO}/releases/download/v${VERSION}/checksums.sha256`;
+  try {
+    const buffer = await downloadToBuffer(url);
+    const text = buffer.toString('utf8');
+    const checksums = new Map();
+    for (const line of text.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      // Format: "<hash>  <filename>" or "<hash> <filename>"
+      const parts = trimmed.split(/\s+/);
+      if (parts.length >= 2) {
+        checksums.set(parts[1], parts[0]);
+      }
+    }
+    return checksums;
+  } catch {
+    return null; // Checksums file not available
+  }
+};
+
+/**
+ * Verify SHA-256 checksum of a downloaded file.
+ */
+const verifyChecksum = (filePath, expectedHash) => {
+  const fileBuffer = fs.readFileSync(filePath);
+  const hash = crypto.createHash('sha256').update(fileBuffer).digest('hex');
+  return hash === expectedHash;
+};
+
+const findOrDownloadBinary = async () => {
+  // 1. Try resolving from optional dependencies
+  const packageName = getPackageName();
+  if (packageName) {
+    try {
+      return require.resolve(`${packageName}/bin/dry-monorepo`);
+    } catch {
+      // Optional package not installed
+    }
+  }
+
+  // 2. Check if installed in system PATH
+  const isWindows = platform === 'win32';
+  const binName = isWindows ? 'dry-monorepo.exe' : 'dry-monorepo';
+  const checkCmd = isWindows ? 'where' : 'which';
+  const pathCheck = spawnSync(checkCmd, [binName], { stdio: 'ignore' });
+  if (pathCheck.status === 0) {
+    return binName;
+  }
+
+  // 2b. Check local development workspace target directories
+  const localCandidates = [
+    path.resolve(__dirname, '..', '..', 'target', 'release', binName),
+    path.resolve(__dirname, '..', '..', 'target', 'debug', binName),
+    path.resolve(process.cwd(), 'target', 'release', binName),
+    path.resolve(process.cwd(), 'target', 'debug', binName),
+  ];
+  for (const localBin of localCandidates) {
+    if (fs.existsSync(localBin)) {
+      return localBin;
+    }
+  }
+
+  // 3. Check user cache directory (~/.dry-monorepo/bin)
+  const artifactName = getArtifactName();
+  if (!artifactName) {
+    console.error(`\x1b[31mError: Unsupported platform or architecture: ${platform}-${arch}\x1b[0m`);
+    process.exit(1);
+  }
+
+  const cacheDir = path.join(os.homedir(), '.dry-monorepo', 'bin');
+  const cachedBinPath = path.join(cacheDir, `${VERSION}-${artifactName}`);
+
+  if (fs.existsSync(cachedBinPath)) {
+    return cachedBinPath;
+  }
+
+  // 4. Download from GitHub Releases with integrity verification
+  console.log(`\x1b[36m⚡ DRY Monorepo Generator: First-time setup...\x1b[0m`);
+  console.log(`\x1b[33m📦 Fetching native precompiled Rust binary for ${platform}-${arch}...\x1b[0m`);
+
+  try {
+    fs.mkdirSync(cacheDir, { recursive: true });
+    const downloadUrl = `https://github.com/${REPO}/releases/download/v${VERSION}/${artifactName}`;
+
+    // Download binary to a temp file first
+    const tempPath = cachedBinPath + '.tmp';
+    const binaryBuffer = await downloadToBuffer(downloadUrl);
+    fs.writeFileSync(tempPath, binaryBuffer);
+
+    // Verify SHA-256 checksum if checksums file is available
+    const checksums = await downloadChecksums();
+    if (checksums) {
+      const expectedHash = checksums.get(artifactName);
+      if (expectedHash) {
+        if (!verifyChecksum(tempPath, expectedHash)) {
+          fs.unlinkSync(tempPath);
+          throw new Error(`SHA-256 checksum mismatch for ${artifactName}. Binary may be corrupted or tampered with.`);
+        }
+        console.log(`\x1b[32m🔒 SHA-256 checksum verified.\x1b[0m`);
+      } else {
+        console.warn(`\x1b[33m⚠️ No checksum entry found for ${artifactName}, skipping verification.\x1b[0m`);
+      }
+    } else {
+      console.warn(`\x1b[33m⚠️ Checksums file not available, skipping integrity verification.\x1b[0m`);
+    }
+
+    // Move temp file to final location
+    fs.renameSync(tempPath, cachedBinPath);
+
+    if (!isWindows) {
+      fs.chmodSync(cachedBinPath, 0o755);
+    }
+
+    console.log(`\x1b[32m✨ Setup complete! Launching DRY Monorepo Generator...\x1b[0m\n`);
+    return cachedBinPath;
+  } catch (err) {
+    // Clean up temp file on failure
+    const tempPath = cachedBinPath + '.tmp';
+    if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+    if (fs.existsSync(cachedBinPath)) fs.unlinkSync(cachedBinPath);
+
+    console.warn(`\x1b[33m⚠️ Could not auto-download prebuilt binary (${err.message}).\x1b[0m`);
+    console.warn(`Falling back to system PATH binary if available...\n`);
+    return binName;
+  }
+};
+
+const run = async () => {
+  const command = await findOrDownloadBinary();
+  const rawArgs = process.argv.slice(2);
+  const knownCommands = new Set([
+    'new', 'test', 'list', 'community', 'doctor', 'deploy', 'bench', 'help', '--help', '-h', '--version', '-V'
+  ]);
+
+  let isYes = false;
+  let forwardedArgs = [];
+  let selectedPm = null;
+
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    if (arg === '--yes' || arg === '-y') {
+      isYes = true;
+    } else if (arg === '--pm' && i + 1 < rawArgs.length) {
+      selectedPm = rawArgs[++i];
+    } else if (arg.startsWith('--pm=')) {
+      selectedPm = arg.split('=')[1];
+    } else {
+      forwardedArgs.push(arg);
+    }
+  }
+
+  let finalArgs = [];
+  if (isYes) {
+    finalArgs.push('--yes');
+  }
+
+  if (forwardedArgs.length > 0 && !knownCommands.has(forwardedArgs[0]) && !forwardedArgs[0].startsWith('-')) {
+    finalArgs.push('new', ...forwardedArgs);
+  } else if (forwardedArgs.length === 0 || (!knownCommands.has(forwardedArgs[0]) && forwardedArgs[0].startsWith('-'))) {
+    finalArgs.push('new', ...forwardedArgs);
+  } else {
+    finalArgs.push(...forwardedArgs);
+  }
+
+  try {
+    const hasLocalTemplates = fs.existsSync(path.resolve(process.cwd(), 'templates')) ||
+                              fs.existsSync(path.resolve(__dirname, '..', '..', 'templates'));
+    const env = { ...process.env };
+    if (hasLocalTemplates) {
+      env.DRY_DEV_TEMPLATES = '1';
+    }
+
+    const result = spawnSync(command, finalArgs, { stdio: 'inherit', env });
+    if (result.error) {
+      if (result.error.code === 'ENOENT') {
+        console.error(`\x1b[31mError: Could not find or launch the dry-monorepo executable.\x1b[0m`);
+        console.error(`Please build from source using 'cargo build --release -p dry-cli',`);
+        console.error(`or verify your internet connection to allow downloading the precompiled release binary.`);
+      } else {
+        console.error(result.error.message);
+      }
+      process.exit(1);
+    }
+    process.exit(result.status || 0);
+  } catch (err) {
+    console.error('An unexpected error occurred:', err);
+    process.exit(1);
+  }
+};
+
+run();

package/package.json

@@ -1,6 +1,32 @@
 {
   "name": "create-dry-monorepo",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.3",
+  "description": "🚀 One Command. Infinite Possibilities. Every Stack. Zero Limits.",
+  "bin": {
+    "create-dry-monorepo": "./bin/index.js"
+  },
+  "files": [
+    "bin/"
+  ],
+  "keywords": [
+    "monorepo",
+    "generator",
+    "scaffold",
+    "boilerplate",
+    "mern",
+    "pern",
+    "fastapi",
+    "django",
+    "go",
+    "flask",
+    "fullstack"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/momanamjad/iframe.git"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.