@atom-js-org/runtime 0.5.3-alpha.1 → 0.5.3-alpha.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atom-js-org/runtime",
-  "version": "0.5.3-alpha.1",
+  "version": "0.5.3-alpha.3",
   "description": "Electron-like desktop runtime powered by the operating system WebView.",
   "main": "src/index.cjs",
   "types": "index.d.ts",
@@ -23,7 +23,8 @@
   },
   "dependencies": {
     "ws": "^8.21.1",
-    "@webviewjs/webview": "0.4.0"
+    "@webviewjs/webview": "0.4.0",
+    "koffi": "3.1.2"
   },
   "repository": {
     "type": "git",

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/windows-native-drag.cjs

@@ -0,0 +1,126 @@
+'use strict';
+
+const WM_NCLBUTTONDOWN = 0x00A1;
+const HTCAPTION = 2;
+const VK_LBUTTON = 0x01;
+const SM_CXDOUBLECLK = 36;
+const SM_CYDOUBLECLK = 37;
+
+let singleton = null;
+let warned = false;
+
+class WindowsNativeDragApi {
+  constructor(koffi) {
+    if (!koffi || typeof koffi.load !== 'function') {
+      throw new TypeError('A Koffi module is required.');
+    }
+
+    const user32 = koffi.load('user32.dll');
+    const pointType = koffi.struct('ATOMJS_WIN32_POINT', { x: 'long', y: 'long' });
+    this.releaseCapture = user32.func('__stdcall', 'ReleaseCapture', 'bool', []);
+    this.sendMessageW = user32.func(
+      '__stdcall',
+      'SendMessageW',
+      'intptr_t',
+      ['void *', 'uint32_t', 'uintptr_t', 'intptr_t']
+    );
+    this.getAsyncKeyState = user32.func('__stdcall', 'GetAsyncKeyState', 'int16_t', ['int']);
+    this.getCursorPos = user32.func('__stdcall', 'GetCursorPos', 'bool', [koffi.out(koffi.pointer(pointType))]);
+    this.getDoubleClickTime = user32.func('__stdcall', 'GetDoubleClickTime', 'uint32_t', []);
+    this.getSystemMetrics = user32.func('__stdcall', 'GetSystemMetrics', 'int', ['int']);
+  }
+
+  isLeftButtonDown() {
+    return (Number(this.getAsyncKeyState(VK_LBUTTON)) & 0x8000) !== 0;
+  }
+
+  doubleClickSettings() {
+    return {
+      time: positiveInteger(this.getDoubleClickTime(), 500),
+      width: positiveInteger(this.getSystemMetrics(SM_CXDOUBLECLK), 4),
+      height: positiveInteger(this.getSystemMetrics(SM_CYDOUBLECLK), 4)
+    };
+  }
+
+  startWindowDrag(nativeWindow) {
+    const handle = nativeWindowHandle(nativeWindow);
+    if (handle === 0n || !this.isLeftButtonDown()) return false;
+
+    // Hand control to DefWindowProc instead of moving the window from JavaScript.
+    // This enters Windows' normal move loop, including snapping, monitor/DPI
+    // transitions and maximized-window restore behavior.
+    const cursor = {};
+    const cursorPosition = this.getCursorPos(cursor) ? packScreenPoint(cursor.x, cursor.y) : 0n;
+
+    this.releaseCapture();
+    this.sendMessageW(handle, WM_NCLBUTTONDOWN, HTCAPTION, cursorPosition);
+    return true;
+  }
+}
+
+
+function packScreenPoint(x, y) {
+  const xWord = BigInt.asUintN(16, BigInt(Math.trunc(Number(x) || 0)));
+  const yWord = BigInt.asUintN(16, BigInt(Math.trunc(Number(y) || 0)));
+  return BigInt.asIntN(32, xWord | (yWord << 16n));
+}
+
+function nativeWindowHandle(nativeWindow) {
+  if (!nativeWindow) return 0n;
+
+  let value = 0n;
+  try {
+    if (typeof nativeWindow.getNativeHandleAnyThread === 'function') {
+      value = nativeWindow.getNativeHandleAnyThread();
+    } else if (typeof nativeWindow.getNativeHandle === 'function') {
+      value = nativeWindow.getNativeHandle();
+    }
+  } catch {
+    return 0n;
+  }
+
+  try {
+    return BigInt(value || 0);
+  } catch {
+    return 0n;
+  }
+}
+
+function positiveInteger(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.round(number) : fallback;
+}
+
+function getWindowsNativeDragApi() {
+  if (process.platform !== 'win32') return null;
+  if (singleton) return singleton;
+
+  try {
+    singleton = new WindowsNativeDragApi(require('koffi'));
+    return singleton;
+  } catch (error) {
+    if (!warned) {
+      warned = true;
+      console.warn([
+        '[AtomJS] Native Windows window dragging could not be initialized.',
+        'Run npm install so the prebuilt koffi Windows package is present.',
+        error && error.message ? error.message : String(error)
+      ].join('\n'));
+    }
+    return null;
+  }
+}
+
+module.exports = {
+  WindowsNativeDragApi,
+  getWindowsNativeDragApi,
+  nativeWindowHandle,
+  packScreenPoint,
+  constants: {
+    WM_NCLBUTTONDOWN,
+    HTCAPTION,
+    VK_LBUTTON,
+    SM_CXDOUBLECLK,
+    SM_CYDOUBLECLK
+  }
+};

package/src/windows-native-host.cjs

@@ -1,11 +1,18 @@
 'use strict';
 
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { getWindowsNativeDragApi } = require('./windows-native-drag.cjs');
+
 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;
@@ -42,6 +49,23 @@ class WindowsNativeHost {
     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) {
@@ -52,6 +76,7 @@ class WindowsNativeHost {
       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,
@@ -85,10 +110,22 @@ class WindowsNativeHost {
       url: String(config.url),
       preload: String(config.bridgeScript || ''),
       enableDevtools: Boolean(config.debug),
-      transparent: Boolean(config.transparent)
+      transparent: Boolean(config.transparent),
+      webContext: this.webContext
     });
 
-    const record = { atomWindow, nativeWindow, webview };
+    const record = {
+      windowId: Number(config.windowId),
+      atomWindow,
+      nativeWindow,
+      webview,
+      dragRegions: [],
+      dragViewport: {
+        width: positive(config.width, 800),
+        height: positive(config.height, 600)
+      },
+      lastDragClick: null
+    };
     this.windows.set(Number(config.windowId), record);
     this._attachEvents(Number(config.windowId), record);
 
@@ -108,21 +145,57 @@ class WindowsNativeHost {
     });
     record.nativeWindow.on('focus', () => emit({ type: 'focus' }));
     record.nativeWindow.on('blur', () => emit({ type: 'blur' }));
-    record.nativeWindow.on('move', (event) => emit({
-      type: 'bounds-changed',
-      reason: 'move',
-      bounds: { x: Number(event.x), y: Number(event.y) }
-    }));
-    record.nativeWindow.on('resize', (event) => emit({
-      type: 'bounds-changed',
-      reason: 'resize',
-      bounds: { width: Number(event.width), height: Number(event.height) }
-    }));
+    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-down', (event) => {
+      if (Number(event.button) !== 0) return;
+      const point = physicalPoint(event);
+      if (!point || !isDraggablePoint(record, point)) return;
+      this._startNativeWindowDrag(record, point);
+    });
     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 || '' }));
   }
 
