@atom-js-org/runtime 0.5.3-alpha.0 → 0.5.3-alpha.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atom-js-org/runtime",
-  "version": "0.5.3-alpha.0",
+  "version": "0.5.3-alpha.2",
   "description": "Electron-like desktop runtime powered by the operating system WebView.",
   "main": "src/index.cjs",
   "types": "index.d.ts",
@@ -19,10 +19,11 @@
     "LICENSE"
   ],
   "engines": {
-    "node": ">=20.12"
+    "node": ">=24"
   },
   "dependencies": {
-    "ws": "^8.21.1"
+    "ws": "^8.21.1",
+    "@webviewjs/webview": "0.4.0"
   },
   "repository": {
     "type": "git",

package/src/app.cjs

@@ -7,6 +7,7 @@ const fs = require('node:fs');
 const state = require('./state.cjs');
 const { BridgeServer } = require('./bridge-server.cjs');
 const { stopNativeHost } = require('./native-host.cjs');
+const { stopWindowsNativeHost } = require('./windows-native-host.cjs');
 
 class App extends EventEmitter {
   constructor() {
@@ -43,6 +44,7 @@ class App extends EventEmitter {
 
     for (const win of [...state.windows.values()]) win.destroy();
     await stopNativeHost();
+    await stopWindowsNativeHost();
     if (state.bridgeServer) await state.bridgeServer.stop();
     this.emit('will-quit');
     this.emit('quit', {}, 0);

package/src/bridge-server.cjs

@@ -220,6 +220,7 @@ class BridgeServer {
 
     const match = url.pathname.match(/^\/__atom\/window\/(\d+)\/(.*)$/);
     if (!match) {
+      if (await redirectRootRelativeApplicationAsset(request, response, url)) return;
       response.statusCode = 404;
       response.end('Not found');
       return;
@@ -271,6 +272,58 @@ class BridgeServer {
   }
 }
 
+async function redirectRootRelativeApplicationAsset(request, response, url) {
+  if (!['GET', 'HEAD'].includes(String(request.method || 'GET').toUpperCase())) return false;
+  if (url.pathname.startsWith('/__atom/')) return false;
+
+  const referer = request.headers && request.headers.referer;
+  if (!referer) return false;
+
+  let refererUrl;
+  try {
+    refererUrl = new URL(referer, 'http://127.0.0.1');
+  } catch {
+    return false;
+  }
+
+  const refererMatch = refererUrl.pathname.match(/^\/__atom\/window\/(\d+)\//);
+  if (!refererMatch) return false;
+
+  const windowId = Number(refererMatch[1]);
+  const win = state.windows.get(windowId);
+  if (!win || !win._contentRoot) return false;
+
+  let requested;
+  try {
+    requested = decodeURIComponent(url.pathname.replace(/^\/+/, ''));
+  } catch {
+    return false;
+  }
+  if (!requested) return false;
+
+  const root = path.resolve(win._contentRoot);
+  const absolute = path.resolve(root, requested);
+  if (absolute !== root && !absolute.startsWith(root + path.sep)) return false;
+
+  try {
+    const stat = await fs.promises.stat(absolute);
+    if (!stat.isFile() && !stat.isDirectory()) return false;
+  } catch {
+    return false;
+  }
+
+  const encodedPath = requested
+    .split(/[\\/]+/)
+    .filter(Boolean)
+    .map((part) => encodeURIComponent(part))
+    .join('/');
+  response.statusCode = 307;
+  response.setHeader('location', `/__atom/window/${windowId}/${encodedPath}${url.search}`);
+  response.setHeader('cache-control', 'no-store');
+  response.end();
+  return true;
+}
+
 function createIpcEvent(win) {
   return Object.freeze({
     sender: win.webContents,
@@ -289,4 +342,4 @@ function serializeError(error) {
   };
 }
 
-module.exports = { BridgeServer };
+module.exports = { BridgeServer, redirectRootRelativeApplicationAsset };

package/src/browser-window.cjs

@@ -10,6 +10,7 @@ const app = require('./app.cjs');
 const { WebContents } = require('./web-contents.cjs');
 const { generateBridgeScript } = require('./bridge-script.cjs');
 const { getNativeHost } = require('./native-host.cjs');
+const { getWindowsNativeHost } = require('./windows-native-host.cjs');
 
 class BrowserWindow extends EventEmitter {
   constructor(options = {}) {
@@ -136,6 +137,10 @@ class BrowserWindow extends EventEmitter {
       this._nativeHost = getNativeHost(app.getName());
       this._hostAttached = true;
       await this._nativeHost.createWindow(this, config);
+    } else if (process.platform === 'win32') {
+      this._nativeHost = getWindowsNativeHost();
+      this._hostAttached = true;
+      await this._nativeHost.createWindow(this, config);
     } else {
       await this._startLegacyHost(config);
     }
@@ -213,8 +218,7 @@ class BrowserWindow extends EventEmitter {
 
   _sendHostCommand(command) {
     if (this._nativeHost) {
-      this._nativeHost.send({ ...command, windowId: this.id });
-      return true;
+      return this._nativeHost.send({ ...command, windowId: this.id }) !== false;
     }
     return false;
   }

package/src/runtime/window-host.mjs

@@ -29,7 +29,7 @@ try {
   ({ Webview, SizeHint } = await import('webview-nodejs'));
 } catch (error) {
   console.error('\nAtomJS could not load the system WebView binding.');
-  console.error('Windows and Linux currently require the webview-nodejs package.');
+  console.error('Linux currently requires the webview-nodejs package.');
   console.error('Run `atom doctor`, install the platform prerequisites, then install dependencies again.');
   console.error(error && error.stack ? error.stack : error);
   process.exit(1);

package/src/windows-native-host.cjs

@@ -0,0 +1,426 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let singleton = null;
+
+class WindowsNativeHost {
+  constructor() {
+    this.binding = null;
+    this.application = null;
+    this.webContext = null;
+    this.webviewDataDirectory = null;
+    this.startPromise = null;
+    this.windows = new Map();
+    this.stopping = false;
+  }
+
+  async ensureStarted() {
+    if (process.platform !== 'win32') {
+      throw new Error('The in-process Windows native host can only run on Windows.');
+    }
+    if (!this.startPromise) {
+      this.startPromise = this._start().catch((error) => {
+        this.startPromise = null;
+        throw error;
+      });
+    }
+    await this.startPromise;
+  }
+
+  async _start() {
+    let binding;
+    try {
+      binding = require('@webviewjs/webview');
+    } catch (error) {
+      const wrapped = new Error([
+        'AtomJS could not load the prebuilt Windows WebView binding.',
+        'Delete node_modules and package-lock.json, then run npm install again.',
+        'CMake and Visual Studio Build Tools are not required.',
+        error && error.message ? error.message : String(error)
+      ].join('\n'));
+      wrapped.cause = error;
+      throw wrapped;
+    }
+
+    this.binding = binding;
+    this.application = new binding.Application();
+    await this.application.whenReady({ interval: 16, ref: true });
+
+    this.webviewDataDirectory = resolveWritableWebViewDataDirectory();
+    try {
+      this.webContext = this.application.createWebContext({
+        dataDirectory: this.webviewDataDirectory,
+        allowsAutomation: false
+      });
+    } catch (error) {
+      const wrapped = new Error([
+        'AtomJS could not create a writable WebView2 data directory.',
+        `Directory: ${this.webviewDataDirectory}`,
+        'Check that the current Windows user can write to LOCALAPPDATA.',
+        error && error.message ? error.message : String(error)
+      ].join('\n'));
+      wrapped.cause = error;
+      throw wrapped;
+    }
+  }
+
+  async createWindow(atomWindow, config) {
+    await this.ensureStarted();
+
+    const parent = config.parentWindowId ? this.windows.get(Number(config.parentWindowId)) : null;
+    const nativeOptions = {
+      title: String(config.title || 'AtomJS App'),
+      width: positive(config.width, 800),
+      height: positive(config.height, 600),
+      logical: true,
+      resizable: config.resizable !== false,
+      visible: false,
+      decorations: config.frame !== false,
+      alwaysOnTop: Boolean(config.alwaysOnTop),
+      maximizable: config.maximizable !== false,
+      minimizable: config.minimizable !== false,
+      focused: config.focusable !== false,
+      transparent: Boolean(config.transparent),
+      windowsSkipTaskbar: Boolean(config.skipTaskbar),
+      windowsClassName: sanitizeWindowsClass(process.env.ATOM_APP_ID || process.env.ATOM_APP_NAME || config.title)
+    };
+    if (Number.isFinite(Number(config.x))) nativeOptions.x = Math.round(Number(config.x));
+    if (Number.isFinite(Number(config.y))) nativeOptions.y = Math.round(Number(config.y));
+    if (parent && parent.nativeWindow && typeof parent.nativeWindow.getNativeHandle === 'function') {
+      nativeOptions.windowsOwnerWindow = parent.nativeWindow.getNativeHandle();
+    }
+
+    const nativeWindow = this.application.createBrowserWindow(nativeOptions);
+    nativeWindow.setClosable(config.closable !== false);
+    if (Number(config.minWidth) > 0 || Number(config.minHeight) > 0) {
+      nativeWindow.setMinSize(positive(config.minWidth, 1), positive(config.minHeight, 1), true);
+    }
+    if (Number(config.maxWidth) > 0 || Number(config.maxHeight) > 0) {
+      nativeWindow.setMaxSize(positive(config.maxWidth, 100000), positive(config.maxHeight, 100000), true);
+    }
+    if (config.center !== false && !Number.isFinite(Number(config.x)) && !Number.isFinite(Number(config.y))) {
+      nativeWindow.center();
+    }
+
+    const webview = nativeWindow.createWebview({
+      url: String(config.url),
+      preload: String(config.bridgeScript || ''),
+      enableDevtools: Boolean(config.debug),
+      transparent: Boolean(config.transparent),
+      webContext: this.webContext
+    });
+
+    const record = {
+      atomWindow,
+      nativeWindow,
+      webview,
+      dragRegions: [],
+      dragViewport: {
+        width: positive(config.width, 800),
+        height: positive(config.height, 600)
+      },
+      lastCursorPhysical: null,
+      dragState: null,
+      lastDragClick: null
+    };
+    this.windows.set(Number(config.windowId), record);
+    this._attachEvents(Number(config.windowId), record);
+
+    if (config.show === false) nativeWindow.hide();
+    else nativeWindow.show();
+  }
+
+  _attachEvents(windowId, record) {
+    const emit = (event) => {
+      if (!this.windows.has(windowId)) return;
+      try { record.atomWindow._handleHostEvent({ ...event, windowId }); } catch {}
+    };
+
+    record.nativeWindow.on('close', () => {
+      try { record.atomWindow._handleHostEvent({ type: 'closed', windowId }); } catch {}
+      this.windows.delete(windowId);
+    });
+    record.nativeWindow.on('focus', () => emit({ type: 'focus' }));
+    record.nativeWindow.on('blur', () => {
+      record.dragState = null;
+      emit({ type: 'blur' });
+    });
+    record.nativeWindow.on('move', (event) => {
+      const scale = safeScaleFactor(record.nativeWindow);
+      emit({
+        type: 'bounds-changed',
+        reason: 'move',
+        bounds: { x: Number(event.x) / scale, y: Number(event.y) / scale }
+      });
+    });
+    record.nativeWindow.on('resize', (event) => {
+      const scale = safeScaleFactor(record.nativeWindow);
+      emit({
+        type: 'bounds-changed',
+        reason: 'resize',
+        bounds: { width: Number(event.width) / scale, height: Number(event.height) / scale }
+      });
+    });
+    record.nativeWindow.on('mouse-move', (event) => {
+      const point = physicalPoint(event);
+      if (!point) return;
+      record.lastCursorPhysical = point;
+      if (record.dragState) this._continueWindowDrag(record, point);
+    });
+    record.nativeWindow.on('mouse-down', (event) => {
+      if (Number(event.button) !== 0) return;
+      const point = physicalPoint(event);
+      if (!point) return;
+      record.lastCursorPhysical = point;
+      if (!isDraggablePoint(record, point)) return;
+
+      const now = Date.now();
+      const previous = record.lastDragClick;
+      record.lastDragClick = { time: now, x: point.x, y: point.y };
+      if (previous && now - previous.time <= 450 && distanceSquared(previous, point) <= 64) {
+        record.dragState = null;
+        record.lastDragClick = null;
+        try { record.nativeWindow.setMaximized(!record.nativeWindow.isMaximized()); } catch {}
+        return;
+      }
+
+      this._beginWindowDrag(record, point);
+    });
+    record.nativeWindow.on('mouse-up', (event) => {
+      if (Number(event.button) === 0) record.dragState = null;
+    });
+    record.webview.on('page-load-started', (event) => emit({ type: 'did-start-loading', url: event.url || '' }));
+    record.webview.on('page-load-finished', (event) => emit({ type: 'did-finish-load', url: event.url || '' }));
+    record.webview.on('title-changed', (event) => emit({ type: 'page-title-updated', title: event.title || '' }));
+  }
+
+  _beginWindowDrag(record, point) {
+    if (!point) return false;
+    record.dragState = { offsetX: point.x, offsetY: point.y };
+    return true;
+  }
+
+  _continueWindowDrag(record, point) {
+    const state = record.dragState;
+    if (!state) return;
+    try {
+      const current = record.nativeWindow.getPosition(false);
+      const globalX = Number(current.x) + point.x;
+      const globalY = Number(current.y) + point.y;
+      record.nativeWindow.setPosition(
+        Math.round(globalX - state.offsetX),
+        Math.round(globalY - state.offsetY),
+        false
+      );
+    } catch {
+      record.dragState = null;
+    }
+  }
+
+  send(message) {
+    const record = this.windows.get(Number(message.windowId));
+    if (!record) return false;
+    const win = record.nativeWindow;
+    const view = record.webview;
+
+    switch (message.command) {
+      case 'navigate': view.loadUrl(String(message.url)); return true;
+      case 'show': win.show(); return true;
+      case 'hide': win.hide(); return true;
+      case 'focus': win.focus(); return true;
+      case 'close': win.close(); return true;
+      case 'destroy':
+        this.windows.delete(Number(message.windowId));
+        try { view.dispose(); } catch {}
+        try { win.dispose(); } catch {}
+        return true;
+      case 'set-title': win.setTitle(String(message.title || '')); return true;
+      case 'set-always-on-top': win.setAlwaysOnTop(Boolean(message.value)); return true;
+      case 'set-resizable': win.setResizable(Boolean(message.value)); return true;
+      case 'fullscreen':
+        win.setFullscreen(message.value ? this.binding.FullscreenType.Borderless : null);
+        return true;
+      case 'maximize': win.setMaximized(true); return true;
+      case 'unmaximize': win.setMaximized(false); return true;
+      case 'minimize': win.setMinimized(true); return true;
+      case 'restore':
+        win.setMinimized(false);
+        win.setMaximized(false);
+        win.show();
+        return true;
+      case 'set-drag-regions':
+        record.dragRegions = normalizeDragRegions(message.regions);
+        record.dragViewport = normalizeViewport(message.viewport, win);
+        return true;
+      case 'start-drag':
+        return this._beginWindowDrag(record, record.lastCursorPhysical);
+      case 'set-bounds': {
+        const bounds = message.bounds || {};
+        if (Number.isFinite(Number(bounds.width)) && Number.isFinite(Number(bounds.height))) {
+          win.setSize(Math.round(Number(bounds.width)), Math.round(Number(bounds.height)), true);
+        }
+        if (Number.isFinite(Number(bounds.x)) && Number.isFinite(Number(bounds.y))) {
+          win.setPosition(Math.round(Number(bounds.x)), Math.round(Number(bounds.y)), true);
+        }
+        return true;
+      }
+      default: return false;
+    }
+  }
+
+  async stop() {
+    if (this.stopping) return;
+    this.stopping = true;
+    for (const record of this.windows.values()) {
+      try { record.webview.dispose(); } catch {}
+      try { record.nativeWindow.dispose(); } catch {}
+    }
+    this.windows.clear();
+    if (this.webContext) {
+      try { this.webContext.dispose(); } catch {}
+    }
+    if (this.application) {
+      try { this.application.exit(); } catch {}
+    }
+    this.webContext = null;
+    this.webviewDataDirectory = null;
+    this.application = null;
+    this.startPromise = null;
+    this.stopping = false;
+  }
+}
+
+function positive(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.round(number) : fallback;
+}
+
+function safeScaleFactor(win) {
+  try {
+    const scale = Number(win.scaleFactor());
+    return Number.isFinite(scale) && scale > 0 ? scale : 1;
+  } catch {
+    return 1;
+  }
+}
+
+function physicalPoint(event) {
+  const x = Number(event && event.x);
+  const y = Number(event && event.y);
+  if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+  return { x, y };
+}
+
+function normalizeDragRegions(regions) {
+  const normalized = [];
+  for (const region of Array.isArray(regions) ? regions.slice(0, 4096) : []) {
+    const x = Number(region && region.x);
+    const y = Number(region && region.y);
+    const width = Number(region && region.width);
+    const height = Number(region && region.height);
+    if (![x, y, width, height].every(Number.isFinite) || width <= 0 || height <= 0) continue;
+    normalized.push({ x, y, width, height, draggable: region.draggable === true });
+  }
+  return normalized;
+}
+
+function normalizeViewport(viewport, win) {
+  let fallback = { width: 1, height: 1 };
+  try {
+    const size = win.getInnerSize(true);
+    fallback = { width: positive(size.width, 1), height: positive(size.height, 1) };
+  } catch {}
+  const width = Number(viewport && viewport.width);
+  const height = Number(viewport && viewport.height);
+  return {
+    width: Number.isFinite(width) && width > 0 ? width : fallback.width,
+    height: Number.isFinite(height) && height > 0 ? height : fallback.height
+  };
+}
+
+function isDraggablePoint(record, physical) {
+  if (!record.dragRegions.length) return false;
+  const scale = safeScaleFactor(record.nativeWindow);
+  const logical = { x: physical.x / scale, y: physical.y / scale };
+  let inner = { width: record.dragViewport.width, height: record.dragViewport.height };
+  try { inner = record.nativeWindow.getInnerSize(true); } catch {}
+  const scaleX = record.dragViewport.width > 0 ? Number(inner.width) / record.dragViewport.width : 1;
+  const scaleY = record.dragViewport.height > 0 ? Number(inner.height) / record.dragViewport.height : 1;
+  let draggable = false;
+
+  for (const region of record.dragRegions) {
+    const inside = logical.x >= region.x * scaleX &&
+      logical.x < (region.x + region.width) * scaleX &&
+      logical.y >= region.y * scaleY &&
+      logical.y < (region.y + region.height) * scaleY;
+    if (!inside) continue;
+    if (!region.draggable) return false;
+    draggable = true;
+  }
+  return draggable;
+}
+
+function distanceSquared(a, b) {
+  const dx = Number(a.x) - Number(b.x);
+  const dy = Number(a.y) - Number(b.y);
+  return (dx * dx) + (dy * dy);
+}
+
+function resolveWritableWebViewDataDirectory() {
+  const identity = sanitizePathSegment(
+    process.env.ATOM_APP_ID || process.env.ATOM_APP_NAME || 'AtomJS.App'
+  );
+  const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+  const candidates = [
+    path.join(localAppData, identity, 'AtomJS', 'WebView2'),
+    path.join(os.tmpdir(), identity, 'AtomJS', 'WebView2')
+  ];
+  let lastError;
+
+  for (const candidate of candidates) {
+    try {
+      fs.mkdirSync(candidate, { recursive: true });
+      fs.accessSync(candidate, fs.constants.R_OK | fs.constants.W_OK);
+      return candidate;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+
+  throw new Error(`No writable WebView2 data directory was available: ${lastError ? lastError.message : 'unknown error'}`);
+}
+
+function sanitizePathSegment(value) {
+  return String(value || 'AtomJS.App')
+    .replace(/[<>:"/\\|?*\x00-\x1F]+/g, '-')
+    .replace(/[. ]+$/g, '')
+    .slice(0, 120) || 'AtomJS.App';
+}
+
+function sanitizeWindowsClass(value) {
+  return String(value || 'AtomJS.App').replace(/[^A-Za-z0-9._-]+/g, '.').slice(0, 120) || 'AtomJS.App';
+}
+
+function getWindowsNativeHost() {
+  if (!singleton) singleton = new WindowsNativeHost();
+  return singleton;
+}
+
+async function stopWindowsNativeHost() {
+  if (!singleton) return;
+  const current = singleton;
+  singleton = null;
+  await current.stop();
+}
+
+module.exports = {
+  WindowsNativeHost,
+  getWindowsNativeHost,
+  stopWindowsNativeHost,
+  isDraggablePoint,
+  normalizeDragRegions,
+  resolveWritableWebViewDataDirectory
+};