lively-electron 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf19bfa8b454abba3dde67bb6e1267bf868fa68439dd167c689c52a51e7c0fd6
-  data.tar.gz: 0ab6ff6ea8a4ccf8d47c4097fa486074c12fc70e7fa343dd1ecee476fdfac2bc
+  metadata.gz: 268db954369a5f37db622d68406bb23be76ba11233dd518ac0cb27015624945f
+  data.tar.gz: 884719a50f2f34b8cdde22b694cdfceb2b206fde2bd478f6dcc1f42a159074e0
 SHA512:
-  metadata.gz: 42b648927ee2f83336fd533b5ffe33de54be204e7f16a8c45e667304045a3605aba110ad3ce1044a9994a9ef6600c54cf0b2e38f6ef368230560343d749d4518
-  data.tar.gz: d3986882840225c81d4e8de8cbe3c7613698567f8534a546d4e94a7fc965c51d5acfefc999f7b5f4ce0e95b3c0209f8ff9a79e1d4ea6010e728029107a8c55e9
+  metadata.gz: a05c6e4d19c06836aba2b030b5bed3fa0294e4eaafeb161c0975784871c447804dbd890b419792f6b1899ab501a2491a8c13d6870ef397c0a4deec2f846c6a45
+  data.tar.gz: f188d608d575029e0894d7d5a70afce1f15d5ea07359069c47b30ffa08ca94533fdf1e92e108b48c4e7702bd7a0a57f84072b71afaf620d46801244280ea1d0e

data/bake/lively/electron/install.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+# Creates +package.json+ in the project root with +pnpm init+ or +npm init+ when it is
+# missing, then runs the appropriate install command for {Lively::Electron::Packager}.
+def install
+	require "console"
+	require "lively/electron/packager"
+	
+	root = context.root
+	package_json_path = File.join(root, "package.json")
+	packager = Lively::Electron::Packager.detect(root, ::ENV)
+	
+	unless File.file?(package_json_path)
+		packager.setup!(root)
+		Console.info(self, "Created", package_json_path, "using", packager)
+	end
+	
+	packager.run_install_in!(root)
+end

data/bin/lively-electron

@@ -8,5 +8,18 @@ if development_mode
 	ENV["CONSOLE_LEVEL"] = "debug"
 end
 
+require_relative "../lib/lively/electron/packager"
+
+# Look for node_modules in the app’s working directory first; the published gem does not
+# ship node_modules, so that is where users install electron. Fall back to the gem’s own
+# directory for development/CI (e.g. pnpm in the repo root while cwd is examples/*).
+project_root = File.expand_path(Dir.pwd)
+gem_root = File.expand_path("..", __dir__)
+packager = Lively::Electron::Packager.detect(project_root, ENV)
+
+electron_path = Lively::Electron::Packager.resolve_electron_executable(
+	packager, [project_root, gem_root], ENV
+)
+
 main_js = File.join(__dir__, "..", "src", "main.js")
-Process.exec("npx", "electron", main_js, *ARGV)
+Process.exec(electron_path, main_js, *ARGV)

data/bin/lively-electron-server

@@ -11,7 +11,7 @@ end
 configuration = Async::Service::Configuration.build do
 	service "lively-electron" do
 		include Lively::Electron::Environment::Application
-	end	
+	end
 end
 
 Async::Service::Controller.run(configuration)

data/context/getting-started.md

@@ -10,10 +10,10 @@ Add the gem to your project:
 $ bundle add lively-electron
 ~~~
 
-Also install the npm package for the Electron wrapper:
+Also install the Node dependencies for the Electron binary (and create `package.json` if it is missing) using the task from the gem:
 
 ~~~ bash
-$ npm install lively-electron
+$ bundle exec bake lively:electron:install
 ~~~
 
 ## Core Concepts

data/lib/lively/electron/environment.rb

@@ -13,23 +13,27 @@ module Lively
 	module Electron
 		# @namespace
 		module Environment
