@atom-js-org/cli 0.3.0-alpha.0 → 0.4.1-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atom-js-org/cli",
-  "version": "0.3.0-alpha.0",
+  "version": "0.4.1-alpha.0",
   "description": "CLI for running and building AtomJS desktop applications.",
   "bin": {
     "atom": "bin/atom.cjs"

package/src/build.cjs

@@ -39,8 +39,8 @@ async function localBuild(project, target, options = {}) {
   }
 
   const buildRoot = path.join(project.root, 'build', target);
-  const unpacked = path.join(buildRoot, 'unpacked');
-  const appDir = path.join(unpacked, 'app');
+  const unpacked = path.join(buildRoot, 'portable');
+  const appDir = null;
   const productName = sanitizeFilename(project.config.productName);
 
   console.log(`\nAtomJS build (${target})`);
@@ -50,7 +50,8 @@ async function localBuild(project, target, options = {}) {
   await fse.remove(buildRoot);
   await fse.ensureDir(unpacked);
 
-  const stageRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'atomjs-stage-'));
+  const stageBase = await resolveShortStageBase();
+  const stageRoot = await fs.promises.mkdtemp(path.join(stageBase, 's-'));
   const stagedApp = path.join(stageRoot, 'app');
   const payloadPath = path.join(stageRoot, 'atom-app.payload.gz');
 
@@ -59,21 +60,8 @@ async function localBuild(project, target, options = {}) {
     await vendorFramework(stagedApp, project, target);
     await installProductionDependencies(stagedApp, options.skipInstall, target);
 
-    if (target === 'macos') {
-      console.log('Embedding application code and production dependencies into the native executable...');
-      await createApplicationPayload(stagedApp, payloadPath);
-    } else {
-      await fse.move(stagedApp, appDir, { overwrite: true });
-    }
-
-    if (target !== 'macos') {
-      const runtimeDir = path.join(unpacked, 'runtime');
-      await fse.ensureDir(runtimeDir);
-      const runtimeNodeName = target === 'windows' ? 'node.exe' : 'node';
-      const runtimeNodePath = path.join(runtimeDir, runtimeNodeName);
-      await fs.promises.copyFile(process.execPath, runtimeNodePath);
-      if (target !== 'windows') await fs.promises.chmod(runtimeNodePath, 0o755);
-    }
+    console.log('Embedding application code and production dependencies into the executable...');
+    await createApplicationPayload(stagedApp, payloadPath);
 
     const executableName = target === 'windows' ? `${productName}.exe` : productName;
     const executablePath = path.join(unpacked, executableName);
@@ -82,7 +70,7 @@ async function localBuild(project, target, options = {}) {
       appDir,
       target,
       productName,
-      payloadPath: target === 'macos' ? payloadPath : null
+      payloadPath
     });
 
     const creditPath = path.join(unpacked, 'ATOMJS-CREDIT.txt');
@@ -138,6 +126,28 @@ async function localBuild(project, target, options = {}) {
   }
 }
 
