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

package/src/native-host.cjs

@@ -0,0 +1,356 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+const { spawn } = require('node:child_process');
+
+let singleton = null;
+
+class NativeHost {
+  constructor(appName) {
+    this.appName = String(appName || 'AtomJS App');
+    this.child = null;
+    this.startPromise = null;
+    this.readyResolve = null;
+    this.readyReject = null;
+    this.pending = new Map();
+    this.windows = new Map();
+    this.stdoutBuffer = '';
+    this.nextRequestId = 1;
+    this.stopping = false;
+  }
+
+  async createWindow(window, config) {
+    await this.ensureStarted();
+    this.windows.set(Number(window.id), window);
+    this.send({
+      command: 'create',
+      windowId: Number(window.id),
+      config
+    });
+  }
+
+  async request(message) {
+    await this.ensureStarted();
+
+    const requestId = `${process.pid}-${this.nextRequestId++}`;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(requestId);
+        reject(new Error(`AtomJS native host request timed out: ${message.command}`));
+      }, 30000);
+
+      this.pending.set(requestId, { resolve, reject, timeout });
+
+      try {
+        this.send({ ...message, requestId });
+      } catch (error) {
+        clearTimeout(timeout);
+        this.pending.delete(requestId);
+        reject(error);
+      }
+    });
+  }
+
+  send(message) {
+    if (!this.child || this.child.killed || !this.child.stdin || this.child.stdin.destroyed) {
+      throw new Error('AtomJS native host is not running.');
+    }
+
+    this.child.stdin.write(`${JSON.stringify(message)}\n`);
+  }
+
+  async ensureStarted() {
+    if (process.platform !== 'darwin') {
+      throw new Error('The shared native host is currently implemented for macOS only.');
+    }
+
+    if (this.child && !this.child.killed) return;
+    if (!this.startPromise) {
+      this.startPromise = this._start().catch((error) => {
+        this.startPromise = null;
+        throw error;
+      });
+    }
+
+    await this.startPromise;
+  }
+
+  async _start() {
+    const executable = await resolveNativeHostExecutable();
+
+    await new Promise((resolve, reject) => {
+      const child = spawn(executable, ['--app-name', this.appName], {
+        cwd: process.env.ATOM_PROJECT_ROOT || process.cwd(),
+        env: process.env,
+        stdio: ['pipe', 'pipe', 'inherit']
+      });
+
+      this.child = child;
+      this.stopping = false;
+      this.stdoutBuffer = '';
+      this.readyResolve = resolve;
+      this.readyReject = reject;
+
+      const startupTimeout = setTimeout(() => {
+        if (this.readyReject) {
+          const rejectReady = this.readyReject;
+          this._clearReadyHandlers();
+          rejectReady(new Error('AtomJS native macOS host did not become ready within 20 seconds.'));
+        }
+        try { child.kill(); } catch {}
+      }, 20000);
+
+      child.stdout.setEncoding('utf8');
+      child.stdout.on('data', (chunk) => this._handleOutput(chunk));
+      child.stdout.on('end', () => {
+        if (this.stdoutBuffer) {
+          this._handleLine(this.stdoutBuffer.replace(/\r$/, ''));
+          this.stdoutBuffer = '';
+        }
+      });
+
+      child.once('error', (error) => {
+        clearTimeout(startupTimeout);
+        if (this.readyReject) {
+          const rejectReady = this.readyReject;
+          this._clearReadyHandlers();
+          rejectReady(error);
+        }
+      });
+
+      child.once('exit', (code, signal) => {
+        clearTimeout(startupTimeout);
+        const wasStopping = this.stopping;
+        this.child = null;
+        this.startPromise = null;
+
+        if (this.readyReject) {
+          const rejectReady = this.readyReject;
+          this._clearReadyHandlers();
+          rejectReady(new Error(`AtomJS native macOS host exited before startup (code ${code}, signal ${signal || 'none'}).`));
+        }
+
+        const error = new Error(`AtomJS native macOS host exited (code ${code}, signal ${signal || 'none'}).`);
+        for (const pending of this.pending.values()) {
+          clearTimeout(pending.timeout);
+          pending.reject(error);
+        }
+        this.pending.clear();
+
+        if (!wasStopping) {
+          for (const window of this.windows.values()) {
+            try {
+              window._handleHostEvent({
+                type: 'did-fail-load',
+                error: error.message,
+                url: window._currentUrl || ''
+              });
+            } catch {}
+          }
+        }
+        this.windows.clear();
+      });
+
+      this._startupTimeout = startupTimeout;
+    });
+  }
+
+  _handleOutput(chunk) {
+    this.stdoutBuffer += chunk;
+
+    let newline;
+    while ((newline = this.stdoutBuffer.indexOf('\n')) !== -1) {
+      const line = this.stdoutBuffer.slice(0, newline).replace(/\r$/, '');
+      this.stdoutBuffer = this.stdoutBuffer.slice(newline + 1);
+      this._handleLine(line);
+    }
+  }
+
+  _handleLine(line) {
+    if (!line) return;
+
+    const prefix = '__ATOMJS_EVENT__';
+    if (!line.startsWith(prefix)) {
+      process.stdout.write(`${line}\n`);
+      return;
+    }
+
+    let event;
+    try {
+      event = JSON.parse(line.slice(prefix.length));
+    } catch (error) {
+      console.warn('[AtomJS] Invalid native-host event:', error.message);
+      return;
+    }
+
+    if (event.type === 'ready') {
+      if (this._startupTimeout) clearTimeout(this._startupTimeout);
+      if (this.readyResolve) {
+        const resolveReady = this.readyResolve;
+        this._clearReadyHandlers();
+        resolveReady();
+      }
+      return;
+    }
+
+    if (event.type === 'response' && event.requestId) {
+      const pending = this.pending.get(String(event.requestId));
+      if (!pending) return;
+
+      this.pending.delete(String(event.requestId));
+      clearTimeout(pending.timeout);
+
+      if (event.ok === false) {
+        pending.reject(new Error(event.error || 'AtomJS native host request failed.'));
+      } else {
+        pending.resolve(event.result);
+      }
+      return;
+    }
+
+    const windowId = Number(event.windowId);
+    if (!Number.isFinite(windowId)) return;
+
+    const window = this.windows.get(windowId);
+    if (!window) return;
+
+    if (event.type === 'closed') this.windows.delete(windowId);
+    window._handleHostEvent(event);
+  }
+
+  _clearReadyHandlers() {
+    this.readyResolve = null;
+    this.readyReject = null;
+    this._startupTimeout = null;
+  }
+
+  async stop() {
+    if (!this.child) return;
+
+    this.stopping = true;
+    const child = this.child;
+
+    const exited = new Promise((resolve) => {
+      child.once('exit', () => resolve());
+    });
+
+    try {
+      this.send({ command: 'quit' });
+    } catch {}
+
+    const timeout = new Promise((resolve) => {
+      setTimeout(() => {
+        if (this.child === child && !child.killed) {
+          try { child.kill('SIGTERM'); } catch {}
+        }
+        resolve();
+      }, 1500).unref();
+    });
+
+    await Promise.race([exited, timeout]);
+  }
+}
+
+function getNativeHost(appName) {
+  if (!singleton) singleton = new NativeHost(appName);
+  return singleton;
+}
+
+async function stopNativeHost() {
+  if (!singleton) return;
+  const host = singleton;
+  singleton = null;
+  await host.stop();
+}
+
+async function resolveNativeHostExecutable() {
+  const bundled = process.env.ATOM_MACOS_HOST_EXECUTABLE;
+  if (bundled) {
+    const resolved = path.resolve(bundled);
+    if (!fs.existsSync(resolved)) {
+      throw new Error(`AtomJS native macOS host executable was not found: ${resolved}`);
+    }
+    return resolved;
+  }
+
+  const source = path.join(__dirname, 'runtime', 'macos-native-host.m');
+  if (!fs.existsSync(source)) {
+    throw new Error(`AtomJS native macOS host source was not found: ${source}`);
+  }
+
+  const sourceData = await fs.promises.readFile(source);
+  const hash = crypto
+    .createHash('sha256')
+    .update(sourceData)
+    .update(process.arch)
+    .digest('hex')
+    .slice(0, 20);
+
+  const outputDirectory = path.join(os.tmpdir(), 'atomjs-native-host', hash);
+  const executable = path.join(outputDirectory, 'AtomJSWindowHost');
+  if (fs.existsSync(executable)) return executable;
+
+  await fs.promises.mkdir(outputDirectory, { recursive: true });
+  const temporary = `${executable}.tmp-${process.pid}`;
+
+  await runCompiler([
+    'clang',
+    '-fobjc-arc',
+    '-fmodules',
+    '-mmacosx-version-min=12.0',
+    '-framework', 'Cocoa',
+    '-framework', 'WebKit',
+    source,
+    '-o', temporary
+  ]);
+
+  await fs.promises.chmod(temporary, 0o755);
+  try {
+    await fs.promises.rename(temporary, executable);
+  } catch (error) {
+    if (error.code !== 'EEXIST') throw error;
+    await fs.promises.rm(temporary, { force: true });
+  }
+
+  return executable;
+}
+
+async function runCompiler(args) {
+  const xcrun = '/usr/bin/xcrun';
+  if (!fs.existsSync(xcrun)) {
+    throw new Error('AtomJS requires the Xcode Command Line Tools. Run `xcode-select --install`.');
+  }
+
+  await new Promise((resolve, reject) => {
+    const child = spawn(xcrun, args, {
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.once('error', reject);
+    child.once('exit', (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+
+      reject(new Error([
+        'AtomJS could not compile the native macOS WKWebView host.',
+        stderr.trim() || stdout.trim() || `xcrun exited with code ${code}`
+      ].join('\n')));
+    });
+  });
+}
+
+module.exports = {
+  getNativeHost,
+  stopNativeHost
+};