Feature/cli installer (#390)

* feat: Improve headless install output - minimal and quiet

- Fix NPE in ServiceLifecycleManager by initializing progressCallback
- Suppress verbose output in headless mode (bundle loading, GitHub downloads, warnings, logging)
- Redirect stdout/stderr to log file (~/.jdeploy/log/jdeploy-headless-install.log)
- Only show essential messages: "Installing..." and "Installation complete"
- Support headless mode in MainDebug for testing

* feat: Add install and uninstall CLI commands to package.json

Define commands for headless install/uninstall operations via CLI.

* fix: Prevent GUI toolkit initialization in headless install mode

Set java.awt.headless=true before any AWT classes are loaded to prevent
the macOS menu bar from appearing during headless installs. The ImageIO
usage in MacBundler was triggering AWT initialization.

* fix: Skip dock/desktop/start menu items in headless install mode

HeadlessInstallationSettings now disables addToDock, addToDesktop,
addToStartMenu, and addToPrograms to prevent GUI interactions and
screen flashes during CLI installs.

Author: shannah

installer/package.json

@@ -5,7 +5,6 @@
     "main": "index.js",
     "preferGlobal": true,
     "repository": {
-        "type": "git",
         "directory": "installer",
         "url": "https://github.com/shannah/jdeploy.git"
     },
@@ -15,6 +14,7 @@
         "notarize": false,
         "packageLinuxX64": "jdeploy-installer-linux-x64",
         "packageMacArm64": "jdeploy-installer-mac-arm64",
+        "javaVersion": "8",
         "packageLinuxArm64": "jdeploy-installer-linux-arm64",
         "downloadPage": {"platforms": ["all"]},
         "fork": false,
@@ -38,7 +38,19 @@
         "jar": "target/jdeploy-installer-1.0-SNAPSHOT.jar",
         "codesign": true,
         "platformBundlesEnabled": true,
-        "packageWinArm64": "jdeploy-installer-win-arm64"
+        "packageWinArm64": "jdeploy-installer-win-arm64",
+        "commands": {
+            "uninstall": {
+                "implements": ["updater"],
+                "args": ["uninstall"],
+                "description": "CLI uninstaller"
+            },
+            "install": {
+                "implements": ["updater"],
+                "args": ["install"],
+                "description": "CLI Install"
+            }
+        }
     },
     "dependencies": {"shelljs": "^0.8.4"},
     "license": "ISC",

installer/src/main/java/ca/weblite/jdeploy/installer/HeadlessInstallationSettings.java

@@ -2,6 +2,19 @@
 
 import ca.weblite.jdeploy.installer.models.InstallationSettings;
 
+/**
+ * Installation settings for headless (CLI) mode.
+ * Disables GUI-related features like dock, desktop shortcuts, and start menu items.
+ */
 public class HeadlessInstallationSettings extends InstallationSettings {
 
+    public HeadlessInstallationSettings() {
+        super();
+        // Disable dock/desktop/start menu items in headless mode
+        // These require GUI interaction or cause screen flashes
+        setAddToDock(false);
+        setAddToDesktop(false);
+        setAddToStartMenu(false);
+        setAddToPrograms(false);
+    }
 }

installer/src/main/java/ca/weblite/jdeploy/installer/Main.java