+
+async function resolveShortStageBase() {
+  const configured = process.env.ATOMJS_TEMP_DIR || process.env.ATOM_TEMP_DIR;
+  const candidates = configured
+    ? [path.resolve(configured)]
+    : process.platform === 'win32'
+      ? [path.join(path.parse(process.cwd()).root, '.atomjs-tmp'), path.join(os.tmpdir(), 'atomjs')]
+      : [path.join(os.tmpdir(), 'atomjs')];
+
+  let lastError;
+  for (const candidate of candidates) {
+    try {
+      await fse.ensureDir(candidate);
+      await fs.promises.access(candidate, fs.constants.W_OK);
+      return candidate;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw new Error(`AtomJS could not create a writable short staging directory: ${lastError ? lastError.message : 'unknown error'}`);
+}
+
 async function copyApplication(projectRoot, appDir) {
   await fse.copy(projectRoot, appDir, {
     dereference: false,
@@ -284,9 +294,8 @@ async function createSeaLauncher({ executablePath, appDir, target, productName,
   const blobPath = path.join(work, target === 'windows' ? 'sea-prep.blob.exe' : 'sea-prep.blob');
   const configPath = path.join(work, 'sea-config.json');
 
-  const launcher = payloadPath
-    ? createEmbeddedLauncherSource(productName)
-    : createLooseLauncherSource();
+  if (!payloadPath) throw new Error('AtomJS SEA payload is required.');
+  const launcher = createEmbeddedLauncherSource(productName);
   await fs.promises.writeFile(launcherPath, launcher, 'utf8');
 
   const seaConfig = {
@@ -295,13 +304,16 @@ async function createSeaLauncher({ executablePath, appDir, target, productName,
     disableExperimentalSEAWarning: true,
     useSnapshot: false,
     useCodeCache: false,
-    ...(payloadPath ? { assets: { 'atom-app': payloadPath } } : {})
+    assets: { 'atom-app': payloadPath }
   };
   await fs.promises.writeFile(configPath, JSON.stringify(seaConfig, null, 2));
 
   await run(process.execPath, ['--experimental-sea-config', configPath], { cwd: work });
   await fs.promises.copyFile(process.execPath, executablePath);
 
+  if (target === 'windows') {
+    await prepareWindowsExecutableForInjection(executablePath);
+  }
   if (target === 'macos' && commandExists('codesign', ['--version'])) {
     spawnSync('codesign', ['--remove-signature', executablePath], { stdio: 'ignore' });
   }
@@ -311,38 +323,64 @@ async function createSeaLauncher({ executablePath, appDir, target, productName,
     machoSegmentName: 'NODE_SEA'
   });
 
-  if (target !== 'windows') await fs.promises.chmod(executablePath, 0o755);
+  if (target === 'windows') {
+    await setWindowsGuiSubsystem(executablePath);
+  } else {
+    await fs.promises.chmod(executablePath, 0o755);
+  }
   if (target === 'macos' && commandExists('codesign', ['--version'])) {
     await run('codesign', ['--force', '--sign', '-', executablePath]);
   }
   await fse.remove(work);
 }
 
-function createLooseLauncherSource() {
-  return `
-'use strict';
-const path = require('node:path');
-const fs = require('node:fs');
-const { createRequire } = require('node:module');
 
-const executableDir = path.dirname(process.execPath);
-const appDir = path.join(executableDir, 'app');
-const packagePath = path.join(appDir, 'package.json');
-if (!fs.existsSync(packagePath)) {
-  console.error('AtomJS application files are missing:', appDir);
-  process.exit(1);
+async function prepareWindowsExecutableForInjection(executablePath) {
+  const image = await fs.promises.readFile(executablePath);
+  const pe = readPortableExecutableLayout(image);
+  const certificateDirectory = pe.dataDirectoryOffset + (8 * 4);
+  const certificateOffset = image.readUInt32LE(certificateDirectory);
+  const certificateSize = image.readUInt32LE(certificateDirectory + 4);
+
+  image.writeUInt32LE(0, certificateDirectory);
+  image.writeUInt32LE(0, certificateDirectory + 4);
+  image.writeUInt32LE(0, pe.optionalHeaderOffset + 64);
+
+  const certificateEnd = certificateOffset + certificateSize;
+  const output = certificateOffset > 0 && certificateSize > 0 && certificateEnd === image.length
+    ? image.subarray(0, certificateOffset)
+    : image;
+  await fs.promises.writeFile(executablePath, output);
 }
 
-const runtimeNode = path.join(executableDir, 'runtime', process.platform === 'win32' ? 'node.exe' : 'node');
-process.chdir(appDir);
-process.env.ATOM_PROJECT_ROOT = appDir;
-process.env.ATOM_BUILD = '1';
-process.env.ATOM_NODE_EXECUTABLE = runtimeNode;
-const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-const mainPath = path.resolve(appDir, pkg.main || 'main.js');
-const load = createRequire(packagePath);
-load(mainPath);
-`;
+async function setWindowsGuiSubsystem(executablePath) {
+  const image = await fs.promises.readFile(executablePath);
+  const pe = readPortableExecutableLayout(image);
+  image.writeUInt16LE(2, pe.optionalHeaderOffset + 68);
+  image.writeUInt32LE(0, pe.optionalHeaderOffset + 64);
+  await fs.promises.writeFile(executablePath, image);
+}
+
+function readPortableExecutableLayout(image) {
+  if (image.length < 0x100 || image.toString('ascii', 0, 2) !== 'MZ') {
+    throw new Error('AtomJS expected a Windows PE executable but the DOS header is missing.');
+  }
+
+  const peOffset = image.readUInt32LE(0x3c);
+  if (peOffset < 0x40 || peOffset + 0x100 > image.length || image.toString('ascii', peOffset, peOffset + 4) !== 'PE\\0\\0') {
+    throw new Error('AtomJS expected a Windows PE executable but the PE header is invalid.');
+  }
+
+  const optionalHeaderOffset = peOffset + 24;
+  const magic = image.readUInt16LE(optionalHeaderOffset);
+  if (magic !== 0x10b && magic !== 0x20b) {
+    throw new Error(`AtomJS does not support Windows PE optional-header magic 0x${magic.toString(16)}.`);
+  }
+
+  return {
+    optionalHeaderOffset,
+    dataDirectoryOffset: optionalHeaderOffset + (magic === 0x20b ? 112 : 96)
+  };
 }
 
 function createEmbeddedLauncherSource(productName) {
@@ -354,6 +392,7 @@ const os = require('node:os');
 const crypto = require('node:crypto');
 const zlib = require('node:zlib');
 const { createRequire } = require('node:module');
+const { pathToFileURL } = require('node:url');
 const { getAsset } = require('node:sea');
 
 const productName = ${JSON.stringify(productName)};
@@ -397,7 +436,20 @@ const executableDir = path.dirname(process.execPath);
 process.chdir(appDir);
 process.env.ATOM_PROJECT_ROOT = appDir;
 process.env.ATOM_BUILD = '1';
+process.env.ATOM_EMBEDDED_RUNTIME = '1';
+process.env.ATOM_WINDOW_HOST_ENTRY = path.join(appDir, 'vendor', 'atomjs', 'src', 'runtime', 'window-host.mjs');
 process.env.ATOM_MACOS_HOST_EXECUTABLE = path.join(executableDir, 'AtomJSWindowHost');
+const hostModeIndex = process.argv.indexOf('--atomjs-window-host');
+if (hostModeIndex !== -1) {
+  const hostEntry = process.env.ATOM_WINDOW_HOST_ENTRY;
+  const configPath = process.argv[hostModeIndex + 1];
+  process.argv = [process.argv[0], hostEntry, configPath];
+  import(pathToFileURL(hostEntry).href).catch((error) => {
+    console.error(error && error.stack ? error.stack : error);
+    process.exit(1);
+  });
+  return;
+}
 const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
 const mainPath = path.resolve(appDir, pkg.main || 'main.js');
 const load = createRequire(packagePath);
@@ -414,40 +466,65 @@ async function packageWindows({ project, buildRoot, unpacked, executableName, pr
   const nsisPath = path.join(buildRoot, 'installer.nsi');
   const installerPath = path.join(buildRoot, `${productName} Installer.exe`);
   const escapedSource = unpacked.replace(/\\/g, '\\\\');
+  const version = String(project.packageJson.version || '0.0.0');
+  const author = project.packageJson.author;
+  const publisher = typeof author === 'string'
+    ? author
+    : author && typeof author === 'object' && author.name
+      ? author.name
+      : 'AtomJS application';
+  const uninstallKey = `Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\${escapeNsis(project.config.appId)}`;
   const credit = project.config.installerCredit
     ? `!define MUI_WELCOMEPAGE_TEXT "This installer will install ${escapeNsis(productName)}.$\\r$\\n$\\r$\\nPowered by AtomJS — https://github.com/Atom-js-org/atom"`
     : '';
   const script = `
 Unicode true
+SetCompressor /SOLID lzma
 !include "MUI2.nsh"
 Name "${escapeNsis(productName)}"
 OutFile "${installerPath.replace(/\\/g, '\\\\')}"
 InstallDir "$LOCALAPPDATA\\Programs\\${escapeNsis(productName)}"
 RequestExecutionLevel user
+ShowInstDetails show
+ShowUninstDetails show
 ${credit}
 !insertmacro MUI_PAGE_WELCOME
 !insertmacro MUI_PAGE_DIRECTORY
 !insertmacro MUI_PAGE_INSTFILES
+!define MUI_FINISHPAGE_RUN "$INSTDIR\\${escapeNsis(executableName)}"
 !insertmacro MUI_PAGE_FINISH
+!insertmacro MUI_UNPAGE_CONFIRM
+!insertmacro MUI_UNPAGE_INSTFILES
 !insertmacro MUI_LANGUAGE "English"
 Section "Install"
+  SetShellVarContext current
   SetOutPath "$INSTDIR"
   File /r "${escapedSource}\\*"
   CreateDirectory "$SMPROGRAMS\\${escapeNsis(productName)}"
   CreateShortcut "$SMPROGRAMS\\${escapeNsis(productName)}\\${escapeNsis(productName)}.lnk" "$INSTDIR\\${escapeNsis(executableName)}"
   CreateShortcut "$DESKTOP\\${escapeNsis(productName)}.lnk" "$INSTDIR\\${escapeNsis(executableName)}"
   WriteUninstaller "$INSTDIR\\Uninstall.exe"
+  WriteRegStr HKCU "${uninstallKey}" "DisplayName" "${escapeNsis(productName)}"
+  WriteRegStr HKCU "${uninstallKey}" "DisplayVersion" "${escapeNsis(version)}"
+  WriteRegStr HKCU "${uninstallKey}" "Publisher" "${escapeNsis(publisher)}"
+  WriteRegStr HKCU "${uninstallKey}" "DisplayIcon" "$INSTDIR\\${escapeNsis(executableName)}"
+  WriteRegStr HKCU "${uninstallKey}" "UninstallString" "$\\\"$INSTDIR\\Uninstall.exe$\\\""
+  WriteRegDWORD HKCU "${uninstallKey}" "NoModify" 1
+  WriteRegDWORD HKCU "${uninstallKey}" "NoRepair" 1
 SectionEnd
 Section "Uninstall"
+  SetShellVarContext current
   Delete "$DESKTOP\\${escapeNsis(productName)}.lnk"
   RMDir /r "$SMPROGRAMS\\${escapeNsis(productName)}"
+  DeleteRegKey HKCU "${uninstallKey}"
   RMDir /r "$INSTDIR"
 SectionEnd
 `;
   await fs.promises.writeFile(nsisPath, script.trimStart(), 'utf8');
 
-  if (commandExists('makensis', ['/VERSION'])) {
-    await run('makensis', [nsisPath]);
+  const makensis = resolveNsisExecutable();
+  if (makensis) {
+    await run(makensis, [nsisPath]);
     if (fs.existsSync(installerPath)) outputs.push(installerPath);
   } else {
     console.warn('NSIS was not found; installer.nsi was generated but the .exe installer was skipped.');
@@ -455,6 +532,19 @@ SectionEnd
   return outputs;
 }
 
+function resolveNsisExecutable() {
+  const candidates = [
+    process.env.MAKENSIS_PATH,
+    process.env.NSIS_HOME && path.join(process.env.NSIS_HOME, 'makensis.exe'),
+    process.env['ProgramFiles(x86)'] && path.join(process.env['ProgramFiles(x86)'], 'NSIS', 'makensis.exe'),
+    process.env.ProgramFiles && path.join(process.env.ProgramFiles, 'NSIS', 'makensis.exe'),
+    process.env.LOCALAPPDATA && path.join(process.env.LOCALAPPDATA, 'Programs', 'NSIS', 'makensis.exe')
+  ].filter(Boolean);
+
+  if (commandExists('makensis', ['/VERSION'])) return 'makensis';
+  return candidates.find((candidate) => fs.existsSync(candidate)) || null;
+}
+
 async function packageMacOS({ project, buildRoot, unpacked, executableName, productName, hostSource }) {
   const outputs = [];
   const appBundle = path.join(buildRoot, `${productName}.app`);
@@ -555,8 +645,6 @@ async function packageLinux({ project, buildRoot, unpacked, executableName, prod
   await fse.ensureDir(usrBin);
   await fse.ensureDir(usrLibApp);
   await fse.copy(path.join(unpacked, executableName), path.join(usrBin, productName));
-  await fse.copy(path.join(unpacked, 'app'), path.join(usrBin, 'app'));
-  await fse.copy(path.join(unpacked, 'runtime'), path.join(usrBin, 'runtime'));
   await fse.copy(path.join(unpacked, 'ATOMJS-CREDIT.txt'), path.join(usrLibApp, 'ATOMJS-CREDIT.txt'));
 
   const appRun = `#!/bin/sh\nHERE="$(dirname "$(readlink -f "$0")")"\nexec "$HERE/usr/bin/${productName}" "$@"\n`;

package/src/doctor.cjs

@@ -12,8 +12,9 @@ async function doctorCommand(options = {}) {
 
   if (process.platform === 'win32') {
     rows.push(check('PowerShell', commandExists('powershell.exe', ['-NoProfile', '-Command', '$PSVersionTable.PSVersion.ToString()'])));
-    rows.push(check('WebView2 Runtime', checkWindowsWebView2(), 'required by the native WebView'));
-    rows.push(check('NSIS (optional installer)', commandExists('makensis', ['/VERSION'])));
+    const webView2Version = getWindowsWebView2Version();
+    rows.push(check('WebView2 Runtime', Boolean(webView2Version), webView2Version || 'required by the native WebView'));
+    rows.push(check('NSIS (optional installer)', Boolean(resolveNsisExecutable())));
   } else if (process.platform === 'darwin') {
     rows.push(check('Xcode Command Line Tools', commandExists('/usr/bin/xcrun', ['--version']), 'required to compile the native Cocoa host'));
     rows.push(check('Clang', commandExists('/usr/bin/xcrun', ['clang', '--version'])));
@@ -69,18 +70,43 @@ function pkgConfigExists(name) {
   return !result.error && result.status === 0;
 }
 
-function checkWindowsWebView2() {
+function getWindowsWebView2Version() {
   const script = `
 $paths = @(
-  'HKLM:\\SOFTWARE\\WOW6432Node\\Microsoft\\EdgeUpdate\\Clients\\{F1E7E4A4-BD05-43A5-BCC0-B7F5E0E9D7F5}',
-  'HKLM:\\SOFTWARE\\Microsoft\\EdgeUpdate\\Clients\\{F1E7E4A4-BD05-43A5-BCC0-B7F5E0E9D7F5}',
-  'HKCU:\\Software\\Microsoft\\EdgeUpdate\\Clients\\{F1E7E4A4-BD05-43A5-BCC0-B7F5E0E9D7F5}'
+  'HKLM:\\SOFTWARE\\WOW6432Node\\Microsoft\\EdgeUpdate\\Clients\\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}',
+  'HKLM:\\SOFTWARE\\Microsoft\\EdgeUpdate\\Clients\\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}',
+  'HKCU:\\Software\\Microsoft\\EdgeUpdate\\Clients\\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}'
 )
-foreach ($p in $paths) { if (Test-Path $p) { exit 0 } }
+foreach ($p in $paths) {
+  try {
+    $version = Get-ItemPropertyValue -Path $p -Name 'pv' -ErrorAction Stop
+    if ($version -and $version -ne '0.0.0.0') {
+      Write-Output $version
+      exit 0
+    }
+  } catch {}
+}
 exit 1
 `;
-  const result = spawnSync('powershell.exe', ['-NoProfile', '-Command', script], { stdio: 'ignore' });
-  return !result.error && result.status === 0;
+  const result = spawnSync('powershell.exe', ['-NoProfile', '-Command', script], {
+    encoding: 'utf8',
+    windowsHide: true
+  });
+  if (result.error || result.status !== 0) return null;
+  return String(result.stdout || '').trim() || null;
+}
+
+function resolveNsisExecutable() {
+  const candidates = [
+    process.env.MAKENSIS_PATH,
+    process.env.NSIS_HOME && path.join(process.env.NSIS_HOME, 'makensis.exe'),
+    process.env['ProgramFiles(x86)'] && path.join(process.env['ProgramFiles(x86)'], 'NSIS', 'makensis.exe'),
+    process.env.ProgramFiles && path.join(process.env.ProgramFiles, 'NSIS', 'makensis.exe'),
+    process.env.LOCALAPPDATA && path.join(process.env.LOCALAPPDATA, 'Programs', 'NSIS', 'makensis.exe')
+  ].filter(Boolean);
+
+  if (commandExists('makensis', ['/VERSION'])) return 'makensis';
+  return candidates.find((candidate) => fs.existsSync(candidate)) || null;
 }
 
 module.exports = { doctorCommand };

package/src/utils.cjs

@@ -54,9 +54,17 @@ function loadProject(projectInput) {
   };
 }
 
+function normalizeSpawn(command, args) {
+  if (process.platform === 'win32' && /\.(?:cmd|bat)$/i.test(command)) {
+    return { command: process.env.ComSpec || 'cmd.exe', args: ['/d', '/s', '/c', command, ...args] };
+  }
+  return { command, args };
+}
+
 function run(command, args, options = {}) {
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
+    const normalized = normalizeSpawn(command, args);
+    const child = spawn(normalized.command, normalized.args, {
       cwd: options.cwd || process.cwd(),
       env: options.env || process.env,
       stdio: options.stdio || 'inherit',
@@ -71,7 +79,8 @@ function run(command, args, options = {}) {
 }
 
 function capture(command, args, options = {}) {
-  const result = spawnSync(command, args, {
+  const normalized = normalizeSpawn(command, args);
+  const result = spawnSync(normalized.command, normalized.args, {
     cwd: options.cwd || process.cwd(),
     env: options.env || process.env,
     encoding: 'utf8',
@@ -86,7 +95,8 @@ function capture(command, args, options = {}) {
 }
 
 function commandExists(command, args = ['--version']) {
-  const result = spawnSync(command, args, { stdio: 'ignore', shell: false });
+  const normalized = normalizeSpawn(command, args);
+  const result = spawnSync(normalized.command, normalized.args, { stdio: 'ignore', shell: false });
   return !result.error && result.status === 0;
 }