positron.js 1.0.6 → 1.1.0

package/README.md

@@ -34,6 +34,8 @@ Positron is built as a lightweight, secure alternative to Electron. Below is a d
 - Node.js (v16+)
 - macOS: Xcode Command Line Tools (swiftc)
 - Windows: .NET SDK (CLI tools capable of executing `dotnet publish`)
+- C++ compiler (G++ is the default), GTK+ 3 and WebKit2GTK on Linux
+  - Docker if building for Linux on macOS or Windows
 
 ## Install
 ```bash
@@ -76,7 +78,8 @@ To create a native extension, provide a custom positron property block within yo
     "command": "toast:show",
     "platforms": {
       "darwin": "src/mac/ToastPlugin.swift",
-      "win32": "src/win/ToastPlugin.cs"
+      "win32": "src/win/ToastPlugin.cs",
+      "linux":"src/linux/ToastPlugin.cpp"
     }
   }
 }
@@ -112,10 +115,10 @@ npx positron run
 ### Packaging
 This will rebuild the binary, then create a deployable version of the app
 ```bash
-npx positron package [--m | --w] [--arm64 || --x64]
+npx positron package [--m | --w || --l] [--arm64 || --x64]
 ```
 
-> Note: Windows supports either arm64 or x64, while macOS only supports arm64 on Apple Silicon.
+> Note: Windows & Linux support either arm64 or x64, while macOS only supports arm64.
 
 ## IPC Protocol Specification
 Communication relies on structured JSON communication frames routed through the IPC WebSocket server.
@@ -143,12 +146,8 @@ Communication relies on structured JSON communication frames routed through the
 }
 ```
 
-## Environment Flags
-- POSITRON_PACKAGED: Set to "true" inside production bundles to suppress localized development shell background re-compilation triggers.
-- POSITRON_IPC_PORT: The port that the IPC server runs on.
-
 ## License
 MIT
 
 ## Documentation
