@krema-build/krema 0.1.0-rc.10

package/bin/krema.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * Krema CLI shim.
+ * Resolves the best way to run Krema (native binary, JAR+Java, or JAR+auto-install JDK)
+ * and execs the resolved command with inherited stdio.
+ */
+
+const fs = require('node:fs');
+const { spawn } = require('node:child_process');
+const readline = require('node:readline');
+const { resolve, findJava } = require('../lib/resolve');
+const { read, write } = require('../lib/cache');
+const { installJdk } = require('../lib/jdk');
+const { JAVA_VERSION, VERSION } = require('../lib/constants');
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  // Try cached resolution first (validate that cached files still exist)
+  const cached = read();
+  if (cached && cached.version === VERSION) {
+    if (cached.mode === 'native' && cached.path && fs.existsSync(cached.path)) {
+      return exec(cached.path, args);
+    }
+    if (cached.mode === 'jar' && cached.java && cached.jar && fs.existsSync(cached.jar)) {
+      return exec(cached.java, ['--enable-native-access=ALL-UNNAMED', '-jar', cached.jar, ...args]);
+    }
+  }
+
+  // Full resolution
+  const resolved = await resolve();
+
+  if (resolved.mode === 'native') {
+    write({ mode: 'native', path: resolved.binary, version: VERSION });
+    return exec(resolved.binary, args);
+  }
+
+  // JAR mode — need Java
+  let javaPath = resolved.java;
+
+  if (!javaPath) {
+    // Interactive prompt for JDK install
+    if (process.stdin.isTTY) {
+      const answer = await prompt(
+        `Java ${JAVA_VERSION} is required but was not found.\n` +
+        `Install Eclipse Temurin ${JAVA_VERSION} to ~/.krema/jdk? [Y/n] `
+      );
+
+      if (answer === '' || answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+        try {
+          javaPath = await installJdk();
+        } catch (err) {
+          console.error(`\nFailed to install JDK: ${err.message}`);
+          process.exit(1);
+        }
+      } else {
+        printManualInstallInstructions();
+        process.exit(1);
+      }
+    } else {
+      // Non-interactive: try auto-install
+      try {
+        javaPath = await installJdk();
+      } catch (err) {
+        console.error(`Error: Java ${JAVA_VERSION} is required but was not found.`);
+        printManualInstallInstructions();
+        process.exit(1);
+      }
+    }
+  }
+
+  write({ mode: 'jar', java: javaPath, jar: resolved.jar, version: VERSION });
+  return exec(javaPath, ['--enable-native-access=ALL-UNNAMED', '-jar', resolved.jar, ...args]);
+}
+
+function exec(command, args) {
+  const child = spawn(command, args, { stdio: 'inherit' });
+  child.on('error', (err) => {
+    console.error(`Failed to start: ${err.message}`);
+    process.exit(1);
+  });
+  child.on('close', (code) => {
+    process.exit(code ?? 1);
+  });
+}
+
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function printManualInstallInstructions() {
+  console.error('');
+  console.error(`To use Krema, install Java ${JAVA_VERSION} and either:`);
+  console.error('  - Set KREMA_JAVA_HOME to point at the JDK');
+  console.error(`  - Ensure /usr/libexec/java_home -v ${JAVA_VERSION} works (macOS)`);
+  console.error('  - Or add java to your PATH');
+  console.error('');
+  console.error('Download from: https://adoptium.net/temurin/releases/');
+}
+
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/lib/cache.js

