@cdm-lang/cli 0.1.34

package/README.md

@@ -0,0 +1,101 @@
+# CDM CLI - npm Package
+
+This directory contains the npm distribution package for CDM CLI. The npm package automatically downloads and installs the appropriate pre-built binary for the user's platform.
+
+## Structure
+
+```
+npm/
+├── package.json          # npm package configuration
+├── index.js              # Module entry point for programmatic usage
+├── bin/
+│   └── cdm.js           # CLI wrapper script
+├── scripts/
+│   └── install.js       # Post-install script to download binary
+├── .npmignore           # Files to exclude from npm package
+└── README.npm.md        # README shown on npm registry
+```
+
+## How It Works
+
+1. User runs `npm install @cdm-lang/cli`
+2. The `postinstall` script (`scripts/install.js`) runs automatically
+3. It detects the user's platform and architecture
+4. Downloads the appropriate pre-built binary from GitHub releases
+5. Verifies the checksum for security
+6. Makes the binary executable (Unix-like systems)
+7. The `bin/cdm.js` wrapper allows users to run `cdm` commands
+
+## Publishing to npm
+
+### Prerequisites
+
+1. Make sure you're logged into npm:
+   ```bash
+   npm login
+   ```
+
+2. Ensure the version in `package.json` matches the Cargo version
+
+### Publish Steps
+
+1. Navigate to the npm directory:
+   ```bash
+   cd npm
+   ```
+
+2. Test the package locally:
+   ```bash
+   npm install
+   npm pack
+   ```
+
+3. Publish to npm:
+   ```bash
+   npm publish --access public
+   ```
+
+   Note: The `--access public` flag is required for scoped packages (@cdm-lang/cli)
+
+### Automation
+
+You can automate npm publishing in the GitHub release workflow by adding an npm publish step after the CLI binaries are released.
+
+## Testing Locally
+
+Before publishing, test the package locally:
+
+```bash
+cd npm
+npm install
+./bin/cdm.js --help
+```
+
+Or test as if installed globally:
+
+```bash
+cd npm
+npm pack
+npm install -g cdm-lang-cli-<version>.tgz
+cdm --help
+npm uninstall -g @cdm-lang/cli
+```
+
+## Version Management
+
+Keep the version in `npm/package.json` synchronized with `crates/cdm/Cargo.toml`. When cutting a new release:
+
+1. Update version in `Cargo.toml`
+2. Update version in `npm/package.json`
+3. Create git tag and push (triggers GitHub release)
+4. After binaries are built, publish to npm
+
+## Important Notes on Self-Update
+
+The CDM CLI has a built-in `cdm update` command that can update the binary directly. However, when CDM is installed via npm, users should be aware:
+
+- `cdm update` will work and update the binary in `node_modules/@cdm-lang/cli/bin/cdm`
+- However, this creates a version mismatch - npm will still think the old version is installed
+- Running `npm install` again will re-download the version specified in `package.json`, overwriting manual updates
+
+**Recommendation**: Users should update via npm (`npm update -g @cdm-lang/cli`) rather than using `cdm update` to keep package versions in sync. This is documented in `README.npm.md`.

package/README.npm.md

