@atom-js-org/runtime 0.2.0-alpha.0

package/src/bridge-server.cjs

@@ -0,0 +1,283 @@
+'use strict';
+
+const http = require('node:http');
+const path = require('node:path');
+const fs = require('node:fs');
+const crypto = require('node:crypto');
+const { URL } = require('node:url');
+const { WebSocketServer, WebSocket } = require('ws');
+const state = require('./state.cjs');
+const ipcMain = require('./ipc-main.cjs');
+
+const MIME_TYPES = new Map([
+  ['.html', 'text/html; charset=utf-8'],
+  ['.htm', 'text/html; charset=utf-8'],
+  ['.js', 'text/javascript; charset=utf-8'],
+  ['.mjs', 'text/javascript; charset=utf-8'],
+  ['.cjs', 'text/javascript; charset=utf-8'],
+  ['.css', 'text/css; charset=utf-8'],
+  ['.json', 'application/json; charset=utf-8'],
+  ['.svg', 'image/svg+xml'],
+  ['.png', 'image/png'],
+  ['.jpg', 'image/jpeg'],
+  ['.jpeg', 'image/jpeg'],
+  ['.gif', 'image/gif'],
+  ['.webp', 'image/webp'],
+  ['.ico', 'image/x-icon'],
+  ['.woff', 'font/woff'],
+  ['.woff2', 'font/woff2'],
+  ['.ttf', 'font/ttf'],
+  ['.wasm', 'application/wasm'],
+  ['.txt', 'text/plain; charset=utf-8'],
+  ['.map', 'application/json; charset=utf-8']
+]);
+
+class BridgeServer {
+  constructor() {
+    this.server = null;
+    this.wss = null;
+    this.port = null;
+    this.token = crypto.randomBytes(32).toString('hex');
+    this.sockets = new Map();
+    this.pendingExecutions = new Map();
+  }
+
+  async start() {
+    if (this.server) return;
+
+    this.server = http.createServer((request, response) => {
+      this._handleHttp(request, response).catch((error) => {
+        response.statusCode = 500;
+        response.setHeader('content-type', 'text/plain; charset=utf-8');
+        response.end(`AtomJS bridge error: ${error.message}`);
+      });
+    });
+
+    this.wss = new WebSocketServer({ noServer: true });
+    this.server.on('upgrade', (request, socket, head) => {
+      try {
+        const url = new URL(request.url, 'http://127.0.0.1');
+        const windowId = Number(url.searchParams.get('windowId'));
+        const token = url.searchParams.get('token');
+        if (url.pathname !== '/__atom/ws' || token !== this.token || !state.windows.has(windowId)) {
+          socket.destroy();
+          return;
+        }
+        this.wss.handleUpgrade(request, socket, head, (websocket) => {
+          this.wss.emit('connection', websocket, request, windowId);
+        });
+      } catch {
+        socket.destroy();
+      }
+    });
+
+    this.wss.on('connection', (socket, _request, windowId) => {
+      const previous = this.sockets.get(windowId);
+      if (previous && previous.readyState === WebSocket.OPEN) previous.close();
+      this.sockets.set(windowId, socket);
+
+      socket.on('message', (raw) => {
+        this._handleRendererMessage(windowId, raw).catch((error) => {
+          console.error('[AtomJS bridge message error]', error);
+        });
+      });
+
+      socket.on('close', () => {
+        if (this.sockets.get(windowId) === socket) this.sockets.delete(windowId);
+      });
+    });
+
+    await new Promise((resolve, reject) => {
+      this.server.once('error', reject);
+      this.server.listen(0, '127.0.0.1', () => {
+        this.server.off('error', reject);
+        const address = this.server.address();
+        this.port = address.port;
+        resolve();
+      });
+    });
+  }
+
+  async stop() {
+    for (const socket of this.sockets.values()) {
+      try { socket.close(); } catch {}
+    }
+    this.sockets.clear();
+    if (this.wss) this.wss.close();
+    if (this.server) {
+      await new Promise((resolve) => this.server.close(() => resolve()));
+    }
+    this.server = null;
+    this.wss = null;
+    this.port = null;
+  }
+
+  websocketUrl(windowId) {
+    if (!this.port) throw new Error('AtomJS bridge server is not running');
+    const query = new URLSearchParams({ windowId: String(windowId), token: this.token });
+    return `ws://127.0.0.1:${this.port}/__atom/ws?${query}`;
+  }
+
+  fileUrl(windowId, relativePath) {
+    if (!this.port) throw new Error('AtomJS bridge server is not running');
+    const normalized = String(relativePath).split(path.sep).map(encodeURIComponent).join('/');
+    return `http://127.0.0.1:${this.port}/__atom/window/${windowId}/${normalized}`;
+  }
+
+  send(windowId, message) {
+    const socket = this.sockets.get(windowId);
+    if (!socket || socket.readyState !== WebSocket.OPEN) return false;
+    socket.send(JSON.stringify(message));
+    return true;
+  }
+
+  executeJavaScript(windowId, code, timeoutMs = 30000) {
+    const id = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingExecutions.delete(id);
+        reject(new Error('executeJavaScript timed out'));
+      }, timeoutMs);
+      this.pendingExecutions.set(id, { resolve, reject, timeout });
+      if (!this.send(windowId, { type: 'system', command: 'execute', id, code })) {
+        clearTimeout(timeout);
+        this.pendingExecutions.delete(id);
+        reject(new Error('Renderer is not connected'));
+      }
+    });
+  }
+
+  async _handleRendererMessage(windowId, raw) {
+    const win = state.windows.get(windowId);
+    if (!win) return;
+
+    let message;
+    try {
+      message = JSON.parse(raw.toString('utf8'));
+    } catch {
+      return;
+    }
+
+    if (message.type === 'renderer-ready') {
+      win._markRendererReady(message);
+      return;
+    }
+
+    if (message.type === 'send') {
+      const event = createIpcEvent(win);
+      ipcMain.emit(message.channel, event, ...(Array.isArray(message.args) ? message.args : []));
+      return;
+    }
+
+    if (message.type === 'invoke') {
+      const event = createIpcEvent(win);
+      try {
+        const result = await ipcMain._invoke(message.channel, event, Array.isArray(message.args) ? message.args : []);
+        this.send(windowId, { type: 'invoke-result', id: message.id, ok: true, result });
+      } catch (error) {
+        this.send(windowId, {
+          type: 'invoke-result',
+          id: message.id,
+          ok: false,
+          error: serializeError(error)
+        });
+      }
+      return;
+    }
+
+    if (message.type === 'execute-result') {
+      const pending = this.pendingExecutions.get(message.id);
+      if (!pending) return;
+      this.pendingExecutions.delete(message.id);
+      clearTimeout(pending.timeout);
+      if (message.ok) pending.resolve(message.result);
+      else {
+        const error = new Error(message.error && message.error.message ? message.error.message : 'Renderer execution failed');
+        if (message.error && message.error.stack) error.stack = message.error.stack;
+        pending.reject(error);
+      }
+    }
+  }
+
+  async _handleHttp(request, response) {
+    const url = new URL(request.url, 'http://127.0.0.1');
+
+    if (url.pathname === '/__atom/health') {
+      response.statusCode = 200;
+      response.setHeader('content-type', 'application/json; charset=utf-8');
+      response.end(JSON.stringify({ ok: true, runtime: 'atomjs' }));
+      return;
+    }
+
+    const match = url.pathname.match(/^\/__atom\/window\/(\d+)\/(.*)$/);
+    if (!match) {
+      response.statusCode = 404;
+      response.end('Not found');
+      return;
+    }
+
+    const windowId = Number(match[1]);
+    const win = state.windows.get(windowId);
+    if (!win || !win._contentRoot) {
+      response.statusCode = 404;
+      response.end('Unknown window');
+      return;
+    }
+
+    const requested = decodeURIComponent(match[2] || 'index.html');
+    const root = path.resolve(win._contentRoot);
+    let absolute = path.resolve(root, requested);
+
+    if (absolute !== root && !absolute.startsWith(root + path.sep)) {
+      response.statusCode = 403;
+      response.end('Forbidden');
+      return;
+    }
+
+    let stat;
+    try {
+      stat = await fs.promises.stat(absolute);
+      if (stat.isDirectory()) {
+        absolute = path.join(absolute, 'index.html');
+        stat = await fs.promises.stat(absolute);
+      }
+    } catch {
+      response.statusCode = 404;
+      response.end('File not found');
+      return;
+    }
+
+    if (!stat.isFile()) {
+      response.statusCode = 404;
+      response.end('File not found');
+      return;
+    }
+
+    response.statusCode = 200;
+    response.setHeader('content-type', MIME_TYPES.get(path.extname(absolute).toLowerCase()) || 'application/octet-stream');
+    response.setHeader('content-length', String(stat.size));
+    response.setHeader('cache-control', process.env.ATOM_DEV === '1' ? 'no-store' : 'public, max-age=3600');
+    response.setHeader('x-content-type-options', 'nosniff');
+    fs.createReadStream(absolute).pipe(response);
+  }
+}
+
+function createIpcEvent(win) {
+  return Object.freeze({
+    sender: win.webContents,
+    senderFrame: null,
+    reply(channel, ...args) {
+      win.webContents.send(channel, ...args);
+    }
+  });
+}
+
+function serializeError(error) {
+  return {
+    name: error && error.name ? String(error.name) : 'Error',
+    message: error && error.message ? String(error.message) : String(error),
+    stack: error && error.stack ? String(error.stack) : undefined
+  };
+}
+
+module.exports = { BridgeServer };

