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

package/src/ipc-main.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+const { EventEmitter } = require('node:events');
+
+class IpcMain extends EventEmitter {
+  constructor() {
+    super();
+    this.handlers = new Map();
+  }
+
+  handle(channel, listener) {
+    validateChannel(channel);
+    if (typeof listener !== 'function') {
+      throw new TypeError('ipcMain.handle listener must be a function');
+    }
+    if (this.handlers.has(channel)) {
+      throw new Error(`Attempted to register a second handler for '${channel}'`);
+    }
+    this.handlers.set(channel, listener);
+  }
+
+  handleOnce(channel, listener) {
+    validateChannel(channel);
+    const wrapped = async (...args) => {
+      this.removeHandler(channel);
+      return listener(...args);
+    };
+    this.handle(channel, wrapped);
+  }
+
+  removeHandler(channel) {
+    this.handlers.delete(channel);
+  }
+
+  async _invoke(channel, event, args) {
+    const handler = this.handlers.get(channel);
+    if (!handler) {
+      throw new Error(`No ipcMain handler registered for '${channel}'`);
+    }
+    return handler(event, ...args);
+  }
+}
+
+function validateChannel(channel) {
+  if (typeof channel !== 'string' || channel.length === 0) {
+    throw new TypeError('IPC channel must be a non-empty string');
+  }
+}
+
+module.exports = new IpcMain();

package/src/menu.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+class Menu {
+  constructor() {
+    this.items = [];
+  }
+
+  append(item) {
+    this.items.push(item instanceof MenuItem ? item : new MenuItem(item));
+  }
+
+  popup() {
+    console.warn('[AtomJS] Native menus are planned but not implemented in this alpha runtime.');
+  }
+
+  static buildFromTemplate(template) {
+    const menu = new Menu();
+    for (const item of template || []) menu.append(item);
+    return menu;
+  }
+
+  static setApplicationMenu(menu) {
+    Menu.applicationMenu = menu;
+    console.warn('[AtomJS] Application menus are stored for compatibility but are not native yet.');
+  }
+
+  static getApplicationMenu() {
+    return Menu.applicationMenu || null;
+  }
+}
+
+class MenuItem {
+  constructor(options = {}) {
+    Object.assign(this, options);
+    this.label = options.label || '';
+    this.enabled = options.enabled !== false;
+    this.visible = options.visible !== false;
+  }
+}
+
+class Tray {
+  constructor(image) {
+    this.image = image;
+    throw new Error('Tray is not implemented in AtomJS alpha. It requires a native platform adapter.');
+  }
+}
+
+module.exports = { Menu, MenuItem, Tray };

package/src/runtime/macos-window-host.jxa.js