@@ -0,0 +1,97 @@
+# CDM CLI
+
+**CDM (Common Data Model)** is a language for defining data models and generating code across multiple platforms.
+
+## Installation
+
+Install via npm:
+
+```bash
+npm install -g @cdm-lang/cli
+```
+
+Or use it in a project:
+
+```bash
+npm install --save-dev @cdm-lang/cli
+```
+
+## Usage
+
+After installation, the `cdm` command will be available:
+
+```bash
+cdm --help
+```
+
+### Command Line
+
+```bash
+# Run CDM CLI
+cdm <command> [options]
+```
+
+### Programmatic Usage
+
+You can also use CDM programmatically in Node.js:
+
+```javascript
+const cdm = require('@cdm-lang/cli');
+
+// Get the path to the binary
+const binaryPath = cdm.getBinaryPath();
+console.log('CDM binary location:', binaryPath);
+
+// Run CDM with arguments
+const exitCode = cdm.run(['--help']);
+```
+
+## How It Works
+
+This npm package automatically downloads the appropriate pre-built CDM binary for your platform during installation. The binary is built from Rust and distributed via GitHub releases.
+
+### Supported Platforms
+
+- macOS (Intel x64)
+- macOS (Apple Silicon arm64)
+- Linux (x64)
+- Linux (ARM64)
+- Windows (x64)
+
+## Updating
+
+To update CDM to a newer version, use npm:
+
+```bash
+# For global installations
+npm update -g @cdm-lang/cli
+
+# For local project installations
+npm update @cdm-lang/cli
+```
+
+**Note**: The CDM CLI has a built-in `cdm update` command, but when installed via npm, you should use `npm update` instead to keep your npm package registry in sync with the actual binary version.
+
+## Troubleshooting
+
+If you encounter installation issues:
+
+1. Make sure you have a stable internet connection
+2. Try clearing npm cache: `npm cache clean --force`
+3. Reinstall: `npm uninstall -g @cdm-lang/cli && npm install -g @cdm-lang/cli`
+
+If the binary fails to download, you can manually install CDM from the [GitHub releases page](https://github.com/cdm-lang/cdm/releases).
+
+## License
+
+MPL-2.0
+
+## Links
+
+- [GitHub Repository](https://github.com/cdm-lang/cdm)
+- [Issue Tracker](https://github.com/cdm-lang/cdm/issues)
+- [Releases](https://github.com/cdm-lang/cdm/releases)
+
+## Contributing
+
+Contributions are welcome! Please visit the [GitHub repository](https://github.com/cdm-lang/cdm) for more information.

package/bin/cdm.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const BINARY_NAME = process.platform === 'win32' ? 'cdm.exe' : 'cdm';
+const BINARY_PATH = path.join(__dirname, BINARY_NAME);
+
+// Check if binary exists
+if (!fs.existsSync(BINARY_PATH)) {
+  console.error('Error: CDM binary not found.');
+  console.error('This usually means the installation did not complete successfully.');
+  console.error('Try reinstalling the package: npm install @cdm-lang/cdm');
+  process.exit(1);
+}
+
+// Spawn the binary with all arguments
+const child = spawn(BINARY_PATH, process.argv.slice(2), {
+  stdio: 'inherit',
+  windowsHide: true,
+});
+
+child.on('exit', (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+  } else {
+    process.exit(code);
+  }
+});
+
+// Handle process termination
+process.on('SIGINT', () => {
+  child.kill('SIGINT');
+  child.kill('SIGTERM');
+});

package/index.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const BINARY_NAME = process.platform === 'win32' ? 'cdm.exe' : 'cdm';
+const BINARY_PATH = path.join(__dirname, 'bin', BINARY_NAME);
+
+function getBinaryPath() {
+  return BINARY_PATH;
+}
+
+function run(args = []) {
+  const result = spawnSync(BINARY_PATH, args, {
+    stdio: 'inherit',
+    windowsHide: true,
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  return result.status;
+}
+
+module.exports = {
+  getBinaryPath,
+  run,
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@cdm-lang/cli",
+  "version": "0.1.34",
+  "description": "CDM (Common Data Model) - A language for defining data models and generating code",
+  "main": "index.js",
+  "bin": {
+    "cdm": "./bin/cdm.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "cdm",
+    "data-model",
+    "schema",
+    "code-generation",
+    "cli",
+    "rust"
+  ],
+  "author": "CDM Lang",
+  "license": "MPL-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cdm-lang/cdm.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cdm-lang/cdm/issues"
+  },
+  "homepage": "https://github.com/cdm-lang/cdm#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "files": [
+    "bin/cdm.js",
+    "scripts/",
+    "index.js",
+    "README.npm.md"
+  ]
+}

package/scripts/install.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { promisify } = require('util');
+const { pipeline } = require('stream');
+
+const streamPipeline = promisify(pipeline);
+
+const MANIFEST_URL = 'https://raw.githubusercontent.com/cdm-lang/cdm/main/cli-releases.json';
+const BINARY_DIR = path.join(__dirname, '..', 'bin');
+const BINARY_NAME = process.platform === 'win32' ? 'cdm.exe' : 'cdm';
+const BINARY_PATH = path.join(BINARY_DIR, BINARY_NAME);
+
+function getPlatformInfo() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  const platformMap = {
+    darwin: {
+      x64: 'x86_64-apple-darwin',
+      arm64: 'aarch64-apple-darwin',
+    },
+    linux: {
+      x64: 'x86_64-unknown-linux-gnu',
+      arm64: 'aarch64-unknown-linux-gnu',
+    },
+    win32: {
+      x64: 'x86_64-pc-windows-msvc.exe',
+    },
+  };
+
+  if (!platformMap[platform] || !platformMap[platform][arch]) {
+    throw new Error(
+      `Unsupported platform: ${platform}-${arch}. ` +
+      `CDM supports: macOS (x64, arm64), Linux (x64, arm64), Windows (x64)`
+    );
+  }
+
+  return platformMap[platform][arch];
+}
+
+function fetchJSON(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if (res.statusCode === 302 || res.statusCode === 301) {
+        return fetchJSON(res.headers.location).then(resolve).catch(reject);
+      }
+
+      if (res.statusCode !== 200) {
+        return reject(new Error(`Failed to fetch ${url}: ${res.statusCode}`));
+      }
+
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (err) {
+          reject(err);
+        }
+      });
+    }).on('error', reject);
+  });
+}
+
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if (res.statusCode === 302 || res.statusCode === 301) {
+        return downloadFile(res.headers.location, destPath).then(resolve).catch(reject);
+      }
+
+      if (res.statusCode !== 200) {
+        return reject(new Error(`Failed to download ${url}: ${res.statusCode}`));
+      }
+
+      const fileStream = fs.createWriteStream(destPath);
+      streamPipeline(res, fileStream)
+        .then(resolve)
+        .catch(reject);
+    }).on('error', reject);
+  });
+}
+
+function verifyChecksum(filePath, expectedChecksum) {
+  const fileBuffer = fs.readFileSync(filePath);
+  const hash = crypto.createHash('sha256');
+  hash.update(fileBuffer);
+  const actualChecksum = hash.digest('hex');
+
+  if (actualChecksum !== expectedChecksum) {
+    throw new Error(
+      `Checksum verification failed!\n` +
+      `Expected: ${expectedChecksum}\n` +
+      `Actual:   ${actualChecksum}`
+    );
+  }
+}
+
+async function install() {
+  console.log('Installing CDM CLI...');
+
+  try {
+    // Get platform info
+    const platformKey = getPlatformInfo();
+    console.log(`Platform: ${platformKey}`);
+
+    // Fetch manifest
+    console.log('Fetching release manifest...');
+    const manifest = await fetchJSON(MANIFEST_URL);
+
+    const latestVersion = manifest.latest;
+    console.log(`Latest version: ${latestVersion}`);
+
+    const release = manifest.releases[latestVersion];
+    if (!release) {
+      throw new Error(`Release ${latestVersion} not found in manifest`);
+    }
+
+    const platformInfo = release.platforms[platformKey];
+    if (!platformInfo) {
+      throw new Error(`Platform ${platformKey} not found in release ${latestVersion}`);
+    }
+
+    const { url, checksum } = platformInfo;
+    const expectedChecksum = checksum.replace('sha256:', '');
+
+    // Create bin directory
+    if (!fs.existsSync(BINARY_DIR)) {
+      fs.mkdirSync(BINARY_DIR, { recursive: true });
+    }
+
+    // Download binary
+    console.log(`Downloading from ${url}...`);
+    await downloadFile(url, BINARY_PATH);
+
+    // Verify checksum
+    console.log('Verifying checksum...');
+    verifyChecksum(BINARY_PATH, expectedChecksum);
+
+    // Make executable (Unix only)
+    if (process.platform !== 'win32') {
+      fs.chmodSync(BINARY_PATH, 0o755);
+    }
+
+    console.log('CDM CLI installed successfully!');
+    console.log(`Binary location: ${BINARY_PATH}`);
+    console.log('\nRun "cdm --help" to get started.');
+
+  } catch (error) {
+    console.error('Installation failed:', error.message);
+    process.exit(1);
+  }
+}
+
+install();