@onslaughtsnail/caelis 0.0.31 → 0.0.33

package/README.md

@@ -18,8 +18,6 @@ npx @onslaughtsnail/caelis --help
 
 ## How it works
 
-This package downloads the platform-specific `caelis` binary from GitHub Releases during `postinstall`.
+This package installs a platform-specific `caelis` binary from npm optional dependencies.
 
-If your environment blocks postinstall network access, download the binary from:
-
-- https://github.com/OnslaughtSnail/caelis/releases
+This keeps installation traffic on the npm registry path instead of fetching binaries from GitHub Releases during `postinstall`.

package/bin/caelis.js

@@ -4,12 +4,41 @@ const { spawn } = require('node:child_process');
 const fs = require('node:fs');
 const path = require('node:path');
 
-const exeName = process.platform === 'win32' ? 'caelis.exe' : 'caelis';
-const binPath = path.join(__dirname, '..', 'runtime', exeName);
+const packageMap = {
+  'darwin:arm64': '@onslaughtsnail/caelis-darwin-arm64',
+  'darwin:x64': '@onslaughtsnail/caelis-darwin-x64',
+  'linux:arm64': '@onslaughtsnail/caelis-linux-arm64',
+  'linux:x64': '@onslaughtsnail/caelis-linux-x64',
+};
+
+function resolvePackageName() {
+  const key = `${process.platform}:${process.arch}`;
+  const packageName = packageMap[key];
+  if (!packageName) {
+    console.error(`[caelis] unsupported platform/arch: ${process.platform}/${process.arch}`);
+    process.exit(1);
+  }
+  return packageName;
+}
+
+function resolveBinaryPath(packageName) {
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`);
+    return path.join(path.dirname(packageJsonPath), 'runtime', 'caelis');
+  } catch (err) {
+    console.error(`[caelis] platform package not installed: ${packageName}`);
+    console.error('[caelis] reinstall without --omit=optional, then try again.');
+    console.error('[caelis] resolve error:', err.message);
+    process.exit(1);
+  }
+}
+
+const packageName = resolvePackageName();
+const binPath = resolveBinaryPath(packageName);
 
 if (!fs.existsSync(binPath)) {
   console.error('[caelis] binary not found at', binPath);
-  console.error('[caelis] try: npm rebuild @onslaughtsnail/caelis');
+  console.error(`[caelis] reinstall ${packageName}, then try again.`);
   process.exit(1);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onslaughtsnail/caelis",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "description": "caelis CLI distributed via npm",
   "license": "Apache-2.0",
   "repository": {
@@ -17,7 +17,6 @@
   "files": [
     "bin",
     "scripts",
-    "runtime",
     "README.md",
     "LICENSE"
   ],
@@ -30,14 +29,19 @@
     "arm64"
   ],
   "scripts": {
-    "postinstall": "node ./scripts/postinstall.mjs",
-    "prepare": "node ./scripts/prepare.mjs"
+    "prepare": "node ./scripts/prepare.mjs",
+    "set-version": "node ./scripts/set-version.mjs",
+    "stage-release": "node ./scripts/stage-release.mjs",
+    "publish-release": "node ./scripts/publish-release.mjs"
   },
-  "dependencies": {
-    "extract-zip": "^2.0.1",
-    "tar": "^7.4.3"
+  "optionalDependencies": {
+    "@onslaughtsnail/caelis-darwin-arm64": "0.0.33",
+    "@onslaughtsnail/caelis-darwin-x64": "0.0.33",
+    "@onslaughtsnail/caelis-linux-arm64": "0.0.33",
+    "@onslaughtsnail/caelis-linux-x64": "0.0.33"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   }
 }

package/scripts/publish-release.mjs

@@ -0,0 +1,79 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, '..');
+
+function runCommand(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      ...options,
+      stdio: 'inherit',
+    });
+    child.on('error', reject);
+    child.on('exit', (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`${command} exited with code ${code}`));
+    });
+  });
+}
+
+async function readManifest(packageDir) {
+  const manifestPath = path.join(packageDir, 'package.json');
+  const raw = await fs.readFile(manifestPath, 'utf8');
+  return JSON.parse(raw);
+}
+
+async function versionExists(name, version) {
+  try {
+    const { stdout } = await execFileAsync(
+      'npm',
+      ['view', `${name}@${version}`, 'version', '--registry=https://registry.npmjs.org'],
+      { cwd: packageRoot },
+    );
+    return stdout.trim() === version;
+  } catch {
+    return false;
+  }
+}
+
+async function publishPackage(packageDir) {
+  const manifest = await readManifest(packageDir);
+  if (await versionExists(manifest.name, manifest.version)) {
+    console.log(`[caelis] skip publish for ${manifest.name}@${manifest.version}; already exists`);
+    return;
+  }
+  console.log(`[caelis] publishing ${manifest.name}@${manifest.version}`);
+  const args = ['publish', '--access', 'public'];
+  if (process.env.CAELIS_NPM_PUBLISH_PROVENANCE === 'false') {
+    args.push('--provenance=false');
+  }
+  if (manifest.version.includes('-')) {
+    args.push('--tag', 'bootstrap');
+  }
+  await runCommand('npm', args, { cwd: packageDir });
+}
+
+async function main() {
+  const inputs = process.argv.slice(2);
+  if (inputs.length === 0) {
+    throw new Error('expected at least one package directory');
+  }
+  for (const input of inputs) {
+    const packageDir = path.resolve(input);
+    await publishPackage(packageDir);
+  }
+}
+
+main().catch((err) => {
+  console.error('[caelis] failed to publish packages:', err.message);
+  process.exit(1);
+});

package/scripts/set-version.mjs

@@ -0,0 +1,52 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, '..');
+
+const platformPackages = [
+  '@onslaughtsnail/caelis-darwin-arm64',
+  '@onslaughtsnail/caelis-darwin-x64',
+  '@onslaughtsnail/caelis-linux-arm64',
+  '@onslaughtsnail/caelis-linux-x64',
+];
+
+const manifestPaths = [
+  path.join(packageRoot, 'package.json'),
+  path.join(packageRoot, 'packages', 'caelis-darwin-arm64', 'package.json'),
+  path.join(packageRoot, 'packages', 'caelis-darwin-x64', 'package.json'),
+  path.join(packageRoot, 'packages', 'caelis-linux-arm64', 'package.json'),
+  path.join(packageRoot, 'packages', 'caelis-linux-x64', 'package.json'),
+];
+
+function normalizeVersion(input) {
+  const version = String(input || '').trim().replace(/^v/, '');
+  if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version)) {
+    throw new Error(`invalid version: ${input}`);
+  }
+  return version;
+}
+
+async function updateManifest(manifestPath, version) {
+  const raw = await fs.readFile(manifestPath, 'utf8');
+  const manifest = JSON.parse(raw);
+  manifest.version = version;
+  if (manifest.name === '@onslaughtsnail/caelis') {
+    manifest.optionalDependencies = Object.fromEntries(
+      platformPackages.map((packageName) => [packageName, version]),
+    );
+  }
+  await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+
+async function main() {
+  const version = normalizeVersion(process.argv[2]);
+  await Promise.all(manifestPaths.map((manifestPath) => updateManifest(manifestPath, version)));
+}
+
+main().catch((err) => {
+  console.error('[caelis] failed to update package versions:', err.message);
+  process.exit(1);
+});

package/scripts/stage-release.mjs

@@ -0,0 +1,78 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, '..');
+
+const targets = [
+  { os: 'darwin', arch: 'arm64', dir: 'caelis-darwin-arm64' },
+  { os: 'darwin', arch: 'amd64', dir: 'caelis-darwin-x64' },
+  { os: 'linux', arch: 'arm64', dir: 'caelis-linux-arm64' },
+  { os: 'linux', arch: 'amd64', dir: 'caelis-linux-x64' },
+];
+
+function normalizeVersion(input) {
+  const version = String(input || '').trim().replace(/^v/, '');
+  if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version)) {
+    throw new Error(`invalid version: ${input}`);
+  }
+  return version;
+}
+
+async function findFile(rootDir, expectedName) {
+  const queue = [rootDir];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const entries = await fs.readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        queue.push(full);
+        continue;
+      }
+      if (entry.isFile() && entry.name === expectedName) {
+        return full;
+      }
+    }
+  }
+  return '';
+}
+
+async function stageTarget(version, distDir, target) {
+  const archiveName = `caelis_${version}_${target.os}_${target.arch}.tar.gz`;
+  const archivePath = path.join(distDir, archiveName);
+  const packageDir = path.join(packageRoot, 'packages', target.dir);
+  const runtimeDir = path.join(packageDir, 'runtime');
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), `caelis-${target.dir}-`));
+  try {
+    await fs.access(archivePath);
+    await execFileAsync('tar', ['-xzf', archivePath, '-C', tempDir]);
+    const extractedBin = await findFile(tempDir, 'caelis');
+    if (!extractedBin) {
+      throw new Error(`binary not found in ${archiveName}`);
+    }
+    await fs.mkdir(runtimeDir, { recursive: true });
+    const destPath = path.join(runtimeDir, 'caelis');
+    await fs.copyFile(extractedBin, destPath);
+    await fs.chmod(destPath, 0o755);
+  } finally {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+async function main() {
+  const version = normalizeVersion(process.argv[2]);
+  const distDir = path.resolve(process.argv[3] || path.join(packageRoot, '..', 'dist'));
+  await Promise.all(targets.map((target) => stageTarget(version, distDir, target)));
+}
+
+main().catch((err) => {
+  console.error('[caelis] failed to stage platform packages:', err.message);
+  process.exit(1);
+});

package/scripts/postinstall.mjs

@@ -1,196 +0,0 @@
-import fs from 'node:fs/promises';
-import { createWriteStream } from 'node:fs';
-import { constants as fsConstants } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import https from 'node:https';
-import { pipeline } from 'node:stream/promises';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const packageDir = path.resolve(__dirname, '..');
-const runtimeDir = path.join(packageDir, 'runtime');
-const packageJsonPath = path.join(packageDir, 'package.json');
-
-const repoOwner = 'OnslaughtSnail';
-const repoName = 'caelis';
-const skipVar = process.env.CAELIS_NPM_SKIP_DOWNLOAD;
-
-function resolveTarget() {
-  const platform = process.platform;
-  const arch = process.arch;
-
-  const osMap = {
-    darwin: 'darwin',
-    linux: 'linux',
-  };
-  const archMap = {
-    x64: 'amd64',
-    arm64: 'arm64',
-  };
-
-  const goos = osMap[platform];
-  const goarch = archMap[arch];
-  if (!goos || !goarch) {
-    throw new Error(`unsupported platform/arch: ${platform}/${arch}; supported: darwin|linux with x64|arm64`);
-  }
-
-  return {
-    platform,
-    goos,
-    goarch,
-    archiveExt: goos === 'windows' ? 'zip' : 'tar.gz',
-    binName: goos === 'windows' ? 'caelis.exe' : 'caelis',
-  };
-}
-
-async function readPackageVersion() {
-	const raw = await fs.readFile(packageJsonPath, 'utf8');
-	const pkg = JSON.parse(raw);
-	const version = String(pkg.version || '').trim();
-	if (!version) {
-		throw new Error('invalid package version for release download');
-	}
-	return version;
-}
-
-function buildAssetURL(version, target) {
-  const tag = `v${version}`;
-  const file = `${repoName}_${version}_${target.goos}_${target.goarch}.${target.archiveExt}`;
-  return {
-    url: `https://github.com/${repoOwner}/${repoName}/releases/download/${tag}/${file}`,
-    filename: file,
-  };
-}
-
-async function download(url, toFile, redirects = 0) {
-	if (redirects > 5) {
-		throw new Error(`too many redirects while downloading ${url}`);
-	}
-	await fs.mkdir(path.dirname(toFile), { recursive: true });
-	await new Promise((resolve, reject) => {
-		const req = https.get(url, (res) => {
-			if ([301, 302, 307, 308].includes(res.statusCode || 0)) {
-				const location = String(res.headers.location || '').trim();
-				if (!location) {
-					reject(new Error(`redirect without location header (${url})`));
-					return;
-				}
-				const nextURL = new URL(location, url).toString();
-				res.resume();
-				download(nextURL, toFile, redirects + 1).then(resolve).catch(reject);
-				return;
-			}
-			if (res.statusCode !== 200) {
-				reject(new Error(`download failed: HTTP ${res.statusCode} (${url})`));
-				res.resume();
-				return;
-			}
-			pipeline(res, createWriteStream(toFile)).then(resolve).catch(reject);
-		});
-		req.on('error', reject);
-	});
-}
-
-async function extractArchive(archivePath, tempDir, target) {
-	if (target.archiveExt === 'zip') {
-		const extractMod = await import('extract-zip');
-		const extract = extractMod.default || extractMod;
-		if (typeof extract !== 'function') {
-			throw new Error('extract-zip module does not export a callable extractor');
-		}
-		await extract(archivePath, { dir: tempDir });
-		return;
-	}
-	const tarMod = await import('tar');
-	const tar = tarMod.default || tarMod;
-	if (!tar || typeof tar.x !== 'function') {
-		throw new Error('tar module does not export x() extractor');
-	}
-	await tar.x({
-		file: archivePath,
-		cwd: tempDir,
-    gzip: true,
-  });
-}
-
-async function findFile(rootDir, expectedName) {
-  const queue = [rootDir];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    const entries = await fs.readdir(current, { withFileTypes: true });
-    for (const entry of entries) {
-      const full = path.join(current, entry.name);
-      if (entry.isDirectory()) {
-        queue.push(full);
-        continue;
-      }
-      if (entry.isFile() && entry.name === expectedName) {
-        return full;
-      }
-    }
-  }
-  return '';
-}
-
-async function installBinary(sourcePath, targetName) {
-  await fs.mkdir(runtimeDir, { recursive: true });
-  const destPath = path.join(runtimeDir, targetName);
-  await fs.copyFile(sourcePath, destPath);
-  if (process.platform !== 'win32') {
-    await fs.chmod(destPath, 0o755);
-  }
-  return destPath;
-}
-
-async function fileExists(p) {
-  try {
-    await fs.access(p, fsConstants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function main() {
-  if (skipVar === '1' || skipVar === 'true') {
-    console.log('[caelis] skip download due to CAELIS_NPM_SKIP_DOWNLOAD');
-    return;
-  }
-
-	const version = await readPackageVersion();
-	if (version === '0.0.0') {
-		console.log('[caelis] skip download for development version 0.0.0');
-		return;
-	}
-	const target = resolveTarget();
-  const existingPath = path.join(runtimeDir, target.binName);
-  if (await fileExists(existingPath)) {
-    return;
-  }
-
-  const { url, filename } = buildAssetURL(version, target);
-  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'caelis-npm-'));
-  const archivePath = path.join(tempDir, filename);
-
-  try {
-    console.log(`[caelis] downloading ${url}`);
-    await download(url, archivePath);
-    await extractArchive(archivePath, tempDir, target);
-    const extractedBin = await findFile(tempDir, target.binName);
-    if (!extractedBin) {
-      throw new Error(`binary ${target.binName} not found in release archive`);
-    }
-    const installed = await installBinary(extractedBin, target.binName);
-    console.log(`[caelis] installed binary: ${installed}`);
-  } finally {
-    await fs.rm(tempDir, { recursive: true, force: true });
-  }
-}
-
-main().catch((err) => {
-  console.error('[caelis] postinstall failed:', err.message);
-  console.error('[caelis] fallback: download release binary manually from GitHub Releases.');
-  process.exit(1);
-});