@@ -0,0 +1,147 @@
+ObjC.import('Cocoa');
+ObjC.import('WebKit');
+
+let atomWindow = null;
+let atomWebView = null;
+let atomWindowDelegate = null;
+let atomNavigationDelegate = null;
+
+
+function emitHostEvent(payload) {
+  try {
+    const line = `__ATOMJS_EVENT__${JSON.stringify(payload)}\n`;
+    const data = $(line).dataUsingEncoding($.NSUTF8StringEncoding);
+    $.NSFileHandle.fileHandleWithStandardOutput.writeData(data);
+  } catch (_) {}
+}
+
+function webViewUrl(webView) {
+  try {
+    if (!webView || !webView.URL) return '';
+    return ObjC.unwrap(webView.URL.absoluteString) || '';
+  } catch (_) {
+    return '';
+  }
+}
+
+function createNavigationDelegate() {
+  if (!$.AtomJSNavigationDelegate) {
+    ObjC.registerSubclass({
+      name: 'AtomJSNavigationDelegate',
+      protocols: ['WKNavigationDelegate'],
+      methods: {
+        'webView:didStartProvisionalNavigation:'(webView) {
+          emitHostEvent({ type: 'did-start-loading', url: webViewUrl(webView) });
+        },
+        'webView:didFinishNavigation:'(webView) {
+          emitHostEvent({ type: 'did-finish-load', url: webViewUrl(webView) });
+        },
+        'webView:didFailNavigation:withError:'(webView, _navigation, error) {
+          emitHostEvent({
+            type: 'did-fail-load',
+            url: webViewUrl(webView),
+            error: error ? ObjC.unwrap(error.localizedDescription) : 'Navigation failed'
+          });
+        },
+        'webView:didFailProvisionalNavigation:withError:'(webView, _navigation, error) {
+          emitHostEvent({
+            type: 'did-fail-load',
+            url: webViewUrl(webView),
+            error: error ? ObjC.unwrap(error.localizedDescription) : 'Navigation failed'
+          });
+        }
+      }
+    });
+  }
+  return $.AtomJSNavigationDelegate.alloc.init;
+}
+
+function readUtf8(filePath) {
+  const value = $.NSString.stringWithContentsOfFileEncodingError(
+    $(String(filePath)),
+    $.NSUTF8StringEncoding,
+    null
+  );
+  if (!value) throw new Error(`Unable to read AtomJS window configuration: ${filePath}`);
+  return ObjC.unwrap(value);
+}
+
+function createWindowDelegate() {
+  if (!$.AtomJSWindowDelegate) {
+    ObjC.registerSubclass({
+      name: 'AtomJSWindowDelegate',
+      protocols: ['NSWindowDelegate'],
+      methods: {
+        'windowWillClose:'() {
+          $.NSApplication.sharedApplication.terminate(null);
+        }
+      }
+    });
+  }
+  return $.AtomJSWindowDelegate.alloc.init;
+}
+
+function makeWindow(config) {
+  const width = Math.max(320, Number(config.width) || 800);
+  const height = Math.max(240, Number(config.height) || 600);
+  const rect = $.NSMakeRect(0, 0, width, height);
+
+  let styleMask = $.NSTitledWindowMask |
+    $.NSClosableWindowMask |
+    $.NSMiniaturizableWindowMask;
+  if (config.resizable !== false) styleMask |= $.NSResizableWindowMask;
+
+  const win = $.NSWindow.alloc.initWithContentRectStyleMaskBackingDefer(
+    rect,
+    styleMask,
+    $.NSBackingStoreBuffered,
+    false
+  );
+  win.releasedWhenClosed = false;
+  win.title = $(String(config.title || 'AtomJS App'));
+  win.center;
+
+  const contentController = $.WKUserContentController.alloc.init;
+  const bridgeSource = String(config.bridgeScript || '');
+  if (bridgeSource) {
+    const userScript = $.WKUserScript.alloc.initWithSourceInjectionTimeForMainFrameOnly(
+      $(bridgeSource),
+      $.WKUserScriptInjectionTimeAtDocumentStart,
+      true
+    );
+    contentController.addUserScript(userScript);
+  }
+
+  const webConfiguration = $.WKWebViewConfiguration.alloc.init;
+  webConfiguration.userContentController = contentController;
+
+  const webView = $.WKWebView.alloc.initWithFrameConfiguration(rect, webConfiguration);
+  atomNavigationDelegate = createNavigationDelegate();
+  webView.navigationDelegate = atomNavigationDelegate;
+  webView.autoresizingMask = $.NSViewWidthSizable | $.NSViewHeightSizable;
+
+  const url = $.NSURL.URLWithString($(String(config.url)));
+  if (!url) throw new Error(`Invalid AtomJS URL: ${config.url}`);
+  webView.loadRequest($.NSURLRequest.requestWithURL(url));
+
+  atomWindowDelegate = createWindowDelegate();
+  win.delegate = atomWindowDelegate;
+  win.contentView.addSubview(webView);
+
+  atomWindow = win;
+  atomWebView = webView;
+  return win;
+}
+
+function run(argv) {
+  if (!argv || argv.length < 1) throw new Error('AtomJS macOS host expected a configuration path');
+  const config = JSON.parse(readUtf8(argv[0]));
+  const app = $.NSApplication.sharedApplication;
+  app.setActivationPolicy($.NSApplicationActivationPolicyRegular);
+
+  const win = makeWindow(config);
+  win.makeKeyAndOrderFront(null);
+  app.activateIgnoringOtherApps(true);
+  app.run;
+  return 0;
+}

package/src/runtime/window-host.mjs