-			# Represents the environment configuration for a Lively Electron application server.
-			# 
-			# This module provides server configuration for Electron apps, using TCP
-			# localhost binding for direct connection from Electron/Chromium.
+			# The Lively environment for a desktop Electron shell that connects to this process over a local HTTP server.
+			# The server uses TCP and may inherit a bound socket passed via `LIVELY_SERVER_DESCRIPTOR`.
 			module Application
 				include Lively::Environment::Application
 				
+				# The base URL the Electron shell uses to reach the Lively server.
+				# Reads `LIVELY_URL` from the environment, or defaults to `http://localhost:0/`.
+				# @returns [String]
 				def url
-					"http://localhost:0/"
+					ENV.fetch("LIVELY_URL", "http://localhost:0/")
 				end
 				
+				# The HTTP endpoint the server listens on.
+				# When `LIVELY_SERVER_DESCRIPTOR` is set, reuses the inherited bound socket instead of binding a new one.
+				# @returns [Async::HTTP::Endpoint]
 				def endpoint
 					if descriptor = ENV["LIVELY_SERVER_DESCRIPTOR"]
 						Console.info(self, "Using inherited file descriptor.", descriptor: descriptor)
 						bound_socket = Socket.for_fd(descriptor.to_i)
 						
-						# Ensure that the socket is non-blocking:
+						# Ensure the inherited socket is non-blocking:
 						bound_socket.nonblock = true
 						
 						endpoint = IO::Endpoint::BoundEndpoint.new(nil, [bound_socket])

data/lib/lively/electron/packager/generic.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "lively"
+
+# @namespace
+module Lively
+	# @namespace
+	module Electron
+		# @namespace
+		module Packager
+			# Raised when {Packager.resolve_electron_executable} cannot produce a usable path from any candidate root, or when a custom {Generic#electron_executable_path} signals failure for every root.
+			class NotFoundError < StandardError; end
+			
+			# A tool-agnostic Node project layout. Both {Npm} and {Pnpm} place CLI shims in `node_modules/.bin` after install. Subclasses implement the concrete {install_command} and {setup!} flows.
+			class Generic
+				# @attribute [String] Semver range for the `electron` dependency written by {setup!}.
+				ELECTRON_VERSION_RANGE = "^41.0.0"
+				
+				# The `argv` for a top-level install with the current packager (e.g. `pnpm install` or `npm install`).
+				# @returns [Array(String)] The program name and arguments, ready for `Process.spawn`.
+				# @raises [NotImplementedError] When the concrete packager has not overridden this method.
+				# @abstract
+				def install_command
+					raise NotImplementedError, "#{self.class} must implement #install_command"
+				end
+				
+				# Runs {install_command} inside `package_root` (e.g. from a bake or CI task).
+				# @parameter package_root [String] The directory passed as `chdir` to the subprocess.
+				# @raises [RuntimeError] If the install command exits with a non-zero status.
+				def run_install_in!(package_root)
+					args = install_command
+					unless system(*args, chdir: File.expand_path(package_root), exception: false)
+						raise "Command failed: #{args.join(" ")} (in #{package_root})"
+					end
+				end
+				
+				# Creates a `package.json` when none exists using the tool's `init` flow, then adds {ELECTRON_VERSION_RANGE} as a dependency.
+				# @parameter package_root [String] The project directory to initialise.
+				# @raises [NotImplementedError] When the concrete packager has not overridden this method.
+				# @abstract
+				def setup!(package_root)
+					raise NotImplementedError, "#{self.class} must implement #setup!"
+				end
+				
+				# Resolves a filesystem path to the `electron` binary. A non-empty `ELECTRON` entry in `environment` wins outright; otherwise looks for an executable `node_modules/.bin/electron` shim under `package_root`.
+				# @parameter package_root [String] A directory that may contain a local `node_modules`.
+				# @parameter environment [Hash] The process environment. Defaults to `::ENV`.
+				# @returns [String] The absolute path to the `electron` binary.
+				# @raises [NotFoundError] If no usable binary is found under `package_root`.
+				def electron_executable_path(package_root, environment = ::ENV)
+					explicit = environment["ELECTRON"]&.to_s
+					if explicit && !explicit.empty?
+						return File.expand_path(explicit)
+					end
+					
+					path = local_electron_path(package_root)
+					return path if File.executable?(path)
+					
+					raise NotFoundError, "Could not find electron in #{package_root}."
+				end
+				
+				# A human-readable suggestion for running the install command in `root`. Useful when `electron` is absent from both `node_modules` and `PATH`.
+				# @parameter root [String] The path shown in the hint.
+				# @returns [String] A one-line string of the form `Run: ... in <absolute_path>`.
+				def install_hint(root)
+					"Run: #{install_command.join(' ')} in #{File.expand_path(root)}"
+				end
+				
+				private
+				
+				# @returns [String] The expanded path to the `node_modules/.bin/electron` shim under `root`.
+				def local_electron_path(root)
+					root = File.expand_path(root)
+					bin = File.join(root, "node_modules", ".bin", "electron")
+					if Gem.win_platform? && !File.exist?(bin)
+						bin = File.join(root, "node_modules", ".bin", "electron.cmd")
+					end
+					File.expand_path(bin)
+				end
+				
+				# Runs a subprocess in `package_root` and raises on failure.
+				# @parameter argv [Array(String)] The program and its arguments.
+				# @parameter package_root [String] Working directory for the command.
+				# @parameter label [String] A short description used in failure messages.
+				# @raises [RuntimeError] If the process exits with a non-zero status.
+				def run_subprocess!(argv, package_root, label)
+					root = File.expand_path(package_root)
+					unless system(*argv, chdir: root, exception: false)
+						raise "Command failed: #{label} – #{argv.join(" ")} (in #{root})"
+					end
+				end
+			end
+		end
+	end
+end