-Read docs [here](https://positronjs.gitbook.io/v1)
+[Read here](https://positronjs.gitbook.io/v1)

package/builder.js

@@ -11,11 +11,13 @@ function performNativeBuild() {
 
   let buildingForWindows = process.argv.includes("--windows") || process.argv.includes("--w");
   let buildingForMac = process.argv.includes("--mac") || process.argv.includes("--m");
+  let buildingForLinux = process.argv.includes("--linux") || process.argv.includes("--l");
 
 
   const appRoot = process.cwd(); // The developer's project folder
   const nativeExtensionsMac = [];
   const nativeExtensionsWindows = [];
+  const nativeExtensionsLinux = [];
   
   // 1. Discover Extensions from the developer's package.json
   const rootPackagePath = path.join(appRoot, "package.json");
@@ -50,6 +52,7 @@ function performNativeBuild() {
           else {
             if(!depPackage.positron.platforms.darwin) missing.push("platforms.darwin");
             if(!depPackage.positron.platforms.win32) missing.push("platforms.win32");
+            if(!depPackage.positron.platforms.linux) missing.push("platforms.linux");
           }
           
           if(missing.includes("className") || missing.includes("command") || missing.includes("platforms")) {
@@ -75,15 +78,26 @@ function performNativeBuild() {
       } else {
         warn(`[Builder] Dependency "${dep}" is missing a Windows platform source file. Skipping Windows native extension build for this dependency.`);
       }
+      if(!missing.includes("platforms.linux")) {
+        nativeExtensionsLinux.push({
+          className: depPackage.positron.className, 
+          command: depPackage.positron.command,
+          sourceFile: path.join(depDir, depPackage.positron.platforms.linux)
+        });
+      } else {
+        warn(`[Builder] Dependency "${dep}" is missing a Linux platform source file. Skipping Linux native extension build for this dependency.`);
+      }
       }
     }
   }
 
-  if(buildingForWindows == false && buildingForMac == false) {
+  if(buildingForWindows == false && buildingForMac == false && buildingForLinux == false) {
     if (process.platform === "win32") {
       buildingForWindows = true;
     } else if (process.platform === "darwin") {
       buildingForMac = true;
+    } else if (process.platform === "linux") {
+      buildingForLinux = true;
     } else {
       error("[Builder] Unsupported platform for native build.");
       return false;
@@ -245,6 +259,19 @@ function performNativeBuild() {
         dotnetArgs.push(`/p:ApplicationIcon=${iconPath}`);
       }
 
+      // Add package.json metadata to Windows executable
+      const appName = rootPackage.productName || rootPackage.name || "PositronApp";
+      const version = rootPackage.version || "1.0.0";
+      const author = rootPackage.author || "Positron";
+      const bundleId = rootPackage.bundleIdentifier || `com.${author.toLowerCase().replace(/[^a-z0-9]/g, '')}.${appName.toLowerCase().replace(/[^a-z0-9]/g, '')}`;
+      const winCategory = rootPackage.winCategory || rootPackage.macCategory || "An application built with Positron.js";
+
+      dotnetArgs.push(`/p:Version=${version}`);
+      dotnetArgs.push(`/p:Authors=${author}`);
+      dotnetArgs.push(`/p:Company=${author}`);
+      dotnetArgs.push(`/p:Product=${bundleId}`);
+      dotnetArgs.push(`/p:Description=${winCategory}`);
+
       cp.execFileSync("dotnet", dotnetArgs, { stdio: "inherit" });
       success("[Builder] Windows native compilation successful.");
       return true;
@@ -254,6 +281,126 @@ function performNativeBuild() {
     }
   }
   
+  if (buildingForLinux) {
+    info(`[Builder] Stitching ${nativeExtensionsLinux.length} native Linux extensions...`);
+    
+    const coreLinuxDir = path.join(__dirname, "core", "linux");
+    
+    let registryContent = `// Auto-generated by Positron. Do not edit.\n`;
+    registryContent += `#include <string>\n#include <unordered_map>\n#include <vector>\n\n`;
+    registryContent += `using namespace std;\n\n`;
+    
+    nativeExtensionsLinux.forEach((ext, index) => {
+        registryContent += `void handle_${ext.className}(int windowId, vector<string> args);\n`;
+    });
+    
+    registryContent += `\nunordered_map<string, void(*)(int, vector<string>)> getExtensionRegistry() {\n`;
+    registryContent += `    return {\n`;
+    
+    nativeExtensionsLinux.forEach((ext, index) => {
+        const comma = index === nativeExtensionsLinux.length - 1 ? "" : ",";
+        registryContent += `        {"${ext.command}", handle_${ext.className}}${comma}\n`;
+    });
+    
+    registryContent += `    };\n}\n`;
+    
+    fs.writeFileSync(path.join(coreLinuxDir, "Registry.cpp"), registryContent);
+
+    if (process.platform !== "linux") {
+      info("[Builder] Cross-compiling for Linux using Docker...");
+      try {
+        const dockerVer = cp.spawnSync("docker", ["--version"], { stdio: "ignore" });
+        if (dockerVer.error || dockerVer.status !== 0) throw new Error("Docker is not available");
+      } catch (e) {
+        error("[Builder] Fatal: Docker is required to cross-compile for Linux on macOS/Windows.");
+        process.exit(1);
+      }
+
+      const dockerArch = arch === "arm64" ? "linux/arm64" : "linux/amd64";
+      const dockerTag = `positron-linux-builder-${arch}`;
+      const dockerfileContent = [
+        "FROM ubuntu:latest",
+        "ENV DEBIAN_FRONTEND=noninteractive",
+        "RUN apt-get update && apt-get install -y "+
+          "g++ pkg-config "+
+          "libgtk-3-dev libwebkit2gtk-4.1-dev libjson-glib-dev "+
+          "libsoup2.4-dev libnotify-dev",
+        "WORKDIR /app"
+      ].join("\n");
+      
+      fs.writeFileSync(path.join(coreLinuxDir, "Dockerfile.linux"), dockerfileContent);
+      info(`[Builder] Building Docker image for ${dockerArch}...`);
+      
+      try {
+        const buildRes = cp.spawnSync("docker", ["build", "--platform", dockerArch, "-t", dockerTag, "-f", path.join(coreLinuxDir, "Dockerfile.linux"), coreLinuxDir], { stdio: "inherit" });
+        if (buildRes.error) throw buildRes.error;
+        if (buildRes.status !== 0) throw new Error("Docker build failed");
+
+        const outBinaryDir = path.join(appRoot, "bin");
+
+        if(!fs.existsSync(outBinaryDir)) fs.mkdirSync(outBinaryDir, { recursive: true });
+
+        const extensionSources = nativeExtensionsLinux.map(e => e.sourceFile);
+        const mappedExtensions = extensionSources.map(s => {
+          if (s.startsWith(appRoot)) {
+            return "/app/" + path.relative(appRoot, s).replace(/\\/g, '/');
+          } else if (s.startsWith(__dirname)) {
+            return "/framework/" + path.relative(__dirname, s).replace(/\\/g, '/');
+          }
+          return s; 
+        });
+
+        const compiler = process.argv.find(arg => arg.startsWith("--compiler="))?.split("=")[1] || "g++";
+
+        const gccArgs = [
+          compiler, "-O3",
+          "/framework/core/linux/main.cpp",
+          "/framework/core/linux/Registry.cpp",
+          ...mappedExtensions,
+          "-o", "/app/bin/positron-runtime",
+          "$(pkg-config --cflags --libs gtk+-3.0 webkit2gtk-4.1 json-glib-1.0 libnotify)"
+        ].join(" ");
+        
+        info("[Builder] Compiling inside Docker container...");
+        const runRes = cp.spawnSync("docker", ["run", "--rm", "--platform", dockerArch, "-v", `\${appRoot}:/app`, "-v", `\${__dirname}:/framework`, dockerTag, "bash", "-c", gccArgs], { stdio: "inherit" });
+        if (runRes.error) throw runRes.error;
+        if (runRes.status !== 0) throw new Error("Docker run failed");
+        
+        success("[Builder] Linux native cross-compilation successful.");
+        return true;
+      } catch (err) {
+        error("[Builder] Linux cross-compilation via Docker failed:", err.message);
+        return false;
+      }
+    } else {
+      info("[Builder] Compiling Linux native binary natively via g++...");
+      try {
+        const pkgRes = cp.spawnSync("pkg-config", ["--cflags", "--libs", "gtk+-3.0", "webkit2gtk-4.1", "json-glib-1.0", "libnotify"], { encoding: 'utf8' });
+        if (pkgRes.error) throw pkgRes.error;
+        if (pkgRes.status !== 0) throw new Error("pkg-config failed");
+        const pkgConfigOutput = pkgRes.stdout.trim().split(/\\s+/);
+        
+        const extensionSources = nativeExtensionsLinux.map(e => e.sourceFile);
+        const gccArgs = [
+          "-O3",
+          path.join(coreLinuxDir, "main.cpp"),
+          path.join(coreLinuxDir, "Registry.cpp"),
+          ...extensionSources,
+          "-o", path.join(outBinaryDir, "positron-runtime"),
+          ...pkgConfigOutput
+        ];
+
+        cp.execFileSync("g++", gccArgs, { stdio: "inherit" });
+        success("[Builder] Linux native compilation successful.");
+        return true;
+      } catch (err) {
+        error("[Builder] Linux compilation failed:", err.message);
+        warn("Ensure you have installed: libgtk-3-dev libwebkit2gtk-4.1-dev libjson-glib-dev libsoup2.4-dev");
+        return false;
+      }
+    }
+  }
+
   return false; // Unsupported platform
  
 }