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

package/LICENSE

@@ -0,0 +1,31 @@
+AtomJS Attribution License 1.0
+
+Copyright (c) 2026 AtomJS contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+1. Framework redistributions, forks, and modified framework distributions must
+   retain this license, the NOTICE file, and a reasonably visible attribution
+   that includes both the name "AtomJS" and the project link:
+   https://github.com/Atom-js-org/atom
+
+2. The attribution requirement applies to distributions of the AtomJS
+   framework itself or a derivative framework. It does not require applications
+   created with AtomJS to display AtomJS branding, notices, splash screens, or
+   user-interface credit.
+
+3. The names and logos of AtomJS may not be used to imply endorsement of a
+   modified distribution without prior permission. Forks may accurately state
+   that they are based on AtomJS.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# @atom-js-org/runtime
+
+The lightweight AtomJS runtime. It uses Node.js for the main process and the operating system WebView for rendering.
+
+AtomJS does not install or execute the Electron runtime and does not bundle a private Chromium copy. On Windows, the system WebView is Microsoft Edge WebView2; on macOS it is WKWebView; on Linux it is WebKitGTK through the current native binding.
+
+Most applications should import the Electron-compatible alias instead:
+
+```bash
+npm install electron@npm:@atom-js-org/electron@alpha
+```
+
+```js
+const { app, BrowserWindow, ipcMain } = require('electron');
+```
+
+Project: https://github.com/Atom-js-org/atom

package/index.d.ts

@@ -0,0 +1,166 @@
+/// <reference types="node" />
+
+import { EventEmitter } from 'node:events';
+
+export interface BrowserWindowConstructorOptions {
+  width?: number;
+  height?: number;
+  title?: string;
+  show?: boolean;
+  resizable?: boolean;
+  center?: boolean;
+  frame?: boolean;
+  backgroundColor?: string;
+  webPreferences?: {
+    preload?: string;
+    contextIsolation?: boolean;
+    nodeIntegration?: boolean;
+    devTools?: boolean;
+  };
+}
+
+export class WebContents extends EventEmitter {
+  readonly id: number;
+  send(channel: string, ...args: unknown[]): void;
+  executeJavaScript(code: string, userGesture?: boolean): Promise<unknown>;
+  reload(): void;
+  loadURL(url: string): void;
+  openDevTools(): void;
+  closeDevTools(): void;
+  isDevToolsOpened(): boolean;
+  getURL(): string;
+  isDestroyed(): boolean;
+}
+
+export class BrowserWindow extends EventEmitter {
+  constructor(options?: BrowserWindowConstructorOptions);
+  readonly id: number;
+  readonly webContents: WebContents;
+  loadFile(filePath: string): Promise<void>;
+  loadURL(url: string): Promise<void>;
+  show(): void;
+  hide(): void;
+  isVisible(): boolean;
+  focus(): void;
+  blur(): void;
+  close(): void;
+  destroy(): void;
+  isDestroyed(): boolean;
+  setTitle(title: string): void;
+  getTitle(): string;
+  setMenu(menu: Menu | null): this;
+  getMenu(): Menu | null;
+  removeMenu(): void;
+  setMenuBarVisibility(visible: boolean): void;
+  isMenuBarVisible(): boolean;
+  setAutoHideMenuBar(hide: boolean): void;
+  isFullScreen(): boolean;
+  setFullScreen(flag: boolean): void;
+  maximize(): void;
+  unmaximize(): void;
+  isMaximized(): boolean;
+  minimize(): void;
+  restore(): void;
+  isMinimized(): boolean;
+  setSize(width: number, height: number): void;
+  getSize(): [number, number];
+  setBounds(bounds: { x?: number; y?: number; width?: number; height?: number }): void;
+  getBounds(): { x: number; y: number; width: number; height: number };
+  reload(): void;
+  static getAllWindows(): BrowserWindow[];
+  static fromId(id: number): BrowserWindow | null;
+  static getFocusedWindow(): BrowserWindow | null;
+}
+
+export const app: EventEmitter & {
+  whenReady(): Promise<typeof app>;
+  isReady(): boolean;
+  quit(): Promise<void>;
+  exit(exitCode?: number): never;
+  getName(): string;
+  setName(name: string): void;
+  getVersion(): string;
+  getAppPath(): string;
+  getPath(name: string): string;
+};
+
+export const ipcMain: EventEmitter & {
+  handle(channel: string, listener: (event: unknown, ...args: unknown[]) => unknown): void;
+  handleOnce(channel: string, listener: (event: unknown, ...args: unknown[]) => unknown): void;
+  removeHandler(channel: string): void;
+};
+
+export const dialog: {
+  showOpenDialog(options?: object): Promise<{ canceled: boolean; filePaths: string[] }>;
+  showSaveDialog(options?: object): Promise<{ canceled: boolean; filePath?: string }>;
+  showMessageBox(options?: object): Promise<{ response: number; checkboxChecked: boolean }>;
+};
+
+export const shell: {
+  openExternal(url: string): Promise<void>;
+  openPath(filePath: string): Promise<string>;
+  showItemInFolder(fullPath: string): void;
+};
+
+export const clipboard: {
+  writeText(text: string): void;
+  readText(): string;
+};
+
+export class Menu {
+  items: MenuItem[];
+  append(item: MenuItem | object): void;
+  popup(): void;
+  static buildFromTemplate(template: object[]): Menu;
+  static setApplicationMenu(menu: Menu | null): void;
+  static getApplicationMenu(): Menu | null;
+}
+
+export class MenuItem {
+  constructor(options?: object);
+}
+
+export class Tray {
+  constructor(image: unknown);
+}
+
+export const nativeTheme: {
+  readonly shouldUseDarkColors: boolean;
+  themeSource: 'system' | 'light' | 'dark';
+};
+
+
+export class Notification extends EventEmitter {
+  constructor(options?: { title?: string; body?: string; [key: string]: unknown });
+  show(): void;
+  close(): void;
+  static isSupported(): boolean;
+}
+
+export const session: any;
+export const protocol: any;
+export const net: any;
+export const screen: any;
+export const webContents: any;
+export const nativeImage: any;
+export const globalShortcut: any;
+export const powerSaveBlocker: any;
+export const powerMonitor: any;
+export const systemPreferences: any;
+export const safeStorage: any;
+export const desktopCapturer: any;
+export const crashReporter: any;
+export const autoUpdater: any;
+export const contentTracing: any;
+export const netLog: any;
+export const utilityProcess: any;
+export const pushNotifications: any;
+export const inAppPurchase: any;
+export class BrowserView extends EventEmitter {}
+export class WebContentsView extends BrowserView {}
+export class BaseWindow extends BrowserWindow {}
+export class View extends EventEmitter {}
+export class ImageView extends View {}
+export class MessageChannelMain { port1: any; port2: any; }
+export const MessagePortMain: any;
+export const TouchBar: any;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@atom-js-org/runtime",
+  "version": "0.2.0-alpha.0",
+  "description": "Electron-like desktop runtime powered by the operating system WebView.",
+  "main": "src/index.cjs",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./src/index.cjs",
+      "default": "./src/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src/",
+    "index.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.12"
+  },
+  "dependencies": {
+    "ws": "^8.21.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Atom-js-org/atom.git",
+    "directory": "packages/atomjs"
+  },
+  "homepage": "https://github.com/Atom-js-org/atom#readme",
+  "bugs": {
+    "url": "https://github.com/Atom-js-org/atom/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  },
+  "license": "LicenseRef-AtomJS-1.0"
+}