data/lib/lively/electron/packager/npm.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "generic"
+
+# @namespace
+module Lively
+	# @namespace
+	module Electron
+		# @namespace
+		module Packager
+			# An npm (`package-lock.json`) project layout with the corresponding `npm` command line.
+			class Npm < Generic
+				# @returns [String] The user-visible packager name, `"npm"`, used in messages and hints.
+				def to_s = "npm"
+				
+				# @returns [Array(String)] `["npm", "install"]` for a full dependency install.
+				def install_command
+					%w[npm install]
+				end
+				
+				# Creates a `package.json` and installs {ELECTRON_VERSION_RANGE} when no manifest exists yet; see {Generic#setup!}.
+				# @parameter package_root [String] The project directory.
+				# @raises [RuntimeError] If any subprocess step fails.
+				def setup!(package_root)
+					manifest = File.join(File.expand_path(package_root), "package.json")
+					return if File.file?(manifest)
+					
+					run_subprocess!(%w[npm init -y], package_root, "npm init -y")
+					run_subprocess!(
+						[
+							"npm", "install", "--save-prod",
+							"electron@#{ELECTRON_VERSION_RANGE}"
+						],
+						package_root,
+						"npm install electron"
+					)
+				end
+			end
+		end
+	end
+end

data/lib/lively/electron/packager/pnpm.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "json"
+require_relative "generic"
+
+# @namespace
+module Lively
+	# @namespace
+	module Electron
+		# @namespace
+		module Packager
+			# A pnpm (`pnpm-lock.yaml`) project layout with the corresponding `pnpm` command line.
+			class Pnpm < Generic
+				# @returns [String] The user-visible packager name, `"pnpm"`, used in messages and hints.
+				def to_s = "pnpm"
+				
+				# @returns [Array(String)] `["pnpm", "install"]` for a full dependency install.
+				def install_command
+					%w[pnpm install]
+				end
+				
+				# Creates a `package.json` and installs {ELECTRON_VERSION_RANGE} when no manifest exists yet; see {Generic#setup!}. Also writes the `onlyBuiltDependencies` policy required by pnpm 10+.
+				# @parameter package_root [String] The project directory.
+				# @raises [RuntimeError] If any subprocess step fails.
+				def setup!(package_root)
+					manifest = File.join(File.expand_path(package_root), "package.json")
+					return if File.file?(manifest)
+					
+					# pnpm 10 requires --bare and --init-package-manager (see `pnpm help init`):
+					run_subprocess!(%w[pnpm init --bare --init-package-manager], package_root, "pnpm init")
+					run_subprocess!(
+						[
+							"pnpm", "add",
+							"electron@#{ELECTRON_VERSION_RANGE}"
+						],
+						package_root,
+						"pnpm add electron"
+					)
+					merge_electron_postinstall_policy!(package_root)
+				end
+				
+				private
+				
+				# Ensures `electron` is listed under `pnpm.onlyBuiltDependencies` in `package.json`. Without this entry, pnpm 10+ blocks `electron`'s `postinstall` script.
+				# @parameter package_root [String] The project directory containing `package.json`.
+				def merge_electron_postinstall_policy!(package_root)
+					path = File.join(File.expand_path(package_root), "package.json")
+					data = JSON.parse(File.read(path, encoding: Encoding::UTF_8))
+					pnode = data["pnpm"] || {}
+					list = pnode["onlyBuiltDependencies"] || []
+					pnode["onlyBuiltDependencies"] = (["electron"] + Array(list)).uniq
+					data["pnpm"] = pnode
+					File.write(path, JSON.pretty_generate(data) + "\n")
+				end
+			end
+		end
+	end
+end

