@zxr55555/leetmate 0.2.8

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LeetMate contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO CLAIM SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @zxr55555/leetmate
+
+Install the LeetMate terminal CLI through npm.
+
+```bash
+npm install -g @zxr55555/leetmate
+```
+
+This package downloads the matching prebuilt binary from the [LeetMate GitHub Releases](https://github.com/DuckInAShirt/leetmate/releases), verifies it against `checksums.txt`, and exposes it as `leetmate`.
+
+LeetMate also requires the external [`leetgo`](https://github.com/j178/leetgo) CLI in your `PATH` and a configured leetgo workspace.

package/bin/leetmate.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const exe = process.platform === 'win32' ? 'leetmate.exe' : 'leetmate';
+const binary = path.join(__dirname, exe);
+
+if (!fs.existsSync(binary)) {
+  console.error('leetmate binary is missing. Reinstall the package or run `npm rebuild leetmate`.');
+  process.exit(1);
+}
+
+const result = spawnSync(binary, process.argv.slice(2), { stdio: 'inherit' });
+if (result.error) {
+  console.error(result.error.message);
+  process.exit(1);
+}
+process.exit(result.status === null ? 1 : result.status);

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@zxr55555/leetmate",
+  "version": "0.2.8",
+  "description": "Hints, not handouts: a terminal LeetCode coach and spaced review tool.",
+  "license": "MIT",
+  "homepage": "https://github.com/DuckInAShirt/leetmate#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DuckInAShirt/leetmate.git"
+  },
+  "bugs": {
+    "url": "https://github.com/DuckInAShirt/leetmate/issues"
+  },
+  "bin": {
+    "leetmate": "bin/leetmate.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js",
+    "test": "node --test scripts/*.test.js",
+    "test:install": "LEETMATE_SKIP_DOWNLOAD=1 node scripts/install.js && node bin/leetmate.js --version"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "leetcode",
+    "tui",
+    "cli",
+    "algorithms",
+    "spaced-repetition"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/install.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const https = require('https');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const root = path.resolve(__dirname, '..');
+const binDir = path.join(root, 'bin');
+const packageJSON = require(path.join(root, 'package.json'));
+const owner = 'DuckInAShirt';
+const repo = 'leetmate';
+
+function platformTarget(platform = os.platform(), arch = os.arch()) {
+  const osName = platform === 'darwin' ? 'macOS' : platform === 'win32' ? 'Windows' : platform === 'linux' ? 'linux' : '';
+  const archName = arch === 'x64' ? 'amd64' : arch === 'arm64' ? 'arm64' : '';
+  if (!osName || !archName) {
+    throw new Error(`Unsupported platform: ${platform}/${arch}`);
+  }
+  return {
+    osName,
+    archName,
+    ext: platform === 'win32' ? '.zip' : '.tar.gz',
+    exe: platform === 'win32' ? 'leetmate.exe' : 'leetmate',
+  };
+}
+
+function releaseVersion(env = process.env, pkg = packageJSON) {
+  if (env.LEETMATE_VERSION) {
+    return env.LEETMATE_VERSION.replace(/^v/, '');
+  }
+  return pkg.version.replace(/^v/, '');
+}
+
+function assetName(version, target) {
+  return `leetmate_${version}_${target.osName}_${target.archName}${target.ext}`;
+}
+
+function releaseURL(version, name) {
+  return `https://github.com/${owner}/${repo}/releases/download/v${version}/${name}`;
+}
+
+function binaryPath(target) {
+  return path.join(binDir, target.exe);
+}
+
+function parseChecksums(text) {
+  const out = new Map();
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const match = trimmed.match(/^([a-fA-F0-9]{64})\s+(.+)$/);
+    if (match) {
+      out.set(match[2].replace(/^\*?/, ''), match[1].toLowerCase());
+    }
+  }
+  return out;
+}
+
+function sha256(file) {
+  const hash = crypto.createHash('sha256');
+  hash.update(fs.readFileSync(file));
+  return hash.digest('hex');
+}
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    const request = https.get(url, { headers: { 'User-Agent': 'leetmate-npm-installer' } }, (response) => {
+      if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        file.close(() => fs.rmSync(dest, { force: true }));
+        download(response.headers.location, dest).then(resolve, reject);
+        return;
+      }
+      if (response.statusCode !== 200) {
+        file.close(() => fs.rmSync(dest, { force: true }));
+        reject(new Error(`Download failed: HTTP ${response.statusCode} ${url}`));
+        return;
+      }
+      response.pipe(file);
+      file.on('finish', () => file.close(resolve));
+    });
+    request.on('error', (err) => {
+      file.close(() => fs.rmSync(dest, { force: true }));
+      reject(err);
+    });
+  });
+}
+
+function extract(archive, target) {
+  fs.mkdirSync(binDir, { recursive: true });
+  const binary = binaryPath(target);
+  fs.rmSync(binary, { force: true });
+  if (archive.endsWith('.zip')) {
+    const tmpDir = `${archive}-extract`;
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    fs.mkdirSync(tmpDir, { recursive: true });
+    execFileSync('powershell', ['-NoProfile', '-Command', `Expand-Archive -LiteralPath ${JSON.stringify(archive)} -DestinationPath ${JSON.stringify(tmpDir)} -Force`], { stdio: 'inherit' });
+    fs.copyFileSync(path.join(tmpDir, target.exe), binary);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  } else {
+    execFileSync('tar', ['-xzf', archive, '-C', binDir, target.exe], { stdio: 'inherit' });
+  }
+  if (process.platform !== 'win32') {
+    fs.chmodSync(binary, 0o755);
+  }
+}
+
+async function install() {
+  const target = platformTarget();
+  const skipDownload = process.argv.includes('--skip-download') || process.env.LEETMATE_SKIP_DOWNLOAD === '1';
+  if (skipDownload) {
+    fs.mkdirSync(binDir, { recursive: true });
+    const binary = binaryPath(target);
+    if (!fs.existsSync(binary)) {
+      fs.writeFileSync(binary, '#!/bin/sh\necho leetmate development\n', { mode: 0o755 });
+    }
+    return;
+  }
+
+  const version = releaseVersion();
+  if (!version || version === '0.0.0-dev') {
+    throw new Error('Cannot install development npm package without LEETMATE_VERSION. Use a published release package.');
+  }
+
+  const name = assetName(version, target);
+  const tmp = path.join(os.tmpdir(), `${name}-${process.pid}`);
+  const sums = path.join(os.tmpdir(), `leetmate-checksums-${version}-${process.pid}.txt`);
+  await download(releaseURL(version, name), tmp);
+  await download(releaseURL(version, 'checksums.txt'), sums);
+  const checksums = parseChecksums(fs.readFileSync(sums, 'utf8'));
+  const expected = checksums.get(name);
+  if (!expected) {
+    throw new Error(`No checksum found for ${name}`);
+  }
+  const actual = sha256(tmp);
+  if (actual !== expected) {
+    throw new Error(`Checksum mismatch for ${name}: expected ${expected}, got ${actual}`);
+  }
+  extract(tmp, target);
+  fs.rmSync(tmp, { force: true });
+  fs.rmSync(sums, { force: true });
+}
+
+if (require.main === module) {
+  install().catch((err) => {
+    console.error(`leetmate install failed: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+module.exports = { assetName, binaryPath, parseChecksums, platformTarget, releaseURL, releaseVersion };

package/scripts/install.test.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const path = require('node:path');
+const {
+  assetName,
+  binaryPath,
+  parseChecksums,
+  platformTarget,
+  releaseURL,
+  releaseVersion,
+} = require('./install');
+
+test('platformTarget maps supported platforms to GoReleaser names', () => {
+  assert.deepEqual(platformTarget('darwin', 'arm64'), { osName: 'macOS', archName: 'arm64', ext: '.tar.gz', exe: 'leetmate' });
+  assert.deepEqual(platformTarget('linux', 'x64'), { osName: 'linux', archName: 'amd64', ext: '.tar.gz', exe: 'leetmate' });
+  assert.deepEqual(platformTarget('win32', 'x64'), { osName: 'Windows', archName: 'amd64', ext: '.zip', exe: 'leetmate.exe' });
+});
+
+test('platformTarget rejects unsupported combinations', () => {
+  assert.throws(() => platformTarget('freebsd', 'x64'), /Unsupported platform/);
+  assert.throws(() => platformTarget('linux', 'arm'), /Unsupported platform/);
+});
+
+test('assetName and releaseURL match GoReleaser assets', () => {
+  const target = platformTarget('darwin', 'arm64');
+  const name = assetName('0.2.7', target);
+  assert.equal(name, 'leetmate_0.2.7_macOS_arm64.tar.gz');
+  assert.equal(releaseURL('0.2.7', name), 'https://github.com/DuckInAShirt/leetmate/releases/download/v0.2.7/leetmate_0.2.7_macOS_arm64.tar.gz');
+});
+
+test('parseChecksums extracts sha256 entries', () => {
+  const sum = 'a'.repeat(64);
+  const parsed = parseChecksums(`${sum}  leetmate_0.2.7_linux_amd64.tar.gz\n`);
+  assert.equal(parsed.get('leetmate_0.2.7_linux_amd64.tar.gz'), sum);
+});
+
+test('releaseVersion prefers LEETMATE_VERSION', () => {
+  assert.equal(releaseVersion({ LEETMATE_VERSION: 'v1.2.3' }, { version: '0.0.0-dev' }), '1.2.3');
+  assert.equal(releaseVersion({}, { version: '1.2.4' }), '1.2.4');
+});
+
+test('binaryPath points inside npm bin directory', () => {
+  assert.equal(path.basename(binaryPath(platformTarget('win32', 'x64'))), 'leetmate.exe');
+  assert.equal(path.basename(binaryPath(platformTarget('linux', 'x64'))), 'leetmate');
+});