+  _startNativeWindowDrag(record, point = null) {
+    const nativeDrag = getWindowsNativeDragApi();
+    if (!nativeDrag) return false;
+
+    if (point && isSystemDoubleClick(record, point, nativeDrag.doubleClickSettings())) {
+      record.lastDragClick = null;
+      try { record.nativeWindow.setMaximized(!record.nativeWindow.isMaximized()); } catch {}
+      return true;
+    }
+
+    const before = readPhysicalWindowPosition(record.nativeWindow);
+    const started = nativeDrag.startWindowDrag(record.nativeWindow);
+    if (!started) return false;
+
+    // SendMessageW returns when the native move loop ends. A real movement must
+    // not become the first half of a later title-bar double click.
+    const after = readPhysicalWindowPosition(record.nativeWindow);
+    if (!samePhysicalPosition(before, after)) {
+      record.lastDragClick = null;
+      emitFinalWindowBounds(record);
+    }
+    return true;
+  }
+
   send(message) {
     const record = this.windows.get(Number(message.windowId));
     if (!record) return false;
@@ -154,6 +227,12 @@ class WindowsNativeHost {
         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._startNativeWindowDrag(record);
       case 'set-bounds': {
         const bounds = message.bounds || {};
         if (Number.isFinite(Number(bounds.width)) && Number.isFinite(Number(bounds.height))) {
@@ -176,9 +255,14 @@ class WindowsNativeHost {
       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;
@@ -190,6 +274,152 @@ function positive(value, fallback) {
   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 isSystemDoubleClick(record, point, settings) {
+  const now = Date.now();
+  const previous = record.lastDragClick;
+  record.lastDragClick = { time: now, x: point.x, y: point.y };
+  if (!previous) return false;
+
+  const halfWidth = Math.max(1, Number(settings && settings.width) / 2);
+  const halfHeight = Math.max(1, Number(settings && settings.height) / 2);
+  return now - previous.time <= Number(settings && settings.time || 500) &&
+    Math.abs(Number(previous.x) - Number(point.x)) <= halfWidth &&
+    Math.abs(Number(previous.y) - Number(point.y)) <= halfHeight;
+}
+
+function readPhysicalWindowPosition(win) {
+  try {
+    const position = win.getPosition(false);
+    const x = Number(position && position.x);
+    const y = Number(position && position.y);
+    return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : null;
+  } catch {
+    return null;
+  }
+}
+
+
+function emitFinalWindowBounds(record) {
+  try {
+    const win = record.nativeWindow;
+    const scale = safeScaleFactor(win);
+    const position = win.getPosition(false);
+    const size = win.getInnerSize(true);
+    record.atomWindow._handleHostEvent({
+      type: 'bounds-changed',
+      reason: 'move',
+      windowId: record.windowId,
+      bounds: {
+        x: Number(position.x) / scale,
+        y: Number(position.y) / scale,
+        width: Number(size.width),
+        height: Number(size.height)
+      }
+    });
+  } catch {}
+}
+
+function samePhysicalPosition(a, b) {
+  if (!a || !b) return true;
+  return Math.abs(a.x - b.x) <= 1 && Math.abs(a.y - b.y) <= 1;
+}
+
+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';
 }
@@ -206,4 +436,14 @@ async function stopWindowsNativeHost() {
   await current.stop();
 }
 
-module.exports = { WindowsNativeHost, getWindowsNativeHost, stopWindowsNativeHost };
+module.exports = {
+  WindowsNativeHost,
+  getWindowsNativeHost,
+  stopWindowsNativeHost,
+  isDraggablePoint,
+  normalizeDragRegions,
+  resolveWritableWebViewDataDirectory,
+  isSystemDoubleClick,
+  emitFinalWindowBounds,
+  samePhysicalPosition
+};