data/lib/lively/electron/packager.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "json"
+
+require_relative "packager/generic"
+require_relative "packager/npm"
+require_relative "packager/pnpm"
+
+# @namespace
+module Lively
+	# @namespace
+	module Electron
+		# Detects the Node packager in use (npm or pnpm) and resolves the `electron` binary path. Both tools place CLI shims in `node_modules/.bin` after install; see {Generic#electron_executable_path}.
+		module Packager
+			# @attribute [String] Environment variable for explicitly selecting `npm` or `pnpm`.
+			ENV_KEY = "LIVELY_ELECTRON_PACKAGER"
+			
+			class << self
+				# Picks a packager for a project root.
+				#
+				# Resolution order:
+				# 1. `LIVELY_ELECTRON_PACKAGER` env var with value `npm` or `pnpm` (case-insensitive);
+				# 2. `package.json` `packageManager` field (e.g. `pnpm@10.0.0` or `npm@10.0.0`);
+				# 3. a lone lock file (`pnpm-lock.yaml` or `package-lock.json`);
+				# 4. if both lock files are present, `pnpm` (matches this gem's default);
+				# 5. if there is no clear signal, `pnpm`.
+				#
+				# @parameter package_root [String] The directory to search for `package.json` and lock files.
+				# @parameter environment [Hash] The process environment. Defaults to `::ENV`.
+				# @returns [Lively::Electron::Packager::Npm | Lively::Electron::Packager::Pnpm] A concrete {Npm} or {Pnpm} instance.
+				# @raises [ArgumentError] If `LIVELY_ELECTRON_PACKAGER` is set to something other than `npm` or `pnpm`.
+				def detect(package_root, environment = ::ENV)
+					root = File.expand_path(package_root)
+					
+					if (resolved = from_environment(environment[ENV_KEY]))
+						return resolved
+					end
+					
+					if (resolved = from_package_json(root))
+						return resolved
+					end
+					
+					has_pnpm = File.file?(File.join(root, "pnpm-lock.yaml"))
+					has_npm = File.file?(File.join(root, "package-lock.json"))
+					
+					if has_pnpm && has_npm
+						return Pnpm.new
+					elsif has_pnpm
+						return Pnpm.new
+					elsif has_npm
+						return Npm.new
+					else
+						return Pnpm.new
+					end
+				end
+				
+				# Calls {Generic#electron_executable_path} for each of `search_roots` in order (e.g. the app's working directory, then the gem root in development). The first concrete path wins. If no root yields a local binary, falls back to the bare program name `"electron"` for the OS to find on `PATH`.
+				# @parameter packager [Lively::Electron::Packager::Generic] A concrete {Npm} or {Pnpm} instance.
+				# @parameter search_roots [Array(String)] Candidate directories; first match wins.
+				# @parameter environment [Hash] The process environment. Defaults to `::ENV`.
+				# @returns [String] An absolute path, or `"electron"` to resolve via `PATH`.
+				def resolve_electron_executable(packager, search_roots, environment = ::ENV)
+					search_roots
+						.compact
+						.map {|path| File.expand_path(path)}
+						.uniq
+						.each do |search_root|
+							begin
+								return packager.electron_executable_path(search_root, environment)
+							rescue NotFoundError
+								next
+							end
+						end
+					
+					# No local binary found in any root; rely on the OS to find `electron` on PATH:
+					"electron"
+				end
+				
+				private
+				
+				def from_environment(value)
+					value = value&.to_s&.strip
+					return nil if value.nil? || value.empty?
+					
+					case value.downcase
+					when "npm" then Npm.new
+					when "pnpm" then Pnpm.new
+					else
+						raise ArgumentError, "Invalid #{ENV_KEY} #{value.inspect} (use 'npm' or 'pnpm')."
+					end
+				end
+				
+				def from_package_json(root)
+					package_json = read_package_json(root) or return nil
+					package_manager = package_json["packageManager"].to_s
+					return Pnpm.new if package_manager.start_with?("pnpm@")
+					return Npm.new if package_manager.start_with?("npm@")
+					
+					nil
+				end
+				
+				def read_package_json(root)
+					path = File.join(root, "package.json")
+					return nil unless File.readable?(path)
+					
+					::JSON.parse(File.read(path, encoding: Encoding::UTF_8))
+				rescue ::JSON::ParserError
+					nil
+				end
+			end
+		end
+	end
+end