@@ -0,0 +1,94 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const configPath = process.argv[2];
+if (!configPath) {
+  console.error('AtomJS window host expected a configuration file');
+  process.exit(1);
+}
+
+let config;
+try {
+  config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+} catch (error) {
+  console.error('Unable to read AtomJS window configuration:', error);
+  process.exit(1);
+}
+
+if (process.platform === 'darwin') {
+  await runMacOSHost(configPath);
+} else {
+  fs.rmSync(configPath, { force: true });
+  await runNativeBindingHost(config);
+}
+
+async function runMacOSHost(configurationPath) {
+  const runtimeDirectory = path.dirname(fileURLToPath(import.meta.url));
+  const helperPath = path.join(runtimeDirectory, 'macos-window-host.jxa.js');
+  const osascript = '/usr/bin/osascript';
+
+  if (!fs.existsSync(osascript)) {
+    console.error('AtomJS could not find /usr/bin/osascript, required for the pure-JavaScript macOS WKWebView host.');
+    fs.rmSync(configurationPath, { force: true });
+    process.exit(1);
+  }
+
+  const child = spawn(osascript, ['-l', 'JavaScript', helperPath, configurationPath], {
+    cwd: process.cwd(),
+    env: process.env,
+    stdio: ['ignore', 'inherit', 'inherit']
+  });
+
+  const forwardSignal = (signal) => {
+    if (!child.killed) child.kill(signal);
+  };
+  process.once('SIGINT', () => forwardSignal('SIGINT'));
+  process.once('SIGTERM', () => forwardSignal('SIGTERM'));
+  process.once('SIGHUP', () => forwardSignal('SIGHUP'));
+
+  await new Promise((resolve) => {
+    child.once('error', (error) => {
+      console.error('AtomJS macOS WKWebView host failed to start:', error && error.stack ? error.stack : error);
+      process.exitCode = 1;
+      resolve();
+    });
+    child.once('exit', (code, signal) => {
+      if (code !== 0 && signal == null) process.exitCode = code || 1;
+      resolve();
+    });
+  });
+
+  fs.rmSync(configurationPath, { force: true });
+}
+
+async function runNativeBindingHost(runtimeConfig) {
+  let Webview;
+  let SizeHint;
+  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('Run `atom doctor`, install the platform prerequisites, then install dependencies again.');
+    console.error(error && error.stack ? error.stack : error);
+    process.exit(1);
+  }
+
+  try {
+    const view = new Webview(Boolean(runtimeConfig.debug));
+    view.title(String(runtimeConfig.title || 'AtomJS App'));
+    view.size(
+      Number(runtimeConfig.width || 800),
+      Number(runtimeConfig.height || 600),
+      runtimeConfig.resizable === false ? SizeHint.Fixed : SizeHint.None
+    );
+    view.init(String(runtimeConfig.bridgeScript || ''));
+    view.navigate(String(runtimeConfig.url));
+    view.show();
+  } catch (error) {
+    console.error('AtomJS native window failed:', error && error.stack ? error.stack : error);
+    process.exit(1);
+  }
+}

package/src/shell.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+const { spawn } = require('node:child_process');
+const { pathToFileURL } = require('node:url');
+
+function openExternal(url) {
+  const target = String(url);
+  return new Promise((resolve, reject) => {
+    let command;
+    let args;
+    if (process.platform === 'win32') {
+      command = 'cmd.exe';
+      args = ['/d', '/s', '/c', 'start', '', target.replace(/&/g, '^&')];
+    } else if (process.platform === 'darwin') {
+      command = 'open';
+      args = [target];
+    } else {
+      command = 'xdg-open';
+      args = [target];
+    }
+    const child = spawn(command, args, { detached: true, stdio: 'ignore' });
+    child.once('error', reject);
+    child.once('spawn', () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+
+function openPath(filePath) {
+  return openExternal(pathToFileURL(String(filePath)).href).then(() => '');
+}
+
+function showItemInFolder(fullPath) {
+  if (process.platform === 'win32') {
+    spawn('explorer.exe', ['/select,', String(fullPath)], { detached: true, stdio: 'ignore' }).unref();
+    return;
+  }
+  openPath(require('node:path').dirname(String(fullPath))).catch(() => {});
+}
+
+module.exports = { openExternal, openPath, showItemInFolder };

package/src/state.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const windows = new Map();
+
+module.exports = {
+  windows,
+  bridgeServer: null,
+  nextWindowId: 1,
+  projectRoot: process.env.ATOM_PROJECT_ROOT || process.cwd(),
+  isQuitting: false
+};

package/src/web-contents.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+const { EventEmitter } = require('node:events');
+const state = require('./state.cjs');
+
+class WebContents extends EventEmitter {
+  constructor(owner) {
+    super();
+    this.owner = owner;
+    this.id = owner.id;
+  }
+
+  send(channel, ...args) {
+    ensureAlive(this.owner);
+    if (typeof channel !== 'string' || channel.length === 0) {
+      throw new TypeError('webContents.send channel must be a non-empty string');
+    }
+    state.bridgeServer.send(this.owner.id, { type: 'event', channel, args });
+  }
+
+  executeJavaScript(code, _userGesture = false) {
+    ensureAlive(this.owner);
+    return state.bridgeServer.executeJavaScript(this.owner.id, String(code));
+  }
+
+  reload() {
+    ensureAlive(this.owner);
+    state.bridgeServer.send(this.owner.id, { type: 'system', command: 'reload' });
+  }
+
+  loadURL(url) {
+    ensureAlive(this.owner);
+    state.bridgeServer.send(this.owner.id, { type: 'system', command: 'navigate', url: String(url) });
+  }
+
+  openDevTools() {
+    console.warn('[AtomJS] DevTools must currently be enabled with webPreferences.devTools before the window starts.');
+  }
+
+  closeDevTools() {}
+
+  isDevToolsOpened() {
+    return false;
+  }
+
+  getURL() {
+    return this.owner._currentUrl || '';
+  }
+
+  isDestroyed() {
+    return this.owner.isDestroyed();
+  }
+}
+
+function ensureAlive(owner) {
+  if (!owner || owner.isDestroyed()) throw new Error('Object has been destroyed');
+}
+
+module.exports = { WebContents };