@atom-js-org/runtime 0.4.2-alpha.0 → 0.4.3-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atom-js-org/runtime",
-  "version": "0.4.2-alpha.0",
+  "version": "0.4.3-alpha.0",
   "description": "Electron-like desktop runtime powered by the operating system WebView.",
   "main": "src/index.cjs",
   "types": "index.d.ts",

package/src/native-host.cjs

@@ -10,7 +10,8 @@ let singleton = null;
 
 class NativeHost {
   constructor(appName) {
-    this.appName = String(appName || 'AtomJS App');
+    this.metadata = resolveMacHostMetadata(appName);
+    this.appName = this.metadata.appName;
     this.child = null;
     this.startPromise = null;
     this.readyResolve = null;
@@ -23,16 +24,23 @@ class NativeHost {
   }
 
   async createWindow(window, config) {
+    const windowId = Number(window.id);
     await this.ensureStarted();
-    this.windows.set(Number(window.id), window);
-    this.send({
-      command: 'create',
-      windowId: Number(window.id),
-      config
-    });
+    this.windows.set(windowId, window);
+
+    try {
+      await this.request({
+        command: 'create',
+        windowId,
+        config
+      }, 15000);
+    } catch (error) {
+      this.windows.delete(windowId);
+      throw error;
+    }
   }
 
-  async request(message) {
+  async request(message, timeoutMs = 30000) {
     await this.ensureStarted();
 
     const requestId = `${process.pid}-${this.nextRequestId++}`;
@@ -40,7 +48,7 @@ class NativeHost {
       const timeout = setTimeout(() => {
         this.pending.delete(requestId);
         reject(new Error(`AtomJS native host request timed out: ${message.command}`));
-      }, 30000);
+      }, timeoutMs);
 
       this.pending.set(requestId, { resolve, reject, timeout });
 
@@ -79,10 +87,15 @@ class NativeHost {
   }
 
   async _start() {
-    const executable = await resolveNativeHostExecutable();
+    const executable = await resolveNativeHostExecutable(this.metadata);
+    const args = [
+      '--app-name', this.metadata.appName,
+      '--app-id', this.metadata.appId
+    ];
+    if (this.metadata.iconPath) args.push('--app-icon', this.metadata.iconPath);
 
     await new Promise((resolve, reject) => {
-      const child = spawn(executable, ['--app-name', this.appName], {
+      const child = spawn(executable, args, {
         cwd: process.env.ATOM_PROJECT_ROOT || process.cwd(),
         env: process.env,
         stdio: ['pipe', 'pipe', 'inherit']
@@ -196,6 +209,17 @@ class NativeHost {
       return;
     }
 
+    if (event.type === 'host-error') {
+      const error = new Error(event.error || 'AtomJS native macOS host reported an error.');
+      for (const pending of this.pending.values()) {
+        clearTimeout(pending.timeout);
+        pending.reject(error);
+      }
+      this.pending.clear();
+      console.error(`[AtomJS] ${error.message}`);
+      return;
+    }
+
     if (event.type === 'response' && event.requestId) {
       const pending = this.pending.get(String(event.requestId));
       if (!pending) return;
@@ -266,7 +290,63 @@ async function stopNativeHost() {
   await host.stop();
 }
 
-async function resolveNativeHostExecutable() {
+function resolveMacHostMetadata(appName) {
+  const projectRoot = path.resolve(process.env.ATOM_PROJECT_ROOT || process.cwd());
+  const packageJson = readJsonIfExists(path.join(projectRoot, 'package.json')) || {};
+  const atomConfig = readJsonIfExists(path.join(projectRoot, 'atom.config.json')) || {};
+
+  const resolvedName = String(
+    process.env.ATOM_APP_NAME ||
+    appName ||
+    atomConfig.productName ||
+    packageJson.productName ||
+    packageJson.name ||
+    'AtomJS App'
+  );
+  const appId = sanitizeBundleIdentifier(
+    process.env.ATOM_APP_ID ||
+    atomConfig.appId ||
+    `com.atomjs.${packageJson.name || resolvedName}`
+  );
+
+  const configuredIcon = process.env.ATOM_APP_ICON || atomConfig.icon || null;
+  const iconPath = configuredIcon
+    ? path.resolve(projectRoot, configuredIcon)
+    : null;
+
+  return {
+    appName: resolvedName,
+    appId,
+    iconPath: iconPath && fs.existsSync(iconPath) ? iconPath : null
+  };
+}
+
+function readJsonIfExists(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function sanitizeBundleIdentifier(value) {
+  const normalized = String(value || 'com.atomjs.app')
+    .toLowerCase()
+    .replace(/[^a-z0-9.-]+/g, '-')
+    .replace(/^[^a-z]+/, '')
+    .replace(/\.{2,}/g, '.')
+    .replace(/^[.-]+|[.-]+$/g, '');
+  return normalized.includes('.') ? normalized : `com.atomjs.${normalized || 'app'}`;
+}
+
+function sanitizeMacExecutableName(value) {
+  return String(value || 'AtomJS App')
+    .replace(/[/:\x00-\x1f]/g, '-')
+    .replace(/\s+/g, ' ')
+    .trim() || 'AtomJS App';
+}
+
+async function resolveNativeHostExecutable(metadata) {
   const bundled = process.env.ATOM_MACOS_HOST_EXECUTABLE;
   if (bundled) {
     const resolved = path.resolve(bundled);
@@ -282,42 +362,84 @@ async function resolveNativeHostExecutable() {
   }
 
   const sourceData = await fs.promises.readFile(source);
-  const hash = crypto
+  const hashBuilder = crypto
     .createHash('sha256')
     .update(sourceData)
     .update(process.arch)
-    .digest('hex')
-    .slice(0, 20);
+    .update(JSON.stringify({ appName: metadata.appName, appId: metadata.appId }));
+  if (metadata.iconPath) hashBuilder.update(await fs.promises.readFile(metadata.iconPath));
+  const hash = hashBuilder.digest('hex').slice(0, 20);
 
+  const executableName = sanitizeMacExecutableName(metadata.appName);
   const outputDirectory = path.join(os.tmpdir(), 'atomjs-native-host', hash);
-  const executable = path.join(outputDirectory, 'AtomJSWindowHost');
+  const appBundle = path.join(outputDirectory, `${executableName}.app`);
+  const executable = path.join(appBundle, 'Contents', 'MacOS', executableName);
   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);
+  const temporaryBundle = `${appBundle}.tmp-${process.pid}-${crypto.randomBytes(4).toString('hex')}`;
+  const contents = path.join(temporaryBundle, 'Contents');
+  const macosDirectory = path.join(contents, 'MacOS');
+  const resourcesDirectory = path.join(contents, 'Resources');
+  const temporaryExecutable = path.join(macosDirectory, executableName);
+
+  await fs.promises.mkdir(macosDirectory, { recursive: true });
+  await fs.promises.mkdir(resourcesDirectory, { recursive: true });
+
   try {
-    await fs.promises.rename(temporary, executable);
-  } catch (error) {
-    if (error.code !== 'EEXIST') throw error;
-    await fs.promises.rm(temporary, { force: true });
+    await runCompiler([
+      'clang',
+      '-fobjc-arc',
+      '-fmodules',
+      '-mmacosx-version-min=12.0',
+      '-framework', 'Cocoa',
+      '-framework', 'WebKit',
+      source,
+      '-o', temporaryExecutable
+    ]);
+    await fs.promises.chmod(temporaryExecutable, 0o755);
+
+    let iconEntry = '';
+    if (metadata.iconPath && path.extname(metadata.iconPath).toLowerCase() === '.icns') {
+      await fs.promises.copyFile(metadata.iconPath, path.join(resourcesDirectory, 'AppIcon.icns'));
+      iconEntry = '<key>CFBundleIconFile</key><string>AppIcon</string>';
+    }
+
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>CFBundleExecutable</key><string>${xmlEscape(executableName)}</string>
+<key>CFBundleIdentifier</key><string>${xmlEscape(metadata.appId)}.dev-host</string>
+<key>CFBundleName</key><string>${xmlEscape(metadata.appName)}</string>
+<key>CFBundleDisplayName</key><string>${xmlEscape(metadata.appName)}</string>
+<key>CFBundlePackageType</key><string>APPL</string>
+<key>LSMinimumSystemVersion</key><string>12.0</string>
+<key>NSHighResolutionCapable</key><true/>
+${iconEntry}
+</dict></plist>`;
+    await fs.promises.writeFile(path.join(contents, 'Info.plist'), plist, 'utf8');
+
+    try {
+      await fs.promises.rename(temporaryBundle, appBundle);
+    } catch (error) {
+      if (error.code !== 'EEXIST' && error.code !== 'ENOTEMPTY') throw error;
+    }
+  } finally {
+    await fs.promises.rm(temporaryBundle, { recursive: true, force: true });
   }
 
   return executable;
 }
 
+function xmlEscape(value) {
+  return String(value)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
 async function runCompiler(args) {
   const xcrun = '/usr/bin/xcrun';
   if (!fs.existsSync(xcrun)) {

package/src/runtime/macos-native-host.m

@@ -1,12 +1,16 @@
 #import <Cocoa/Cocoa.h>
 #import <WebKit/WebKit.h>
 #include <string.h>
+#include <unistd.h>
+#include <errno.h>
 
 static NSString *const AtomJSEventPrefix = @"__ATOMJS_EVENT__";
 
 @class AtomJSWindowController;
 static NSMutableDictionary<NSNumber *, AtomJSWindowController *> *atomWindows;
 static NSString *atomAppName = @"AtomJS App";
+static NSString *atomAppIdentifier = @"com.atomjs.app";
+static NSString *atomAppIconPath = nil;
 
 static void AtomJSEmit(NSDictionary *payload) {
   if (![NSJSONSerialization isValidJSONObject:payload]) return;
@@ -66,6 +70,46 @@ static NSColor *AtomJSColor(NSString *hex) {
   return [NSColor colorWithSRGBRed:red green:green blue:blue alpha:alpha];
 }
 
+static NSImage *AtomJSDefaultApplicationIcon(void) {
+  NSSize size = NSMakeSize(512.0, 512.0);
+  NSImage *image = [[NSImage alloc] initWithSize:size];
+  [image lockFocus];
+
+  NSRect canvas = NSMakeRect(0.0, 0.0, size.width, size.height);
+  NSBezierPath *background = [NSBezierPath bezierPathWithRoundedRect:NSInsetRect(canvas, 18.0, 18.0) xRadius:112.0 yRadius:112.0];
+  [[NSColor colorWithSRGBRed:0.055 green:0.075 blue:0.11 alpha:1.0] setFill];
+  [background fill];
+
+  NSDictionary *letterAttributes = @{
+    NSFontAttributeName: [NSFont systemFontOfSize:252.0 weight:NSFontWeightSemibold],
+    NSForegroundColorAttributeName: [NSColor colorWithSRGBRed:0.42 green:0.78 blue:1.0 alpha:1.0]
+  };
+  NSString *letter = @"A";
+  NSSize letterSize = [letter sizeWithAttributes:letterAttributes];
+  [letter drawAtPoint:NSMakePoint((size.width - letterSize.width) / 2.0, 154.0) withAttributes:letterAttributes];
+
+  NSDictionary *suffixAttributes = @{
+    NSFontAttributeName: [NSFont systemFontOfSize:82.0 weight:NSFontWeightMedium],
+    NSForegroundColorAttributeName: [NSColor whiteColor]
+  };
+  NSString *suffix = @"JS";
+  NSSize suffixSize = [suffix sizeWithAttributes:suffixAttributes];
+  [suffix drawAtPoint:NSMakePoint((size.width - suffixSize.width) / 2.0, 82.0) withAttributes:suffixAttributes];
+
+  [image unlockFocus];
+  return image;
+}
+
+static void AtomJSConfigureApplicationIdentity(NSApplication *application) {
+  [[NSProcessInfo processInfo] setProcessName:atomAppName];
+
+  NSImage *icon = nil;
+  if (atomAppIconPath.length > 0) {
+    icon = [[NSImage alloc] initWithContentsOfFile:atomAppIconPath];
+  }
+  application.applicationIconImage = icon ?: AtomJSDefaultApplicationIcon();
+}
+
 @interface AtomJSWindowController : NSObject <NSWindowDelegate, WKNavigationDelegate>
 @property(nonatomic, strong) NSNumber *windowId;
 @property(nonatomic, strong) NSWindow *window;
@@ -124,7 +168,9 @@ static NSColor *AtomJSColor(NSString *hex) {
   [self navigate:AtomJSString(config[@"url"], @"about:blank")];
 
   if (AtomJSBoolean(config[@"show"], YES)) {
+    [NSApp unhide:nil];
     [_window makeKeyAndOrderFront:nil];
+    [_window orderFrontRegardless];
     [NSApp activateIgnoringOtherApps:YES];
   }
 
@@ -355,10 +401,23 @@ static void AtomJSHandleMessage(NSDictionary *message) {
   if ([command isEqualToString:@"create"]) {
     NSNumber *windowId = AtomJSNumber(message[@"windowId"], nil);
     NSDictionary *config = [message[@"config"] isKindOfClass:[NSDictionary class]] ? message[@"config"] : @{};
-    if (!windowId) return;
+    if (!windowId) {
+      AtomJSRespond(requestId, NO, nil, @"The create command did not include a valid window ID.");
+      return;
+    }
 
     AtomJSWindowController *controller = [[AtomJSWindowController alloc] initWithWindowId:windowId config:config];
+    if (!controller || !controller.window || !controller.webView) {
+      AtomJSRespond(requestId, NO, nil, @"AppKit could not create the AtomJS window.");
+      return;
+    }
+
     atomWindows[windowId] = controller;
+    AtomJSRespond(requestId, YES, @{ @"windowId": windowId }, nil);
+    AtomJSEmit(@{
+      @"type": @"created",
+      @"windowId": windowId
+    });
     return;
   }
 
@@ -391,12 +450,16 @@ static void AtomJSHandleMessage(NSDictionary *message) {
   if ([command isEqualToString:@"navigate"]) {
     [controller navigate:AtomJSString(message[@"url"], @"about:blank")];
   } else if ([command isEqualToString:@"show"]) {
+    [NSApp unhide:nil];
     [controller.window makeKeyAndOrderFront:nil];
+    [controller.window orderFrontRegardless];
     [NSApp activateIgnoringOtherApps:YES];
   } else if ([command isEqualToString:@"hide"]) {
     [controller.window orderOut:nil];
   } else if ([command isEqualToString:@"focus"]) {
+    [NSApp unhide:nil];
     [controller.window makeKeyAndOrderFront:nil];
+    [controller.window orderFrontRegardless];
     [NSApp activateIgnoringOtherApps:YES];
   } else if ([command isEqualToString:@"close"] || [command isEqualToString:@"destroy"]) {
     [controller.window close];
@@ -433,14 +496,22 @@ static void AtomJSHandleMessage(NSDictionary *message) {
 
 static void AtomJSConsumeInput(void) {
   dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
-    NSFileHandle *input = [NSFileHandle fileHandleWithStandardInput];
     NSMutableData *buffer = [NSMutableData data];
 
     while (YES) {
       @autoreleasepool {
-        NSData *chunk = [input readDataOfLength:4096];
-        if (chunk.length == 0) break;
-        [buffer appendData:chunk];
+        unsigned char bytes[4096];
+        ssize_t count = read(STDIN_FILENO, bytes, sizeof(bytes));
+        if (count < 0) {
+          if (errno == EINTR) continue;
+          AtomJSEmit(@{
+            @"type": @"host-error",
+            @"error": [NSString stringWithFormat:@"Could not read native-host input: %s", strerror(errno)]
+          });
+          break;
+        }
+        if (count == 0) break;
+        [buffer appendBytes:bytes length:(NSUInteger)count];
 
         while (YES) {
           const unsigned char *bytes = buffer.bytes;
@@ -492,26 +563,53 @@ static void AtomJSInstallMenu(void) {
   NSApp.mainMenu = mainMenu;
 }
 
+@interface AtomJSApplicationDelegate : NSObject <NSApplicationDelegate>
+@end
+
+@implementation AtomJSApplicationDelegate
+
+- (void)applicationWillFinishLaunching:(NSNotification *)notification {
+  AtomJSConfigureApplicationIdentity(NSApp);
+  AtomJSInstallMenu();
+}
+
+- (void)applicationDidFinishLaunching:(NSNotification *)notification {
+  AtomJSConsumeInput();
+  AtomJSEmit(@{
+    @"type": @"ready",
+    @"pid": @([[NSProcessInfo processInfo] processIdentifier]),
+    @"appName": atomAppName,
+    @"appId": atomAppIdentifier
+  });
+}
+
+- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)sender {
+  return NO;
+}
+
+@end
+
 int main(int argc, const char *argv[]) {
   @autoreleasepool {
     for (int index = 1; index + 1 < argc; index += 1) {
       if (strcmp(argv[index], "--app-name") == 0) {
         atomAppName = [NSString stringWithUTF8String:argv[index + 1]] ?: @"AtomJS App";
         index += 1;
+      } else if (strcmp(argv[index], "--app-id") == 0) {
+        atomAppIdentifier = [NSString stringWithUTF8String:argv[index + 1]] ?: @"com.atomjs.app";
+        index += 1;
+      } else if (strcmp(argv[index], "--app-icon") == 0) {
+        atomAppIconPath = [NSString stringWithUTF8String:argv[index + 1]];
+        index += 1;
       }
     }
 
+    [[NSProcessInfo processInfo] setProcessName:atomAppName];
     atomWindows = [NSMutableDictionary dictionary];
     NSApplication *application = [NSApplication sharedApplication];
+    AtomJSApplicationDelegate *delegate = [[AtomJSApplicationDelegate alloc] init];
+    application.delegate = delegate;
     [application setActivationPolicy:NSApplicationActivationPolicyRegular];
-    AtomJSInstallMenu();
-    AtomJSConsumeInput();
-
-    AtomJSEmit(@{
-      @"type": @"ready",
-      @"pid": @([[NSProcessInfo processInfo] processIdentifier])
-    });
-
     [application run];
   }