data/lib/lively/electron/version.rb

@@ -7,7 +7,8 @@
 module Lively
 	# @namespace
 	module Electron
-		VERSION = "0.1.1"
+		# @attribute [String] The published SemVer of this gem.
+		VERSION = "0.2.0"
 	end
 end
 

data/lib/lively/electron.rb

@@ -4,5 +4,7 @@
 # Copyright, 2025, by Samuel Williams.
 
 require "lively"
+
 require_relative "electron/version"
 require_relative "electron/environment"
+require_relative "electron/packager"

data/readme.md

@@ -14,6 +14,11 @@ Please see the [project documentation](https://github.com/socketry/lively-electr
 
 Please see the [project releases](https://github.com/socketry/lively-electron/releases/index) for all releases.
 
+### v0.2.0
+
+  - Add support for `pnpm` as well as `npm`.
+  - Add `bake lively:electron:install` that installs electron locally.
+
 ### v0.1.0
 
   - Initial implementation.

data/releases.md

@@ -1,5 +1,10 @@
 # Releases
 
+## v0.2.0
+
+  - Add support for `pnpm` as well as `npm`.
+  - Add `bake lively:electron:install` that installs electron locally.
+
 ## v0.1.0
 
   - Initial implementation.

data/src/main.js

@@ -1,155 +1,155 @@
 const {app, BrowserWindow, ipcMain} = require('electron');
-const {spawn} = require('child_process');
+const {spawn, spawnSync} = require('child_process');
 const http = require('http');
 const net = require('net');
 const path = require('path');
 const fs = require('fs');
 
 class LivelyElectronApp {
-  constructor() {
-    this.rubyProcess = null;
-    this.mainWindow = null;
-    this.serverUrl = null;
-    
-    // Store the working directory (should be preserved by direct CLI)
-    this.originalCwd = process.cwd();
-    console.log('💾 Working directory:', this.originalCwd);
-  }
-
-  isDevelopment() {
-    const variant = process.env.LIVELY_VARIANT || process.env.VARIANT;
-    return variant === "development";
-  }
-
-  async start() {
-    try {
-      // 1. Start Ruby Lively server on TCP localhost
-      await this.startLivelyServer();
-      
-      // 2. Create Electron window (connects directly to Ruby server)
-      await this.createWindow();
-      
-      console.log(`Lively Electron started - Ruby server: ${this.serverUrl}`);
-    } catch (error) {
-      console.error('Failed to start Lively Electron:', error);
-      app.quit();
-    }
-  }
-
-  async startLivelyServer() {
-    return new Promise((resolve, reject) => {
-      // Forward all CLI args to the Ruby server; let the Ruby script decide the application file
-      const args = process.argv.slice(2);
-      
-      // Create server and let it bind+listen, then pass handle to child
-      const server = net.createServer();
-      server.listen(0, '127.0.0.1', () => {
-        const port = server.address().port;
-        this.serverUrl = `http://localhost:${port}`;
-        
-        const fd = server._handle.fd;
-
-        // Start Ruby process with FD passed via stdio and forward all CLI args
-        const livelyElectronScript = path.join(__dirname, '..', 'bin', 'lively-electron-server');
-        const childArgs = args.slice();
-
-        const child = spawn(livelyElectronScript, childArgs, {
-          stdio: [
-            'inherit',  // stdin
-            'inherit',  // stdout
-            'inherit',  // stderr
-            fd          // Pass socket FD as stdio[3]
-          ],
-          env: { 
-            ...process.env, 
-            LIVELY_SERVER_DESCRIPTOR: '3'  // Tell child it's on FD 3
-          }
-        });
-
-        child.on('spawn', () => {
-          this.rubyProcess = child;
-          server.close((error) => {
-            if (error) {
-              reject(error);
-            } else {
-              console.log(`✅ Ruby server should be ready: ${this.serverUrl}`);
-              resolve();
-            }
-          });
-        });
-
-        child.on('error', (error) => {
-          server.close();
-          console.error('Failed to spawn Ruby process:', error);
-          reject(error);
-        });
-
-        child.on('close', (code) => {
-          this.rubyProcess = null;
-          console.log(`Ruby process exited with code ${code}`);
-          if (code !== 0) {
-            reject(new Error(`Ruby process failed with code ${code}`));
-          }
-        });
-      });
-    });
-  }
-
-  async createWindow() {
-    this.mainWindow = new BrowserWindow({
-      width: 1200,
-      height: 800,
-      webPreferences: {
-        nodeIntegration: false,
-        contextIsolation: true,
-        enableRemoteModule: false
-      },
-      titleBarStyle: 'hiddenInset'
-    });
-
-    // Load the Lively app directly
-    await this.mainWindow.loadURL(this.serverUrl);
-
-    // Open DevTools in development mode
-    if (this.isDevelopment()) {
-      this.mainWindow.webContents.openDevTools();
-    }
-
-    this.mainWindow.on('closed', () => {
-      this.cleanup();
-    });
-  }
-
-  cleanup() {
-    if (this.rubyProcess) {
-      this.rubyProcess.kill();
-    }
-  }
+	constructor() {
+		this.rubyProcess = null;
+		this.mainWindow = null;
+		this.serverUrl = null;
+		
+		// Store the working directory (should be preserved by direct CLI)
+		this.originalCwd = process.cwd();
+		console.log('💾 Working directory:', this.originalCwd);
+	}
+	
+	isDevelopment() {
+		const variant = process.env.LIVELY_VARIANT || process.env.VARIANT;
+		return variant === "development";
+	}
+	
+	async start() {
+		try {
+			// 1. Start Ruby Lively server on TCP localhost
+			await this.startLivelyServer();
+			
+			// 2. Create Electron window (connects directly to Ruby server)
+			await this.createWindow();
+			
+			console.log(`Lively Electron started - Ruby server: ${this.serverUrl}`);
+		} catch (error) {
+			console.error('Failed to start Lively Electron:', error);
+			app.quit();
+		}
+	}
+	
+	async startLivelyServer() {
+		return new Promise((resolve, reject) => {
+			// Forward all CLI args to the Ruby server; let the Ruby script decide the application file
+			const args = process.argv.slice(2);
+			
+			// Create server and let it bind+listen, then pass handle to child
+			const server = net.createServer();
+			server.listen(0, '127.0.0.1', () => {
+				const port = server.address().port;
+				this.serverUrl = `http://localhost:${port}`;
+				
+				const fd = server._handle.fd;
+				
+				// Start Ruby process with FD passed via stdio and forward all CLI args
+				const livelyElectronScript = path.join(__dirname, '..', 'bin', 'lively-electron-server');
+				const childArgs = args.slice();
+				
+				const child = spawn(livelyElectronScript, childArgs, {
+					stdio: [
+						'inherit',  // stdin
+						'inherit',  // stdout
+						'inherit',  // stderr
+						fd          // Pass socket FD as stdio[3]
+					],
+					env: { 
+						...process.env, 
+						LIVELY_SERVER_DESCRIPTOR: '3'  // Tell child it's on FD 3
+					}
+				});
+				
+				child.on('spawn', () => {
+					this.rubyProcess = child;
+					server.close((error) => {
+						if (error) {
+							reject(error);
+						} else {
+							console.log(`✅ Ruby server should be ready: ${this.serverUrl}`);
+							resolve();
+						}
+					});
+				});
+				
+				child.on('error', (error) => {
+					server.close();
+					console.error('Failed to spawn Ruby process:', error);
+					reject(error);
+				});
+				
+				child.on('close', (code) => {
+					this.rubyProcess = null;
+					console.log(`Ruby process exited with code ${code}`);
+					if (code !== 0) {
+						reject(new Error(`Ruby process failed with code ${code}`));
+					}
+				});
+			});
+		});
+	}
+	
+	async createWindow() {
+		this.mainWindow = new BrowserWindow({
+			width: 1200,
+			height: 800,
+			webPreferences: {
+				nodeIntegration: false,
+				contextIsolation: true,
+				enableRemoteModule: false
+			},
+			titleBarStyle: 'hiddenInset'
+		});
+		
+		// Load the Lively app directly
+		await this.mainWindow.loadURL(this.serverUrl);
+		
+		// Open DevTools in development mode
+		if (this.isDevelopment()) {
+			this.mainWindow.webContents.openDevTools();
+		}
+		
+		this.mainWindow.on('closed', () => {
+			this.cleanup();
+		});
+	}
+	
+	cleanup() {
+		if (this.rubyProcess) {
+			this.rubyProcess.kill();
+		}
+	}
 }
 
 // Electron app lifecycle
 app.whenReady().then(() => {
-  console.log('Electron ready, starting Lively app...');
-  const livelyApp = new LivelyElectronApp();
-  livelyApp.start().catch(error => {
-    console.error('Failed to start Lively app:', error);
-    app.quit();
-  });
+	console.log('Electron ready, starting Lively app...');
+	const livelyApp = new LivelyElectronApp();
+	livelyApp.start().catch(error => {
+		console.error('Failed to start Lively app:', error);
+		app.quit();
+	});
 });
 
 app.on('window-all-closed', () => {
-  if (process.platform !== 'darwin') {
-    app.quit();
-  }
+	if (process.platform !== 'darwin') {
+		app.quit();
+	}
 });
 
 app.on('activate', () => {
-  if (BrowserWindow.getAllWindows().length === 0) {
-    const livelyApp = new LivelyElectronApp();
-    livelyApp.start();
-  }
+	if (BrowserWindow.getAllWindows().length === 0) {
+		const livelyApp = new LivelyElectronApp();
+		livelyApp.start();
+	}
 });
 
 app.on('before-quit', () => {
-  // Cleanup will be handled by window close event
+	// Cleanup will be handled by window close event
 });

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lively-electron
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -100,12 +100,17 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- bake/lively/electron/install.rb
 - bin/lively-electron
 - bin/lively-electron-server
 - context/getting-started.md
 - context/index.yaml
 - lib/lively/electron.rb
 - lib/lively/electron/environment.rb
+- lib/lively/electron/packager.rb
+- lib/lively/electron/packager/generic.rb
+- lib/lively/electron/packager/npm.rb
+- lib/lively/electron/packager/pnpm.rb
 - lib/lively/electron/version.rb
 - license.md
 - readme.md
@@ -132,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Electron wrapper for Lively Ruby applications
 test_files: []