package/src/browser-window.cjs

@@ -0,0 +1,411 @@
+'use strict';
+
+const { EventEmitter } = require('node:events');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { spawn } = require('node:child_process');
+const state = require('./state.cjs');
+const app = require('./app.cjs');
+const { WebContents } = require('./web-contents.cjs');
+const { generateBridgeScript } = require('./bridge-script.cjs');
+
+class BrowserWindow extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.id = state.nextWindowId++;
+    this.options = normalizeOptions(options);
+    this.webContents = new WebContents(this);
+    this._child = null;
+    this._destroyed = false;
+    this._rendererReady = false;
+    this._visible = this.options.show;
+    this._contentRoot = null;
+    this._currentUrl = '';
+    this._pendingLoad = null;
+    this._menu = null;
+    this._menuBarVisible = true;
+    this._lastFinishedLoad = null;
+    state.windows.set(this.id, this);
+  }
+
+  loadFile(filePath) {
+    const task = this._loadFile(filePath);
+    // Electron applications commonly call loadFile() without awaiting it. Keep
+    // failures observable to callers while preventing a second, unhandled
+    // rejection from terminating modern Node.js processes.
+    task.catch(() => {});
+    return task;
+  }
+
+  async _loadFile(filePath) {
+    const absolute = path.resolve(state.projectRoot, filePath);
+    const stat = await fs.promises.stat(absolute);
+    if (!stat.isFile()) throw new Error(`BrowserWindow.loadFile expected a file: ${absolute}`);
+    this._contentRoot = path.dirname(absolute);
+    await app.whenReady();
+    const url = state.bridgeServer.fileUrl(this.id, path.basename(absolute));
+    return this._load(url);
+  }
+
+  loadURL(url) {
+    const task = this._loadURL(url);
+    task.catch(() => {});
+    return task;
+  }
+
+  async _loadURL(url) {
+    await app.whenReady();
+    return this._load(String(url));
+  }
+
+  async _load(url) {
+    if (this._destroyed) throw new Error('BrowserWindow has been destroyed');
+    this._currentUrl = url;
+
+    if (this._child) {
+      state.bridgeServer.send(this.id, { type: 'system', command: 'navigate', url });
+      return;
+    }
+
+    const preloadPath = this.options.webPreferences.preload;
+    let preloadCode = '';
+    if (preloadPath) {
+      preloadCode = await fs.promises.readFile(path.resolve(preloadPath), 'utf8');
+    }
+
+    const config = {
+      title: this.options.title || app.getName(),
+      width: this.options.width,
+      height: this.options.height,
+      resizable: this.options.resizable,
+      debug: Boolean(this.options.webPreferences.devTools || process.env.ATOM_DEV === '1'),
+      url,
+      bridgeScript: generateBridgeScript({
+        websocketUrl: state.bridgeServer.websocketUrl(this.id),
+        preloadCode
+      })
+    };
+
+    const configPath = path.join(os.tmpdir(), `atomjs-window-${process.pid}-${this.id}-${Date.now()}.json`);
+    await fs.promises.writeFile(configPath, JSON.stringify(config), { mode: 0o600 });
+
+    const hostPath = path.join(__dirname, 'runtime', 'window-host.mjs');
+    const nodeExecutable = process.env.ATOM_NODE_EXECUTABLE || process.execPath;
+    this._child = spawn(nodeExecutable, [hostPath, configPath], {
+      cwd: state.projectRoot,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'inherit']
+    });
+
+    attachHostOutput(this, this._child);
+
+    this._child.once('error', (error) => {
+      this.emit('unresponsive');
+      this.emit('error', error);
+    });
+
+    this._child.once('exit', (code, signal) => {
+      this._child = null;
+      if (!this._destroyed) {
+        const failedBeforeReady = !this._rendererReady && code !== 0 && signal == null;
+        if (failedBeforeReady) {
+          process.exitCode = code || 1;
+          this.webContents.emit('did-fail-load', {}, code || 1, 'AtomJS window host exited before the renderer became ready', this._currentUrl, true);
+        }
+        this._destroyed = true;
+        state.windows.delete(this.id);
+        this.emit('closed', { code, signal });
+        if (state.windows.size === 0 && !state.isQuitting) app.emit('window-all-closed');
+      }
+    });
+
+    this._pendingLoad = new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        cleanup();
+        reject(new Error('Renderer did not become ready within 20 seconds'));
+      }, 20000);
+      const onReady = () => {
+        cleanup();
+        resolve();
+      };
+      const onClosed = () => {
+        cleanup();
+        reject(new Error('Window closed before the page finished loading'));
+      };
+      const cleanup = () => {
+        clearTimeout(timeout);
+        this.off('ready-to-show', onReady);
+        this.off('closed', onClosed);
+      };
+      this.once('ready-to-show', onReady);
+      this.once('closed', onClosed);
+    });
+
+    // Keep Electron-style fire-and-forget loadFile() usage from producing an
+    // unhandled rejection while still returning the rejecting promise to callers.
+    this._pendingLoad.catch(() => {});
+    return this._pendingLoad;
+  }
+
+  _markRendererReady(details) {
+    this._notifyDidFinishLoad(details && details.href ? details.href : this._currentUrl, 'bridge');
+  }
+
+  _handleHostEvent(event) {
+    if (!event || typeof event !== 'object') return;
+    if (event.type === 'did-start-loading') {
+      if (event.url) this._currentUrl = String(event.url);
+      this.webContents.emit('did-start-loading');
+      return;
+    }
+    if (event.type === 'did-finish-load') {
+      this._notifyDidFinishLoad(event.url || this._currentUrl, 'native');
+      return;
+    }
+    if (event.type === 'did-fail-load') {
+      const description = event.error ? String(event.error) : 'Navigation failed';
+      this.webContents.emit('did-fail-load', {}, -2, description, event.url || this._currentUrl, true);
+      return;
+    }
+    if (event.type === 'page-title-updated' && event.title) {
+      this.options.title = String(event.title);
+      this.emit('page-title-updated', { preventDefault() {} }, this.options.title, false);
+    }
+  }
+
+  _notifyDidFinishLoad(url, source) {
+    const href = url ? String(url) : this._currentUrl;
+    if (href) this._currentUrl = href;
+
+    const now = Date.now();
+    if (this._lastFinishedLoad &&
+        this._lastFinishedLoad.url === this._currentUrl &&
+        this._lastFinishedLoad.source !== source &&
+        now - this._lastFinishedLoad.time < 300) {
+      return;
+    }
+    this._lastFinishedLoad = { url: this._currentUrl, time: now, source };
+
+    const firstLoad = !this._rendererReady;
+    this._rendererReady = true;
+    this.webContents.emit('dom-ready');
+    this.webContents.emit('did-finish-load');
+    this.webContents.emit('did-stop-loading');
+
+    if (firstLoad) {
+      this.emit('ready-to-show');
+      if (this.options.show) this.emit('show');
+    }
+  }
+
+  show() {
+    this._visible = true;
+    this.emit('show');
+  }
+
+  hide() {
+    this._visible = false;
+    console.warn('[AtomJS] Native hide/show is not yet supported by the current pure-JS window host.');
+    this.emit('hide');
+  }
+
+  isVisible() {
+    return this._visible && !this._destroyed;
+  }
+
+  focus() {
+    console.warn('[AtomJS] Native focus is not yet supported by the current window host.');
+  }
+
+  blur() {}
+
+  close() {
+    if (this._destroyed) return;
+    const event = { defaultPrevented: false, preventDefault() { this.defaultPrevented = true; } };
+    this.emit('close', event);
+    if (event.defaultPrevented) return;
+    state.bridgeServer && state.bridgeServer.send(this.id, { type: 'system', command: 'close' });
+    setTimeout(() => {
+      if (!this._destroyed && this._child) this._child.kill();
+    }, 800).unref();
+  }
+
+  destroy() {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    state.windows.delete(this.id);
+    if (this._child) {
+      try { this._child.kill(); } catch {}
+      this._child = null;
+    }
+    this.emit('closed');
+  }
+
+  isDestroyed() {
+    return this._destroyed;
+  }
+
+  setTitle(title) {
+    this.options.title = String(title);
+    if (state.bridgeServer) {
+      state.bridgeServer.send(this.id, { type: 'system', command: 'set-title', title: this.options.title });
+    }
+  }
+
+  getTitle() {
+    return this.options.title || app.getName();
+  }
+
+
+  setMenu(menu) {
+    this._menu = menu || null;
+    return this;
+  }
+
+  getMenu() {
+    return this._menu;
+  }
+
+  removeMenu() {
+    this._menu = null;
+  }
+
+  setMenuBarVisibility(visible) {
+    this._menuBarVisible = Boolean(visible);
+  }
+
+  isMenuBarVisible() {
+    return this._menuBarVisible;
+  }
+
+  autoHideMenuBar() {
+    return false;
+  }
+
+  setAutoHideMenuBar() {}
+
+  isFullScreen() {
+    return false;
+  }
+
+  setFullScreen() {
+    console.warn('[AtomJS] Native fullscreen switching is not implemented yet.');
+  }
+
+  maximize() {
+    console.warn('[AtomJS] Native maximize is not implemented yet.');
+  }
+
+  unmaximize() {}
+
+  isMaximized() {
+    return false;
+  }
+
+  minimize() {
+    console.warn('[AtomJS] Native minimize is not implemented yet.');
+  }
+
+  restore() {}
+
+  isMinimized() {
+    return false;
+  }
+
+  setSize(width, height) {
+    this.options.width = Number(width);
+    this.options.height = Number(height);
+    console.warn('[AtomJS] Changing the native window size after creation is not yet supported.');
+  }
+
+  getSize() {
+    return [this.options.width, this.options.height];
+  }
+
+  setBounds(bounds) {
+    if (bounds.width) this.options.width = Number(bounds.width);
+    if (bounds.height) this.options.height = Number(bounds.height);
+    console.warn('[AtomJS] Changing native bounds after creation is not yet supported.');
+  }
+
+  getBounds() {
+    return { x: 0, y: 0, width: this.options.width, height: this.options.height };
+  }
+
+  reload() {
+    this.webContents.reload();
+  }
+
+  static getAllWindows() {
+    return [...state.windows.values()].filter((win) => !win.isDestroyed());
+  }
+
+  static fromId(id) {
+    return state.windows.get(Number(id)) || null;
+  }
+
+  static getFocusedWindow() {
+    const windows = BrowserWindow.getAllWindows();
+    return windows.length ? windows[windows.length - 1] : null;
+  }
+}
+
+function attachHostOutput(win, child) {
+  if (!child.stdout) return;
+  let pending = '';
+  child.stdout.setEncoding('utf8');
+  child.stdout.on('data', (chunk) => {
+    pending += chunk;
+    let newline;
+    while ((newline = pending.indexOf('\n')) !== -1) {
+      const line = pending.slice(0, newline).replace(/\r$/, '');
+      pending = pending.slice(newline + 1);
+      handleHostLine(win, line);
+    }
+  });
+  child.stdout.on('end', () => {
+    if (pending) handleHostLine(win, pending);
+  });
+}
+
+function handleHostLine(win, line) {
+  const prefix = '__ATOMJS_EVENT__';
+  if (!line.startsWith(prefix)) {
+    if (line) process.stdout.write(line + '\n');
+    return;
+  }
+  try {
+    win._handleHostEvent(JSON.parse(line.slice(prefix.length)));
+  } catch (error) {
+    console.warn('[AtomJS] Invalid window-host event:', error.message);
+  }
+}
+
+function normalizeOptions(options) {
+  return {
+    width: finiteOr(options.width, 800),
+    height: finiteOr(options.height, 600),
+    title: options.title ? String(options.title) : '',
+    show: options.show !== false,
+    resizable: options.resizable !== false,
+    center: options.center !== false,
+    frame: options.frame !== false,
+    backgroundColor: options.backgroundColor || '#ffffff',
+    webPreferences: {
+      preload: options.webPreferences && options.webPreferences.preload
+        ? path.resolve(options.webPreferences.preload)
+        : null,
+      contextIsolation: options.webPreferences ? options.webPreferences.contextIsolation !== false : true,
+      nodeIntegration: false,
+      devTools: options.webPreferences ? options.webPreferences.devTools !== false : true
+    }
+  };
+}
+
+function finiteOr(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.round(number) : fallback;
+}
+
+module.exports = { BrowserWindow };