package/src/app.cjs

@@ -0,0 +1,111 @@
+'use strict';
+
+const { EventEmitter } = require('node:events');
+const os = require('node:os');
+const path = require('node:path');
+const fs = require('node:fs');
+const state = require('./state.cjs');
+const { BridgeServer } = require('./bridge-server.cjs');
+
+class App extends EventEmitter {
+  constructor() {
+    super();
+    this._readyPromise = null;
+    this._name = readPackageName();
+  }
+
+  whenReady() {
+    if (!this._readyPromise) {
+      this._readyPromise = (async () => {
+        state.bridgeServer = new BridgeServer();
+        await state.bridgeServer.start();
+        queueMicrotask(() => this.emit('ready'));
+        return this;
+      })();
+    }
+    return this._readyPromise;
+  }
+
+  isReady() {
+    return Boolean(this._readyPromise && state.bridgeServer && state.bridgeServer.port);
+  }
+
+  async quit() {
+    if (state.isQuitting) return;
+    state.isQuitting = true;
+    const event = { defaultPrevented: false, preventDefault() { this.defaultPrevented = true; } };
+    this.emit('before-quit', event);
+    if (event.defaultPrevented) {
+      state.isQuitting = false;
+      return;
+    }
+
+    for (const win of [...state.windows.values()]) win.destroy();
+    if (state.bridgeServer) await state.bridgeServer.stop();
+    this.emit('will-quit');
+    this.emit('quit', {}, 0);
+  }
+
+  exit(exitCode = 0) {
+    for (const win of [...state.windows.values()]) win.destroy();
+    process.exit(exitCode);
+  }
+
+  getName() {
+    return this._name;
+  }
+
+  setName(name) {
+    this._name = String(name);
+  }
+
+  getVersion() {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(state.projectRoot, 'package.json'), 'utf8'));
+      return pkg.version || '0.0.0';
+    } catch {
+      return '0.0.0';
+    }
+  }
+
+  getAppPath() {
+    return state.projectRoot;
+  }
+
+  getPath(name) {
+    const home = os.homedir();
+    const appData = process.platform === 'win32'
+      ? (process.env.APPDATA || path.join(home, 'AppData', 'Roaming'))
+      : process.platform === 'darwin'
+        ? path.join(home, 'Library', 'Application Support')
+        : (process.env.XDG_CONFIG_HOME || path.join(home, '.config'));
+
+    const table = {
+      home,
+      appData,
+      userData: path.join(appData, this.getName()),
+      temp: os.tmpdir(),
+      desktop: path.join(home, 'Desktop'),
+      documents: path.join(home, 'Documents'),
+      downloads: path.join(home, 'Downloads'),
+      music: path.join(home, 'Music'),
+      pictures: path.join(home, 'Pictures'),
+      videos: path.join(home, 'Videos'),
+      logs: path.join(appData, this.getName(), 'logs')
+    };
+
+    if (!(name in table)) throw new Error(`Unsupported app path: ${name}`);
+    return table[name];
+  }
+}
+
+function readPackageName() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(state.projectRoot, 'package.json'), 'utf8'));
+    return pkg.productName || pkg.name || 'AtomJS App';
+  } catch {
+    return 'AtomJS App';
+  }
+}
+
+module.exports = new App();