@@ -0,0 +1,18 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { CACHE_FILE, KREMA_HOME } = require('./constants');
+
+function read() {
+  try {
+    return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function write(data) {
+  fs.mkdirSync(KREMA_HOME, { recursive: true });
+  fs.writeFileSync(CACHE_FILE, JSON.stringify(data, null, 2) + '\n');
+}
+
+module.exports = { read, write };

package/lib/constants.js

@@ -0,0 +1,36 @@
+const path = require('node:path');
+const os = require('node:os');
+
+const VERSION = '0.1.0-rc.10';
+const JAVA_VERSION = '25';
+const GITHUB_REPO = 'krema-build/krema';
+const JAR_NAME = 'krema-cli.jar';
+
+const KREMA_HOME = path.join(os.homedir(), '.krema');
+const LIB_DIR = path.join(KREMA_HOME, 'lib');
+const JDK_DIR = path.join(KREMA_HOME, 'jdk');
+const CACHE_FILE = path.join(KREMA_HOME, 'cache.json');
+const TEMURIN_DIR = path.join(JDK_DIR, `temurin-${JAVA_VERSION}`);
+
+function jarUrl(version) {
+  return `https://github.com/${GITHUB_REPO}/releases/download/v${version}/${JAR_NAME}`;
+}
+
+function nativeBinaryUrl(version, platformKey) {
+  const name = platformKey === 'win32-x64' ? 'krema-windows-x64.exe' : `krema-${platformKey}`;
+  return `https://github.com/${GITHUB_REPO}/releases/download/v${version}/${name}`;
+}
+
+module.exports = {
+  VERSION,
+  JAVA_VERSION,
+  GITHUB_REPO,
+  JAR_NAME,
+  KREMA_HOME,
+  LIB_DIR,
+  JDK_DIR,
+  CACHE_FILE,
+  TEMURIN_DIR,
+  jarUrl,
+  nativeBinaryUrl,
+};

package/lib/download.js

@@ -0,0 +1,69 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const https = require('node:https');
+const http = require('node:http');
+
+function follow(url) {
+  return url.startsWith('https://') ? https : http;
+}
+
+function download(url, dest, { onProgress, quiet } = {}) {
+  return new Promise((resolve, reject) => {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    const file = fs.createWriteStream(dest);
+
+    const get = (currentUrl) => {
+      follow(currentUrl).get(currentUrl, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          res.resume();
+          get(res.headers.location);
+          return;
+        }
+
+        if (res.statusCode !== 200) {
+          file.close();
+          fs.unlinkSync(dest);
+          reject(new Error(`Download failed: HTTP ${res.statusCode} for ${currentUrl}`));
+          return;
+        }
+
+        const total = parseInt(res.headers['content-length'], 10) || 0;
+        let downloaded = 0;
+
+        res.on('data', (chunk) => {
+          downloaded += chunk.length;
+          if (onProgress && total > 0) {
+            onProgress(downloaded, total);
+          } else if (!quiet && total > 0 && process.stderr.isTTY) {
+            const pct = Math.round((downloaded / total) * 100);
+            const mb = (downloaded / 1048576).toFixed(1);
+            const totalMb = (total / 1048576).toFixed(1);
+            process.stderr.write(`\r  Downloading... ${mb}/${totalMb} MB (${pct}%)`);
+          }
+        });
+
+        res.pipe(file);
+
+        file.on('finish', () => {
+          if (!quiet && total > 0 && process.stderr.isTTY) {
+            process.stderr.write('\n');
+          }
+          file.close(resolve);
+        });
+
+        file.on('error', (err) => {
+          fs.unlinkSync(dest);
+          reject(err);
+        });
+      }).on('error', (err) => {
+        file.close();
+        try { fs.unlinkSync(dest); } catch {}
+        reject(err);
+      });
+    };
+
+    get(url);
+  });
+}
+
+module.exports = { download };

package/lib/jdk.js