@@ -89,6 +89,11 @@ private Main() {
 
     private Main(InstallationSettings settings) {
         this.installationSettings = settings;
+        // Initialize the service lifecycle progress callback
+        // Use SILENT by default - headless mode redirects output anyway,
+        // and GUI mode will set up its own callback via the UI
+        this.serviceLifecycleProgressCallback =
+            ca.weblite.jdeploy.installer.services.ServiceLifecycleProgressCallback.SILENT;
     }
 
     private Document getAppXMLDocument() throws IOException {
@@ -476,13 +481,20 @@ public static void main(String[] args) {
 
         if (args.length == 1 && args[0].equals("install")) {
             headlessInstall = true;
+            // Set AWT headless mode to prevent GUI toolkit initialization
+            // This must be set before any AWT classes are loaded
+            System.setProperty("java.awt.headless", "true");
         }
 
         if (System.getProperty("jdeploy.background", "false").equals("true")) {
             runAsBackgroundHelper = true;
         }
 
-        if (!headlessInstall) {
+        if (headlessInstall) {
+            // For headless mode, set up output suppression immediately
+            // This must happen before Main object creation which triggers verbose output
+            setupStaticHeadlessOutputSuppression();
+        } else {
             File logFile = new File(System.getProperty("user.home") + File.separator + ".jdeploy" + File.separator + "log" + File.separator + "jdeploy-installer.log");
             logFile.getParentFile().mkdirs();
             try {
@@ -500,6 +512,62 @@ public static void main(String[] args) {
         main.run();
     }
 
+    // Static fields for headless output suppression (set in main() before Main object creation)
+    private static PrintStream staticOriginalOut;
+    private static PrintStream staticOriginalErr;
+    private static File staticLogFile;
+    private static PrintStream staticLogStream;
+
+    /**
+     * Allows external callers (like MainDebug) to set the original streams
+     * before Main.main() is called. This is needed when the caller has already
+     * set up output redirection and wants Main to use the true original streams.
+     */
+    public static void setOriginalStreams(PrintStream out, PrintStream err, File logFile) {
+        staticOriginalOut = out;
+        staticOriginalErr = err;
+        staticLogFile = logFile;
+    }
+
+    /**
+     * Sets up output suppression for headless mode at the static level.
+     * Must be called before Main object creation to suppress verbose output from InstallationContext.
+     */
+    private static void setupStaticHeadlessOutputSuppression() {
+        // Only store streams if not already set by external caller (e.g., MainDebug)
+        if (staticOriginalOut == null) {
+            staticOriginalOut = System.out;
+        }
+        if (staticOriginalErr == null) {
+            staticOriginalErr = System.err;
+        }
+
+        // Suppress java.util.logging output
+        java.util.logging.Logger rootLogger = java.util.logging.Logger.getLogger("");
+        java.util.logging.Handler[] handlers = rootLogger.getHandlers();
+        for (java.util.logging.Handler handler : handlers) {
+            handler.setLevel(java.util.logging.Level.OFF);
+        }
+        rootLogger.setLevel(java.util.logging.Level.OFF);
+
+        // Only set up log file redirection if not already done
+        if (staticLogFile == null) {
+            staticLogFile = new File(
+                System.getProperty("user.home") + File.separator + ".jdeploy" +
+                File.separator + "log" + File.separator + "jdeploy-headless-install.log"
+            );
+        }
+        staticLogFile.getParentFile().mkdirs();
+
+        try {
+            staticLogStream = new PrintStream(new FileOutputStream(staticLogFile));
+            System.setOut(staticLogStream);
+            System.setErr(staticLogStream);
+        } catch (FileNotFoundException e) {
+            staticOriginalErr.println("Warning: Could not create log file: " + e.getMessage());
+        }
+    }
+
     private File findAppXmlFile() {
         return installationContext.findAppXml();
 
@@ -510,19 +578,32 @@ public void run() {
         try {
             run0();
         } catch (Exception ex) {
-            ex.printStackTrace(System.err);
-            System.err.flush();
-            invokeLater(()->{
-                String message = ex.getMessage();
-                if (ex instanceof UserLangRuntimeException) {
-                    UserLangRuntimeException userEx = (UserLangRuntimeException) ex;
-                    if (userEx.hasUserFriendlyMessage()) {
-                        message = userEx.getUserFriendlyMessage();
-                    }
-                }
-                uiFactory.showModalErrorDialog(null, message, "Installation failed.");
+            // In headless mode, write to original stderr (not the redirected one)
+            PrintStream errStream = staticOriginalErr != null ? staticOriginalErr : System.err;
+            if (headlessInstall) {
+                errStream.println("Installation failed: " + ex.getMessage());
+                if (staticLogFile != null) {
+                    errStream.println("See log file for details: " + staticLogFile.getAbsolutePath());
+                }
+                // Also log full stack trace to log file
+                ex.printStackTrace(System.err);
+                System.err.flush();
                 System.exit(1);
-            });
+            } else {
+                ex.printStackTrace(System.err);
+                System.err.flush();
+                invokeLater(()->{
+                    String message = ex.getMessage();
+                    if (ex instanceof UserLangRuntimeException) {
+                        UserLangRuntimeException userEx = (UserLangRuntimeException) ex;
+                        if (userEx.hasUserFriendlyMessage()) {
+                            message = userEx.getUserFriendlyMessage();
+                        }
+                    }
+                    uiFactory.showModalErrorDialog(null, message, "Installation failed.");
+                    System.exit(1);
+                });
+            }
         }
     }
 
@@ -861,6 +942,7 @@ private void onVisitSoftwareHomepage(InstallationFormEvent evt) {
     }
 
     private void run0() throws Exception {
+        // Output suppression for headless mode is handled in main() via setupStaticHeadlessOutputSuppression()
         loadAppInfo();
 
         if (uninstall && Platform.getSystemPlatform().isWindows()) {
@@ -922,18 +1004,24 @@ private void runAsBackgroundHelperOnEdt() {
     }
 
     private void runHeadlessInstall() throws Exception {
-        System.out.println(
-                "jDeploy installer running in headless mode.  Installing " +
-                        appInfo().getTitle() + " " + npmPackageVersion().getVersion()
+        // Output suppression is handled by setupStaticHeadlessOutputSuppression() in main()
+        // Use staticOriginalOut for user-facing messages
+
+        staticOriginalOut.println(
+            "Installing " + appInfo().getTitle() + " " + npmPackageVersion().getVersion() + "..."
         );
+
         try {
             install();
         } catch (Exception ex) {
-            System.err.println("Installation failed");
-            ex.printStackTrace(System.err);
-            return;
+            staticOriginalErr.println("Installation failed: " + ex.getMessage());
+            if (staticLogFile != null) {
+                staticOriginalErr.println("See log file for details: " + staticLogFile.getAbsolutePath());
+            }
+            throw ex;
         }
-        System.out.println("Installation complete");
+
+        staticOriginalOut.println("Installation complete");
     }
 
     private File installedApp;

installer/src/main/java/ca/weblite/jdeploy/installer/MainDebug.java

@@ -2,20 +2,47 @@
 
 import org.apache.commons.io.FileUtils;
 import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.PrintStream;
 
 public class MainDebug {
-    
+
+    // Static fields for headless output suppression
+    private static PrintStream originalOut;
+    private static PrintStream originalErr;
+    private static File logFile;
+    private static PrintStream logStream;
+    private static boolean headlessMode = false;
+
     public static void main(String[] args) throws Exception {
         if (args.length < 1) {
-            System.err.println("Usage: MainDebug <code> [version]");
+            System.err.println("Usage: MainDebug <code> [version] [install]");
             System.err.println("  code: The jDeploy bundle code");
             System.err.println("  version: The version (defaults to 'latest' if not specified)");
+            System.err.println("  install: Pass 'install' as third arg for headless mode");
             System.exit(1);
         }
 
         String code = args[0];
         String version = args.length > 1 ? args[1] : "latest";
 
+        // Check if headless mode is requested (install argument in args)
+        for (int i = 2; i < args.length; i++) {
+            if ("install".equals(args[i])) {
+                headlessMode = true;
+                // Set AWT headless mode to prevent GUI toolkit initialization
+                // This must be set before any AWT classes are loaded
+                System.setProperty("java.awt.headless", "true");
+                break;
+            }
+        }
+
+        // Set up output suppression for headless mode before any verbose operations
+        if (headlessMode) {
+            setupHeadlessOutputSuppression();
+        }
+
         File tempDir = File.createTempFile("jdeploy-debug2-", "");
         tempDir.delete();
         tempDir.mkdirs();
@@ -47,10 +74,53 @@ public static void main(String[] args) throws Exception {
                 System.err.println("Failed to download .jdeploy-files for code: " + code + ", version: " + version);
                 System.exit(1);
             }
-            
-            Main.main(new String[0]);
+            String[] newArgs;
+            if (args.length > 2) {
+                newArgs = new String[args.length - 2];
+                System.arraycopy(args, 2, newArgs, 0, newArgs.length);
+            } else {
+                newArgs = new String[0];
+            }
+            // Pass original streams to Main so it can output user-facing messages
+            if (headlessMode) {
+                Main.setOriginalStreams(originalOut, originalErr, logFile);
+            }
+            Main.main(newArgs);
         } finally {
             System.setProperty("user.dir", originalDir.getAbsolutePath());
         }
     }
+
+    /**
+     * Sets up output suppression for headless mode.
+     * Redirects stdout and stderr to a log file and suppresses java.util.logging.
+     */
+    private static void setupHeadlessOutputSuppression() {
+        // Store original streams
+        originalOut = System.out;
+        originalErr = System.err;
+
+        // Suppress java.util.logging output
+        java.util.logging.Logger rootLogger = java.util.logging.Logger.getLogger("");
+        java.util.logging.Handler[] handlers = rootLogger.getHandlers();
+        for (java.util.logging.Handler handler : handlers) {
+            handler.setLevel(java.util.logging.Level.OFF);
+        }
+        rootLogger.setLevel(java.util.logging.Level.OFF);
+
+        // Redirect stdout and stderr to log file
+        logFile = new File(
+            System.getProperty("user.home") + File.separator + ".jdeploy" +
+            File.separator + "log" + File.separator + "jdeploy-headless-install.log"
+        );
+        logFile.getParentFile().mkdirs();
+
+        try {
+            logStream = new PrintStream(new FileOutputStream(logFile));
+            System.setOut(logStream);
+            System.setErr(logStream);
+        } catch (FileNotFoundException e) {
+            originalErr.println("Warning: Could not create log file: " + e.getMessage());
+        }
+    }
 }

installer/src/main/java/ca/weblite/jdeploy/installer/services/ConsoleServiceLifecycleProgressCallback.java

@@ -0,0 +1,20 @@
+package ca.weblite.jdeploy.installer.services;
+
+/**
+ * Console-based implementation of ServiceLifecycleProgressCallback for headless installations.
+ * Prints progress messages to stdout in a clean format.
+ *
+ * @author Steve Hannah
+ */
+public class ConsoleServiceLifecycleProgressCallback implements ServiceLifecycleProgressCallback {
+
+    @Override
+    public void updateProgress(String message) {
+        System.out.println(message);
+    }
+
+    @Override
+    public void reportWarning(String message) {
+        System.err.println("Warning: " + message);
+    }
+}