@bobfrankston/msger 0.1.196 → 0.1.197

package/index.d.ts

@@ -1 +1 @@
-export { showMessageBox, MessageBoxOptions, MessageBoxResult } from "./shower.js";
+export { showMessageBox, showService, ServiceHandle, MessageBoxOptions, MessageBoxResult } from "./shower.js";

package/index.js

@@ -1,5 +1,5 @@
 // Export showMessageBox and types for use as a library
-export { showMessageBox } from "./shower.js";
+export { showMessageBox, showService, ServiceHandle } from "./shower.js";
 // If run directly (e.g., `node .` or `node index.js`), run the CLI
 // @ts-ignore - import.meta.main is available in Node.js 20+
 if (import.meta.main) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/msger",
-  "version": "0.1.196",
+  "version": "0.1.197",
   "description": "Fast, lightweight, cross-platform message box - Rust-powered alternative to msgview",
   "type": "module",
   "main": "./index.js",

package/shower.d.ts

@@ -41,6 +41,8 @@ export interface MessageBoxOptions {
     debug?: boolean; /** Return debug information (HTML, size) in result (default: false) */
     showVersion?: boolean; /** Show version in window title (default: false) */
     appUserModelId?: string; /** Windows AppUserModelID for taskbar pinning (internal use) */
+    initScript?: string; /** Custom JS injected into WebView alongside msger-api.js */
+    service?: boolean; /** Service mode: bidirectional IPC with parent. Stdin/stdout stay open. */
 }
 export interface MessageBoxResult {
     button: string;
@@ -68,3 +70,23 @@ export declare function showMessageBoxEx(options: MessageBoxOptions): MessageBox
  * @returns Promise that resolves with user's response
  */
 export declare function showMessageBox(options: MessageBoxOptions): Promise<MessageBoxResult>;
+export type ServiceRequestHandler = (request: any) => void;
+/** Handle for a service-mode msger instance. Bidirectional IPC with the WebView. */
+export declare class ServiceHandle {
+    private child;
+    private _closed;
+    private _onRequest;
+    readonly closed: Promise<void>;
+    constructor(child: ChildProcess);
+    /** Register handler for requests from the WebView (_action messages) */
+    onRequest(handler: ServiceRequestHandler): void;
+    /** Send a response or event to the WebView (written to child's stdin) */
+    send(msg: any): void;
+    /** Close the window */
+    close(): void;
+}
+/**
+ * Open msger in service mode — bidirectional IPC, no HTTP.
+ * Parent process handles requests via onRequest, sends responses via send().
+ */
+export declare function showService(options: Omit<MessageBoxOptions, "service" | "detach">): ServiceHandle;

package/shower.js

@@ -262,3 +262,89 @@ export function showMessageBoxEx(options) {
 export async function showMessageBox(options) {
     return showMessageBoxEx(options).result;
 }
+/** Handle for a service-mode msger instance. Bidirectional IPC with the WebView. */
+export class ServiceHandle {
+    child;
+    _closed = false;
+    _onRequest = null;
+    closed;
+    constructor(child) {
+        this.child = child;
+        // Parse stdout as newline-delimited JSON (requests from WebView)
+        let buffer = "";
+        child.stdout?.on("data", (data) => {
+            buffer += data.toString();
+            let newline;
+            while ((newline = buffer.indexOf("\n")) >= 0) {
+                const line = buffer.slice(0, newline).trim();
+                buffer = buffer.slice(newline + 1);
+                if (!line)
+                    continue;
+                try {
+                    const msg = JSON.parse(line);
+                    if (this._onRequest)
+                        this._onRequest(msg);
+                }
+                catch { /* ignore malformed lines */ }
+            }
+        });
+        this.closed = new Promise((resolve) => {
+            child.on("close", () => { this._closed = true; resolve(); });
+        });
+    }
+    /** Register handler for requests from the WebView (_action messages) */
+    onRequest(handler) {
+        this._onRequest = handler;
+    }
+    /** Send a response or event to the WebView (written to child's stdin) */
+    send(msg) {
+        if (this._closed)
+            return;
+        this.child.stdin?.write(JSON.stringify(msg) + "\n");
+    }
+    /** Close the window */
+    close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        this.child.kill();
+    }
+}
+/**
+ * Open msger in service mode — bidirectional IPC, no HTTP.
+ * Parent process handles requests via onRequest, sends responses via send().
+ */
+export function showService(options) {
+    const serviceOptions = { ...options, service: true, detach: false };
+    const isWindows = platform() === "win32";
+    const arch = process.arch;
+    let binaryName;
+    if (isWindows)
+        binaryName = "msgernative.exe";
+    else if (arch === "arm64")
+        binaryName = "msgernative-linux-aarch64";
+    else
+        binaryName = "msgernative";
+    const binaryPath = path.join(import.meta.dirname, "msger-native", "bin", binaryName);
+    const childEnv = { ...process.env };
+    if ("NODE_OPTIONS" in childEnv)
+        delete childEnv.NODE_OPTIONS;
+    const child = spawn(binaryPath, [], {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: childEnv,
+    });
+    child.stderr?.on("data", (data) => {
+        // Forward Rust stderr to parent stderr (debug messages)
+        process.stderr.write(data);
+    });
+    child.stdin?.on("error", () => { });
+    // Send options as first line of stdin (Rust reads one line for options, then keeps reading)
+    const rustOptions = { ...serviceOptions };
+    if (rustOptions.size) {
+        rustOptions.width = rustOptions.size.width;
+        rustOptions.height = rustOptions.size.height;
+        delete rustOptions.size;
+    }
+    child.stdin?.write(JSON.stringify(rustOptions) + "\n");
+    return new ServiceHandle(child);
+}