@@ -0,0 +1,73 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { getPlatform } = require('./platform');
+const { JAVA_VERSION, JDK_DIR, TEMURIN_DIR } = require('./constants');
+const { download } = require('./download');
+
+function adoptiumUrl() {
+  const platform = getPlatform();
+  if (!platform) {
+    return null;
+  }
+  return `https://api.adoptium.net/v3/binary/latest/${JAVA_VERSION}/ga/${platform.adoptiumOs}/${platform.adoptiumArch}/jdk/hotspot/normal/eclipse`;
+}
+
+function temurinJavaPath() {
+  // After extraction, Temurin tarballs contain a top-level directory like
+  // jdk-25+36 (or jdk-25.0.1+9 etc). We find it dynamically.
+  if (!fs.existsSync(TEMURIN_DIR)) {
+    return null;
+  }
+  const entries = fs.readdirSync(TEMURIN_DIR);
+  for (const entry of entries) {
+    const candidate = process.platform === 'darwin'
+      ? path.join(TEMURIN_DIR, entry, 'Contents', 'Home', 'bin', 'java')
+      : path.join(TEMURIN_DIR, entry, 'bin', 'java');
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+async function installJdk() {
+  const url = adoptiumUrl();
+  if (!url) {
+    throw new Error(`No Adoptium JDK available for ${process.platform}-${process.arch}`);
+  }
+
+  const ext = process.platform === 'win32' ? '.zip' : '.tar.gz';
+  const tmpFile = path.join(JDK_DIR, `temurin-${JAVA_VERSION}${ext}`);
+
+  console.error(`  Downloading Eclipse Temurin ${JAVA_VERSION}...`);
+  await download(url, tmpFile);
+
+  console.error('  Extracting...');
+  fs.mkdirSync(TEMURIN_DIR, { recursive: true });
+
+  if (ext === '.tar.gz') {
+    execFileSync('tar', ['xzf', tmpFile, '-C', TEMURIN_DIR], { stdio: 'pipe' });
+  } else {
+    // Windows: use PowerShell to extract zip
+    execFileSync('powershell', [
+      '-NoProfile', '-Command',
+      `Expand-Archive -Path '${tmpFile}' -DestinationPath '${TEMURIN_DIR}' -Force`
+    ], { stdio: 'pipe' });
+  }
+
+  fs.unlinkSync(tmpFile);
+
+  const javaPath = temurinJavaPath();
+  if (!javaPath) {
+    throw new Error('JDK extraction succeeded but java binary not found');
+  }
+
+  // Verify
+  const out = execFileSync(javaPath, ['-version'], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+  // java -version writes to stderr
+  console.error(`  Installed: ${javaPath}`);
+  return javaPath;
+}
+
+module.exports = { adoptiumUrl, temurinJavaPath, installJdk };

package/lib/platform.js

@@ -0,0 +1,25 @@
+const os = require('node:os');
+const process = require('node:process');
+
+const PLATFORMS = {
+  'darwin-arm64': { npmPkg: '@krema-build/cli-darwin-arm64', adoptiumOs: 'mac', adoptiumArch: 'aarch64' },
+  'darwin-x64': { npmPkg: '@krema-build/cli-darwin-x64', adoptiumOs: 'mac', adoptiumArch: 'x64' },
+  'linux-x64': { npmPkg: '@krema-build/cli-linux-x64', adoptiumOs: 'linux', adoptiumArch: 'x64' },
+  'linux-arm64': { npmPkg: '@krema-build/cli-linux-arm64', adoptiumOs: 'linux', adoptiumArch: 'aarch64' },
+  'win32-x64': { npmPkg: '@krema-build/cli-win32-x64', adoptiumOs: 'windows', adoptiumArch: 'x64' },
+};
+
+function getPlatformKey() {
+  return `${process.platform}-${os.arch()}`;
+}
+
+function getPlatform() {
+  const key = getPlatformKey();
+  const platform = PLATFORMS[key];
+  if (!platform) {
+    return null;
+  }
+  return { key, ...platform };
+}
+
+module.exports = { PLATFORMS, getPlatformKey, getPlatform };

package/lib/resolve.js

@@ -0,0 +1,143 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { getPlatform } = require('./platform');
+const { JAVA_VERSION, LIB_DIR, JAR_NAME, VERSION } = require('./constants');
+const { jarUrl } = require('./constants');
+const { download } = require('./download');
+const { temurinJavaPath } = require('./jdk');
+
+/**
+ * Try to find the native binary from the platform-specific npm optional dependency.
+ * Returns the path to the binary, or null.
+ */
+function findNativeBinary() {
+  const platform = getPlatform();
+  if (!platform) return null;
+
+  try {
+    const pkgDir = path.dirname(require.resolve(`${platform.npmPkg}/package.json`));
+    const bin = path.join(pkgDir, 'bin', process.platform === 'win32' ? 'krema.exe' : 'krema');
+    if (fs.existsSync(bin)) {
+      return bin;
+    }
+  } catch {
+    // Package not installed (wrong platform or optional dep skipped)
+  }
+  return null;
+}
+
+/**
+ * Find the fat JAR. Downloads it if not present.
+ * Returns the path to the JAR.
+ */
+async function findOrDownloadJar() {
+  const jarPath = path.join(LIB_DIR, JAR_NAME);
+  if (fs.existsSync(jarPath)) {
+    return jarPath;
+  }
+
+  console.error(`  Downloading ${JAR_NAME}...`);
+  await download(jarUrl(VERSION), jarPath);
+  return jarPath;
+}
+
+/**
+ * Find a Java 25 installation.
+ * Search order:
+ *   1. KREMA_JAVA_HOME env
+ *   2. macOS: /usr/libexec/java_home -v 25
+ *   3. JAVA_HOME (if version matches)
+ *   4. java on PATH (if version matches)
+ *   5. ~/.krema/jdk/temurin-25/
+ * Returns the path to the java binary, or null.
+ */
+function findJava() {
+  // 1. KREMA_JAVA_HOME override
+  if (process.env.KREMA_JAVA_HOME) {
+    const java = path.join(process.env.KREMA_JAVA_HOME, 'bin', 'java');
+    if (fs.existsSync(java)) return java;
+  }
+
+  // 2. macOS: /usr/libexec/java_home
+  if (process.platform === 'darwin') {
+    try {
+      const jh = execFileSync('/usr/libexec/java_home', ['-v', JAVA_VERSION], {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+      const java = path.join(jh, 'bin', 'java');
+      if (jh && fs.existsSync(java)) return java;
+    } catch {
+      // Not found
+    }
+  }
+
+  // 3. JAVA_HOME if version matches
+  if (process.env.JAVA_HOME) {
+    const java = path.join(process.env.JAVA_HOME, 'bin', 'java');
+    if (fs.existsSync(java) && checkJavaVersion(java)) return java;
+  }
+
+  // 4. java on PATH
+  try {
+    const javaOnPath = execFileSync(process.platform === 'win32' ? 'where' : 'which', ['java'], {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim().split('\n')[0];
+    if (javaOnPath && checkJavaVersion(javaOnPath)) return javaOnPath;
+  } catch {
+    // Not found
+  }
+
+  // 5. ~/.krema/jdk/temurin-25/
+  const temurin = temurinJavaPath();
+  if (temurin) return temurin;
+
+  return null;
+}
+
+function checkJavaVersion(javaPath) {
+  try {
+    const output = execFileSync(javaPath, ['-version'], {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    // java -version outputs to stderr, but execFileSync with stdio pipe captures it
+    // Some JDKs output to stdout, some to stderr. Check both.
+    const combined = output || '';
+    return parseJavaVersion(combined) === JAVA_VERSION;
+  } catch (err) {
+    // java -version writes to stderr which becomes err.stderr
+    if (err.stderr) {
+      return parseJavaVersion(err.stderr) === JAVA_VERSION;
+    }
+    return false;
+  }
+}
+
+function parseJavaVersion(text) {
+  const match = text.match(/"(\d+)/);
+  return match ? match[1] : null;
+}
+
+/**
+ * Resolve the execution mode. Returns { mode, args } where:
+ *   - mode "native": args = [binaryPath, ...userArgs]
+ *   - mode "jar":    args = [javaPath, "-jar", jarPath, ...userArgs]
+ */
+async function resolve() {
+  // Tier 1: Native binary
+  const nativeBin = findNativeBinary();
+  if (nativeBin) {
+    return { mode: 'native', binary: nativeBin, java: null, jar: null };
+  }
+
+  // Tier 2 & 3: JAR + Java
+  const jarPath = await findOrDownloadJar();
+  const javaPath = findJava();
+
+  return { mode: 'jar', binary: null, java: javaPath, jar: jarPath };
+}
+
+module.exports = { findNativeBinary, findOrDownloadJar, findJava, resolve };

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@krema-build/krema",
+  "version": "0.1.0-rc.10",
+  "description": "Lightweight desktop apps with system webviews — CLI tool",
+  "bin": {
+    "krema": "bin/krema.js"
+  },
+  "scripts": {
+    "postinstall": "node postinstall.js"
+  },
+  "optionalDependencies": {
+    "@krema-build/cli-darwin-arm64": "0.1.0-rc.10",
+    "@krema-build/cli-linux-x64": "0.1.0-rc.10",
+    "@krema-build/cli-linux-arm64": "0.1.0-rc.10",
+    "@krema-build/cli-win32-x64": "0.1.0-rc.10"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "postinstall.js"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "krema",
+    "desktop",
+    "webview",
+    "gui",
+    "native",
+    "cli"
+  ],
+  "license": "BSL-1.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/krema-build/krema.git",
+    "directory": "krema-npm/packages/krema"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/postinstall.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+/**
+ * Postinstall script for the krema npm package.
+ * Non-interactive: detects the best execution mode and caches the result.
+ * Always exits 0 to never break npm install.
+ */
+
+const { findNativeBinary, findJava } = require('./lib/resolve');
+const { download } = require('./lib/download');
+const { read, write } = require('./lib/cache');
+const { VERSION, LIB_DIR, JAR_NAME, jarUrl } = require('./lib/constants');
+const path = require('node:path');
+const fs = require('node:fs');
+
+async function main() {
+  // 1. Check for native binary
+  const nativeBin = findNativeBinary();
+  if (nativeBin) {
+    write({ mode: 'native', path: nativeBin, version: VERSION });
+    return;
+  }
+
+  // 2. No native binary — download JAR
+  const jarPath = path.join(LIB_DIR, JAR_NAME);
+  if (!fs.existsSync(jarPath)) {
+    try {
+      await download(jarUrl(VERSION), jarPath, { quiet: true });
+    } catch {
+      // Non-fatal: bin/krema.js will retry at runtime
+    }
+  }
+
+  // Only cache if the JAR was actually downloaded
+  if (!fs.existsSync(jarPath)) {
+    return;
+  }
+
+  // 3. Check for Java 25
+  const javaPath = findJava();
+  if (javaPath) {
+    write({ mode: 'jar', java: javaPath, jar: jarPath, version: VERSION });
+  } else {
+    write({ mode: 'jar-no-java', jar: jarPath, version: VERSION });
+  }
+}
+
+main().catch(() => {
+  // Never break npm install
+  process.exit(0);
+});