package/src/bridge-script.cjs

@@ -0,0 +1,274 @@
+'use strict';
+
+function generateBridgeScript({ websocketUrl, preloadCode = '' }) {
+  const endpoint = JSON.stringify(websocketUrl);
+  const preload = JSON.stringify(preloadCode);
+
+  return `
+(() => {
+  'use strict';
+
+  const endpoint = ${endpoint};
+  const preloadSource = ${preload};
+  const channelListeners = new Map();
+  const pendingInvocations = new Map();
+  const outboundQueue = [];
+  let sequence = 0;
+  let socket = null;
+
+  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
+    };
+  }
+
+  function sendNow(message) {
+    const payload = JSON.stringify(message);
+    if (socket && socket.readyState === WebSocket.OPEN) {
+      socket.send(payload);
+      return;
+    }
+    outboundQueue.push(payload);
+  }
+
+  function flushQueue() {
+    while (outboundQueue.length && socket && socket.readyState === WebSocket.OPEN) {
+      socket.send(outboundQueue.shift());
+    }
+  }
+
+  function makeEvent(channel) {
+    return Object.freeze({
+      channel,
+      senderId: 'main',
+      reply(replyChannel, ...args) {
+        ipcRenderer.send(replyChannel, ...args);
+      }
+    });
+  }
+
+  function addListener(channel, listener, once) {
+    if (typeof listener !== 'function') {
+      throw new TypeError('IPC listener must be a function');
+    }
+    const bucket = channelListeners.get(channel) || new Set();
+    const record = { listener, once: Boolean(once) };
+    bucket.add(record);
+    channelListeners.set(channel, bucket);
+    return record;
+  }
+
+  function removeListener(channel, listener) {
+    const bucket = channelListeners.get(channel);
+    if (!bucket) return;
+    for (const record of bucket) {
+      if (record.listener === listener) bucket.delete(record);
+    }
+    if (bucket.size === 0) channelListeners.delete(channel);
+  }
+
+  function emitChannel(channel, args) {
+    const bucket = channelListeners.get(channel);
+    if (!bucket) return;
+    for (const record of [...bucket]) {
+      try {
+        record.listener(makeEvent(channel), ...args);
+      } catch (error) {
+        console.error('[AtomJS renderer IPC listener error]', error);
+      }
+      if (record.once) bucket.delete(record);
+    }
+    if (bucket.size === 0) channelListeners.delete(channel);
+  }
+
+  const ipcRenderer = Object.freeze({
+    send(channel, ...args) {
+      sendNow({ type: 'send', channel, args });
+    },
+
+    invoke(channel, ...args) {
+      const id = 'invoke-' + (++sequence);
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          pendingInvocations.delete(id);
+          reject(new Error('IPC invocation timed out: ' + channel));
+        }, 30000);
+        pendingInvocations.set(id, { resolve, reject, timeout });
+        sendNow({ type: 'invoke', id, channel, args });
+      });
+    },
+
+    on(channel, listener) {
+      addListener(channel, listener, false);
+      return this;
+    },
+
+    once(channel, listener) {
+      addListener(channel, listener, true);
+      return this;
+    },
+
+    removeListener(channel, listener) {
+      removeListener(channel, listener);
+      return this;
+    },
+
+    removeAllListeners(channel) {
+      if (channel === undefined) channelListeners.clear();
+      else channelListeners.delete(channel);
+      return this;
+    }
+  });
+
+  const contextBridge = Object.freeze({
+    exposeInMainWorld(key, api) {
+      if (typeof key !== 'string' || key.length === 0) {
+        throw new TypeError('contextBridge key must be a non-empty string');
+      }
+      Object.defineProperty(globalThis, key, {
+        configurable: false,
+        enumerable: true,
+        writable: false,
+        value: api
+      });
+    }
+  });
+
+  const webFrame = Object.freeze({
+    getZoomFactor: () => 1,
+    setZoomFactor: () => {},
+    getZoomLevel: () => 0,
+    setZoomLevel: () => {},
+    insertCSS: async () => '',
+    removeInsertedCSS: async () => {}
+  });
+
+  const atomModule = Object.freeze({ ipcRenderer, contextBridge, webFrame });
+
+  function atomRequire(specifier) {
+    if (specifier === '@atom-js-org/runtime' || specifier === 'atomjs' || specifier === 'atom' ||
+        specifier === 'electron' || specifier === 'electron/renderer' ||
+        specifier === 'electron/common') {
+      return atomModule;
+    }
+    throw new Error(
+      "AtomJS system-WebView preload supports require('electron') for Electron renderer APIs, " +
+      "plus require('@atom-js-org/runtime'), require('atomjs'), and require('atom'). Use ipcRenderer for privileged Node.js work."
+    );
+  }
+
+  async function handleSystemMessage(message) {
+    switch (message.command) {
+      case 'close':
+        window.close();
+        break;
+      case 'reload':
+        location.reload();
+        break;
+      case 'navigate':
+        location.href = String(message.url);
+        break;
+      case 'set-title':
+        document.title = String(message.title || '');
+        break;
+      case 'execute': {
+        try {
+          const result = await (0, eval)(String(message.code));
+          sendNow({ type: 'execute-result', id: message.id, ok: true, result });
+        } catch (error) {
+          sendNow({ type: 'execute-result', id: message.id, ok: false, error: serializeError(error) });
+        }
+        break;
+      }
+      default:
+        console.warn('[AtomJS] Unknown system command:', message.command);
+    }
+  }
+
+  function connect() {
+    socket = new WebSocket(endpoint);
+
+    socket.addEventListener('open', () => {
+      flushQueue();
+      sendNow({ type: 'bridge-open' });
+    });
+
+    socket.addEventListener('message', async (event) => {
+      let message;
+      try {
+        message = JSON.parse(String(event.data));
+      } catch (error) {
+        console.error('[AtomJS] Invalid bridge message', error);
+        return;
+      }
+
+      if (message.type === 'invoke-result') {
+        const pending = pendingInvocations.get(message.id);
+        if (!pending) return;
+        pendingInvocations.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 : 'IPC invocation failed');
+          if (message.error && message.error.stack) error.stack = message.error.stack;
+          pending.reject(error);
+        }
+        return;
+      }
+
+      if (message.type === 'event') {
+        emitChannel(message.channel, Array.isArray(message.args) ? message.args : []);
+        return;
+      }
+
+      if (message.type === 'system') {
+        await handleSystemMessage(message);
+      }
+    });
+
+    socket.addEventListener('close', () => {
+      for (const pending of pendingInvocations.values()) {
+        clearTimeout(pending.timeout);
+        pending.reject(new Error('AtomJS bridge disconnected'));
+      }
+      pendingInvocations.clear();
+    });
+
+    socket.addEventListener('error', (event) => {
+      console.error('[AtomJS] Renderer bridge error', event);
+    });
+  }
+
+  connect();
+
+  try {
+    const module = { exports: {} };
+    const preloadFunction = new Function('require', 'module', 'exports', preloadSource);
+    preloadFunction(atomRequire, module, module.exports);
+  } catch (error) {
+    console.error('[AtomJS preload error]', error);
+  }
+
+  function signalReady() {
+    sendNow({ type: 'renderer-ready', title: document.title, href: location.href });
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', signalReady, { once: true });
+  } else {
+    queueMicrotask(signalReady);
+  }
+
+  Object.defineProperty(globalThis, '__ATOMJS_INTERNAL__', {
+    configurable: false,
+    enumerable: false,
+    writable: false,
+    value: Object.freeze({ ipcRenderer, contextBridge, webFrame })
+  });
+})();
+`;
+}
+
+module.exports = { generateBridgeScript };