@compressius/cmx 0.2.23 → 0.2.24

package/bin/cmx.js

@@ -18,7 +18,15 @@ if (!os || !arch) {
 async function main() {
   const extension = os === 'windows' ? '.exe' : '';
   const binary = path.join(__dirname, '..', 'platform', `cmx-${os}-${arch}${extension}`);
-  if (!fs.existsSync(binary)) await require('../scripts/install').install();
+  if (!fs.existsSync(binary)) {
+    // The download screen settles before the requested command runs; a failed
+    // download exits without ever spawning a partial or missing binary.
+    try {
+      await require('../scripts/install').install();
+    } catch {
+      process.exit(1);
+    }
+  }
 
   const result = spawnSync(binary, process.argv.slice(2), { stdio: 'inherit' });
   if (result.error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compressius/cmx",
-  "version": "0.2.23",
+  "version": "0.2.24",
   "description": "CMX local context-compression gateway",
   "license": "MIT",
   "repository": {

package/scripts/install.js

@@ -4,6 +4,7 @@ const crypto = require('node:crypto');
 const fs = require('node:fs');
 const https = require('node:https');
 const path = require('node:path');
+const readline = require('node:readline');
 
 const packageJson = require('../package.json');
 const platforms = { darwin: 'darwin', linux: 'linux', win32: 'windows' };
@@ -19,13 +20,149 @@ const asset = `cmx-${os}-${arch}${os === 'windows' ? '.exe' : ''}`;
 const tag = `v${packageJson.version}`;
 const releaseBase = `https://github.com/compressius/cmx/releases/download/${tag}`;
 
-function download(url, redirects = 0) {
+const HIDE_CURSOR = '\x1b[?25l';
+const SHOW_CURSOR = '\x1b[?25h';
+const ACCENT = '38;2;217;119;87';
+const ACCENT_LIGHT = '38;2;240;169;142';
+
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 0) return '0 B';
+  if (bytes < 1024) return `${Math.floor(bytes)} B`;
+  const units = ['KB', 'MB', 'GB', 'TB'];
+  let value = bytes;
+  let unit = -1;
+  do {
+    value /= 1024;
+    unit += 1;
+  } while (value >= 1024 && unit < units.length - 1);
+  return `${value >= 100 ? value.toFixed(0) : value.toFixed(1)} ${units[unit]}`;
+}
+
+// renderBar draws only received bytes against a reliable total. An unknown
+// total yields an empty track; callers must pair it with byte counts instead
+// of inventing a percentage.
+function renderBar(received, total, width) {
+  if (!(total > 0)) return '░'.repeat(width);
+  const ratio = Math.min(1, Math.max(0, received / total));
+  const filled = Math.max(0, Math.min(width, Math.round(ratio * width)));
+  return '█'.repeat(filled) + '░'.repeat(width - filled);
+}
+
+function terminalSupportsAnimation(stream) {
+  if (!stream.isTTY) return false;
+  if (process.env.TERM === 'dumb') return false;
+  if (process.platform === 'win32' && !process.env.WT_SESSION && !process.env.ANSICON && !process.env.TERM) {
+    return false;
+  }
+  return true;
+}
+
+// createProgress renders the local download screen. Interactive terminals get
+// an in-place branded block; piped output gets plain truthful lines with no
+// escape codes. Progress is stderr-only so command output stays clean.
+function createProgress(stream) {
+  const interactive = terminalSupportsAnimation(stream);
+  const color = interactive && !process.env.NO_COLOR;
+  const paint = (code, value) => (color ? `\x1b[${code}m${value}\x1b[0m` : value);
+  const accent = (value) => paint(ACCENT, value);
+  const dim = (value) => paint('2', value);
+  const shown = () => stream.write(SHOW_CURSOR);
+
+  let drawn = 0;
+  let status = '';
+  let closed = false;
+  const showOnExit = () => shown();
+
+  if (interactive) {
+    stream.write(HIDE_CURSOR);
+    process.once('exit', showOnExit);
+  }
+
+  const header = `${accent('CMX')} ${dim('· Compressius Maximus')}`;
+
+  function erase() {
+    if (drawn === 0) return;
+    readline.moveCursor(stream, 0, -drawn);
+    for (let line = 0; line < drawn; line += 1) {
+      readline.clearLine(stream, 0);
+      readline.cursorTo(stream, 0);
+      stream.write('\n');
+    }
+    readline.moveCursor(stream, 0, -drawn);
+    readline.cursorTo(stream, 0);
+    drawn = 0;
+  }
+
+  function draw(lines) {
+    if (!interactive) return;
+    erase();
+    for (const line of lines) stream.write(`${line}\n`);
+    drawn = lines.length;
+  }
+
+  function settle(lines) {
+    if (!interactive) return;
+    erase();
+    for (const line of lines) stream.write(`${line}\n`);
+  }
+
+  function barLine(received, total) {
+    const columns = stream.columns || 80;
+    const width = Math.max(12, Math.min(36, columns - 34));
+    const bar = accent(renderBar(received, total, width).replace(/░+$/, (empty) => dim(empty)));
+    if (total > 0) {
+      const percent = Math.floor(Math.min(1, received / total) * 100);
+      return `  ${bar} ${String(percent).padStart(3)}% ${formatBytes(received)} / ${formatBytes(total)}`;
+    }
+    return `  ${bar} ${formatBytes(received)} downloaded`;
+  }
+
+  return {
+    begin(label) {
+      status = label;
+      if (interactive) draw([header, status]);
+      else stream.write(`${label}\n`);
+    },
+    update(received, total) {
+      if (!interactive) return;
+      const now = Date.now();
+      if (received < total && now - (this._paintedAt || 0) < 80) return;
+      this._paintedAt = now;
+      draw([header, status, barLine(received, total)]);
+    },
+    stage(label) {
+      status = label;
+      if (interactive) draw([header, dim(label)]);
+      else stream.write(`${label}\n`);
+    },
+    done(message) {
+      settle([header, `  ${accent('✓')} ${message}`]);
+      if (!interactive) stream.write(`✓ ${message}\n`);
+    },
+    fail(message) {
+      const line = `  ${paint(ACCENT_LIGHT, '✗')} ${message}`;
+      settle([header, line]);
+      if (!interactive) stream.write(`${message}\n`);
+    },
+    cancel(message) {
+      this.fail(message);
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      process.removeListener('exit', showOnExit);
+      if (interactive) shown();
+    },
+  };
+}
+
+function download(url, redirects = 0, onProgress, client = https) {
   if (redirects > 5) return Promise.reject(new Error(`Too many redirects downloading ${url}.`));
   return new Promise((resolve, reject) => {
-    const request = https.get(url, { headers: { 'User-Agent': 'cmx-npm-installer' } }, (response) => {
+    const request = client.get(url, { headers: { 'User-Agent': 'cmx-npm-installer' } }, (response) => {
       if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
         response.resume();
-        resolve(download(new URL(response.headers.location, url), redirects + 1));
+        resolve(download(new URL(response.headers.location, url), redirects + 1, onProgress, client));
         return;
       }
       if (response.statusCode !== 200) {
@@ -33,8 +170,16 @@ function download(url, redirects = 0) {
         reject(new Error(`Download failed for ${url}: HTTP ${response.statusCode}.`));
         return;
       }
+      // A missing Content-Length is a valid unknown length: report real bytes
+      // and never fabricate a percentage for it.
+      const total = Number(response.headers['content-length']) || 0;
+      let received = 0;
       const chunks = [];
-      response.on('data', (chunk) => chunks.push(chunk));
+      response.on('data', (chunk) => {
+        received += chunk.length;
+        chunks.push(chunk);
+        if (onProgress) onProgress(received, total);
+      });
       response.on('end', () => resolve(Buffer.concat(chunks)));
     });
     request.setTimeout(60_000, () => request.destroy(new Error(`Timed out downloading ${url}.`)));
@@ -50,27 +195,69 @@ function checksumFor(sums) {
   return match[1].toLowerCase();
 }
 
-async function install() {
-  const [binary, sums] = await Promise.all([
-    download(`${releaseBase}/${asset}`),
-    download(`${releaseBase}/SHA256SUMS`),
-  ]);
-  const actual = crypto.createHash('sha256').update(binary).digest('hex');
-  if (actual !== checksumFor(sums)) throw new Error(`Checksum mismatch for ${asset}; CMX was not installed.`);
-
-  const platformDir = path.join(__dirname, '..', 'platform');
-  fs.mkdirSync(platformDir, { recursive: true });
-  const destination = path.join(platformDir, asset);
-  fs.writeFileSync(destination, binary, { mode: 0o755 });
-  if (os !== 'windows') fs.chmodSync(destination, 0o755);
-  console.log(`Installed CMX ${tag} for ${os}/${arch}.`);
+// writeExecutable stages the verified binary and renames it into place so an
+// interrupted install can never leave a partial executable behind.
+function writeExecutable(destination, contents) {
+  const pending = `${destination}.download-${process.pid}`;
+  try {
+    fs.writeFileSync(pending, contents, { mode: 0o755 });
+    if (os !== 'windows') fs.chmodSync(pending, 0o755);
+    try {
+      fs.renameSync(pending, destination);
+    } catch (error) {
+      if (!fs.existsSync(destination)) throw error;
+      fs.rmSync(destination, { force: true });
+      fs.renameSync(pending, destination);
+    }
+  } catch (error) {
+    fs.rmSync(pending, { force: true });
+    throw error;
+  }
+}
+
+async function install(options = {}) {
+  const stream = options.stream || process.stderr;
+  const display = createProgress(stream);
+  const onInterrupt = () => {
+    display.cancel('Cancelled; CMX was not installed.');
+    process.exit(130);
+  };
+  process.once('SIGINT', onInterrupt);
+  try {
+    let received = 0;
+    let total = 0;
+    display.begin(`Downloading ${asset} ${tag}`);
+    const [binary, sums] = await Promise.all([
+      download(`${releaseBase}/${asset}`, 0, (done, declared) => {
+        received = done;
+        total = declared;
+        display.update(done, declared);
+      }),
+      download(`${releaseBase}/SHA256SUMS`),
+    ]);
+    display.stage('Verifying SHA-256 checksum…');
+    const actual = crypto.createHash('sha256').update(binary).digest('hex');
+    if (actual !== checksumFor(sums)) throw new Error(`Checksum mismatch for ${asset}; CMX was not installed.`);
+
+    display.stage('Installing…');
+    const platformDir = path.join(__dirname, '..', 'platform');
+    fs.mkdirSync(platformDir, { recursive: true });
+    writeExecutable(path.join(platformDir, asset), binary);
+    const size = total > 0 ? total : received;
+    display.done(`CMX ${tag} installed for ${os}/${arch} (${formatBytes(size)}).`);
+  } catch (error) {
+    display.fail(`CMX installation failed: ${error.message}`);
+    throw error;
+  } finally {
+    process.removeListener('SIGINT', onInterrupt);
+    display.close();
+  }
 }
 
-module.exports = { install };
+module.exports = { install, download, renderBar, formatBytes, createProgress, checksumFor, writeExecutable };
 
 if (require.main === module) {
-  install().catch((error) => {
-    console.error(`CMX installation failed: ${error.message}`);
+  install().catch(() => {
     process.exitCode = 1;
   });
 }