eval-kanban 0.1.0

package/bin/cli.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+
+const { execSync, spawn } = require('child_process');
+const AdmZip = require('adm-zip');
+const path = require('path');
+const fs = require('fs');
+const { ensureBinary, getLatestRelease, CACHE_DIR } = require('./download');
+
+const CLI_VERSION = require('../package.json').version;
+
+function getEffectiveArch() {
+  const platform = process.platform;
+  const nodeArch = process.arch;
+
+  if (platform === 'darwin') {
+    if (nodeArch === 'arm64') return 'arm64';
+    try {
+      const translated = execSync('sysctl -in sysctl.proc_translated', {
+        encoding: 'utf8',
+      }).trim();
+      if (translated === '1') return 'arm64';
+    } catch {}
+    return 'x64';
+  }
+
+  if (/arm/i.test(nodeArch)) return 'arm64';
+
+  if (platform === 'win32') {
+    const pa = process.env.PROCESSOR_ARCHITECTURE || '';
+    const paw = process.env.PROCESSOR_ARCHITEW6432 || '';
+    if (/arm/i.test(pa) || /arm/i.test(paw)) return 'arm64';
+  }
+
+  return 'x64';
+}
+
+function getPlatformDir() {
+  const platform = process.platform;
+  const arch = getEffectiveArch();
+
+  if (platform === 'linux' && arch === 'x64') return 'linux-x64';
+  if (platform === 'win32' && arch === 'x64') return 'windows-x64';
+  if (platform === 'darwin' && arch === 'arm64') return 'macos-arm64';
+
+  if (platform === 'darwin' && arch === 'x64') {
+    console.error('Intel Macs are not supported.');
+    console.error('eval-kanban requires Apple Silicon (M1 or later).');
+    process.exit(1);
+  }
+
+  if (platform === 'linux' && arch === 'arm64') {
+    console.error('Linux ARM64 is not supported yet.');
+    console.error('Please use Linux x64 or open an issue for ARM64 support.');
+    process.exit(1);
+  }
+
+  console.error(`Unsupported platform: ${platform}-${arch}`);
+  console.error('Supported platforms:');
+  console.error('  - Linux x64');
+  console.error('  - Windows x64');
+  console.error('  - macOS ARM64 (Apple Silicon M1+)');
+  process.exit(1);
+}
+
+function getBinaryName() {
+  return process.platform === 'win32' ? 'eval-kanban-server.exe' : 'eval-kanban-server';
+}
+
+function showProgress(downloaded, total) {
+  const percent = total ? Math.round((downloaded / total) * 100) : 0;
+  const mb = (downloaded / (1024 * 1024)).toFixed(1);
+  const totalMb = total ? (total / (1024 * 1024)).toFixed(1) : '?';
+  process.stderr.write(`\r   Downloading: ${mb}MB / ${totalMb}MB (${percent}%)`);
+}
+
+async function main() {
+  const platformDir = getPlatformDir();
+  const cwd = process.cwd();
+
+  console.log(`eval-kanban v${CLI_VERSION}`);
+
+  // Get latest release info
+  let release;
+  try {
+    release = await getLatestRelease();
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    console.error('Make sure you have internet connection and the release exists.');
+    process.exit(1);
+  }
+
+  const version = release.tag_name;
+  const versionDir = path.join(CACHE_DIR, version, platformDir);
+  const binPath = path.join(versionDir, getBinaryName());
+  const extractedMarker = path.join(versionDir, '.extracted');
+
+  // Download and extract if needed
+  if (!fs.existsSync(extractedMarker)) {
+    try {
+      const { zipPath } = await ensureBinary(platformDir, version, showProgress);
+
+      console.log('Extracting...');
+      const zip = new AdmZip(zipPath);
+      zip.extractAllTo(versionDir, true);
+
+      // Mark as extracted
+      fs.writeFileSync(extractedMarker, new Date().toISOString());
+
+      // Set permissions on Unix
+      if (process.platform !== 'win32') {
+        try {
+          fs.chmodSync(binPath, 0o755);
+        } catch {}
+      }
+
+      // Clean up zip
+      try {
+        fs.unlinkSync(zipPath);
+      } catch {}
+    } catch (err) {
+      console.error(`\nError: ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  if (!fs.existsSync(binPath)) {
+    console.error(`Error: Binary not found at ${binPath}`);
+    console.error('Try deleting ~/.eval-kanban/bin and running again.');
+    process.exit(1);
+  }
+
+  console.log('Starting server...');
+
+  const server = spawn(binPath, [], {
+    cwd: cwd,
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      RUST_LOG: process.env.RUST_LOG || 'eval_kanban_server=info',
+    },
+  });
+
+  server.on('error', (err) => {
+    console.error('Server error:', err.message);
+    process.exit(1);
+  });
+
+  server.on('exit', (code) => {
+    process.exit(code || 0);
+  });
+
+  process.on('SIGINT', () => {
+    server.kill('SIGINT');
+  });
+
+  process.on('SIGTERM', () => {
+    server.kill('SIGTERM');
+  });
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err.message);
+  process.exit(1);
+});

package/bin/download.js

@@ -0,0 +1,132 @@
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const GITHUB_REPO = 'reverendjah/eval-kanban';
+const CACHE_DIR = path.join(require('os').homedir(), '.eval-kanban', 'bin');
+
+async function fetchJson(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, { headers: { 'User-Agent': 'eval-kanban-cli' } }, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        return fetchJson(res.headers.location).then(resolve).catch(reject);
+      }
+      if (res.statusCode !== 200) {
+        return reject(new Error(`HTTP ${res.statusCode} fetching ${url}`));
+      }
+      let data = '';
+      res.on('data', (chunk) => (data += chunk));
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          reject(new Error(`Failed to parse JSON from ${url}`));
+        }
+      });
+    }).on('error', reject);
+  });
+}
+
+async function downloadFile(url, destPath, onProgress) {
+  const tempPath = destPath + '.tmp';
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(tempPath);
+
+    const cleanup = () => {
+      try {
+        fs.unlinkSync(tempPath);
+      } catch {}
+    };
+
+    const doRequest = (requestUrl) => {
+      https.get(requestUrl, { headers: { 'User-Agent': 'eval-kanban-cli' } }, (res) => {
+        if (res.statusCode === 301 || res.statusCode === 302) {
+          file.close();
+          cleanup();
+          return doRequest(res.headers.location);
+        }
+
+        if (res.statusCode !== 200) {
+          file.close();
+          cleanup();
+          return reject(new Error(`HTTP ${res.statusCode} downloading ${requestUrl}`));
+        }
+
+        const totalSize = parseInt(res.headers['content-length'], 10);
+        let downloadedSize = 0;
+
+        res.on('data', (chunk) => {
+          downloadedSize += chunk.length;
+          if (onProgress) onProgress(downloadedSize, totalSize);
+        });
+        res.pipe(file);
+
+        file.on('finish', () => {
+          file.close();
+          try {
+            fs.renameSync(tempPath, destPath);
+            resolve(destPath);
+          } catch (err) {
+            cleanup();
+            reject(err);
+          }
+        });
+      }).on('error', (err) => {
+        file.close();
+        cleanup();
+        reject(err);
+      });
+    };
+
+    doRequest(url);
+  });
+}
+
+async function getLatestRelease() {
+  const url = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
+  try {
+    const release = await fetchJson(url);
+    return release;
+  } catch (err) {
+    throw new Error(`Failed to fetch latest release: ${err.message}`);
+  }
+}
+
+async function ensureBinary(platform, version, onProgress) {
+  const versionDir = path.join(CACHE_DIR, version, platform);
+  const zipPath = path.join(versionDir, 'eval-kanban.zip');
+  const extractedMarker = path.join(versionDir, '.extracted');
+
+  // Already downloaded and extracted
+  if (fs.existsSync(extractedMarker)) {
+    return versionDir;
+  }
+
+  fs.mkdirSync(versionDir, { recursive: true });
+
+  // Download if not cached
+  if (!fs.existsSync(zipPath)) {
+    const release = await getLatestRelease();
+    const asset = release.assets.find((a) => a.name === `eval-kanban-${platform}.zip`);
+
+    if (!asset) {
+      throw new Error(`No binary available for platform: ${platform}`);
+    }
+
+    console.error(`Downloading eval-kanban ${version} for ${platform}...`);
+    await downloadFile(asset.browser_download_url, zipPath, onProgress);
+    console.error(''); // newline after progress
+  }
+
+  return { zipPath, versionDir };
+}
+
+module.exports = {
+  GITHUB_REPO,
+  CACHE_DIR,
+  fetchJson,
+  downloadFile,
+  getLatestRelease,
+  ensureBinary,
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "eval-kanban",
+  "version": "0.1.0",
+  "description": "Kanban board for orchestrating tasks with Claude Code",
+  "bin": {
+    "eval-kanban": "./bin/cli.js"
+  },
+  "scripts": {
+    "start": "node bin/cli.js"
+  },
+  "keywords": [
+    "claude",
+    "kanban",
+    "ai",
+    "cli",
+    "automation"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin"
+  ],
+  "dependencies": {
+    "adm-zip": "^0.5.16"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/reverendjah/eval-kanban.git"
+  }
+}