Removed old log mechanism in favor of captured stdout so that both the script server and susubprocess modes use the same log mechanism

Author: G.S. Hirpara

vangard/commands/BaseCommand.py

@@ -102,7 +102,6 @@ def exec_remote_script(
                 "scriptFile": script_path,
                 "args": mark_args
             }
-            
 
             print(f"Sending script to DAZ Script Server: {url}")
             print(f"  payload: {json.dumps(payload, indent=2)}")
@@ -117,19 +116,25 @@ def exec_remote_script(
             timeout = 30
             with urllib.request.urlopen(req, timeout=timeout) as response:
                 result = response.read().decode("utf-8")
-                print(f"DAZ Script Server response: {result}")
+                BaseCommand._print_script_output(result)
 
         else:
-            print(os.environ['DAZ_ROOT'])
-
             daz_root = os.getenv("DAZ_ROOT")
             daz_args = os.getenv("DAZ_ARGS", "")
 
             # Build command as a list for cross-platform compatibility
             command_list = [daz_root]
 
+            # Inject _log_file if DAZ_LOG_FILE env var is set, giving subprocess
+            # mode a configurable (non-hardcoded) file for diagnostic output.
+            effective_vars = dict(script_vars) if script_vars is not None else {}
+            daz_log_file = os.getenv("DAZ_LOG_FILE")
+            if daz_log_file:
+                effective_vars["_log_file"] = daz_log_file
+                print(f"Script log output will be written to: {daz_log_file}")
+
             # Add script arguments
-            mark_args = json.dumps(script_vars) if script_vars is not None else ""
+            mark_args = json.dumps(effective_vars) if effective_vars else ""
             if mark_args:
                 command_list.extend(["-scriptArg", mark_args])
 
@@ -152,6 +157,34 @@ def exec_remote_script(
             subprocess.Popen(command_list, shell=False)
 
 
+    @staticmethod
+    def _print_script_output(raw: str) -> None:
+        """
+        Parses and displays output returned by the DAZ Script Server.
+
+        Scripts emit structured JSON log lines via print() (one per line).
+        Each line is attempted as JSON; if it parses as a log entry (has an
+        'event_type' key) it is displayed in a readable format.  Lines that
+        are not valid JSON are printed as-is.
+        """
+        for line in raw.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                entry = json.loads(line)
+                if "event_type" in entry:
+                    level  = entry.get("event_type", "INFO")
+                    source = entry.get("source", "")
+                    msg    = entry.get("message", "")
+                    status = entry.get("status", "")
+                    detail = f" [{status}]" if status else ""
+                    print(f"[{level}] {source}{detail}: {msg}" if msg else f"[{level}] {json.dumps(entry)}")
+                else:
+                    print(line)
+            except (json.JSONDecodeError, ValueError):
+                print(line)
+
     @staticmethod
     def to_dict(args: argparse.Namespace, exclude: Optional[Set[str]] = None) -> Dict[str, Any]:
         """

vangard/scripts/DazLoggingUtils.dsa

@@ -86,18 +86,20 @@ function close_log() {
 /**
  * Initializes script utilities. This includes:
  * - Setting the global log source name (`s_logSourceName`).
- * - Initializing the log file (hardcoded to 'C:/Temp/razor.log', append mode).
  * - Updating modifier key states.
- * - Parsing script arguments (expected to be a JSON string in `App.scriptArgs[0]`) and logging them.
+ * - Parsing script arguments (expected to be a JSON string in `App.scriptArgs[0]`
+ *   in subprocess mode, or via `getArguments()` in server mode).
+ * - Optionally opening a log file if the parsed args contain a `_log_file` key.
+ *   This is the only supported way to enable file logging; there is no hardcoded
+ *   default path.
+ *
  * @param {string} log_source_id - The identifier to use as the source for log entries.
  * @returns {object | null} The parsed script arguments object, or `null` if parsing fails or no arguments.
  */
 function init_script_utils(log_source_id) {
 
     s_logSourceName = log_source_id;
 
-    init_log('C:/Temp/razor.log', false);
-
     // If the "Action" global transient is defined, and its the correct type
     if( typeof( Action ) != "undefined" && Action.inherits( "DzScriptAction" ) ){
         // If the current key sequence for the action is not pressed
@@ -112,9 +114,16 @@ function init_script_utils(log_source_id) {
     args = getArguments()[0];
     if (args == undefined) {
         args = App.scriptArgs[0];
-	rv   = JSON.parse(args);
+        rv   = JSON.parse(args);
     } else {
-	rv = args;
+        rv = args;
+    }
+
+    // Optional file logging: only enabled when the caller passes `_log_file`
+    // in the script arguments (e.g. via the DAZ_LOG_FILE environment variable
+    // on the Python side).  No hardcoded default path is used.
+    if (rv != null && rv['_log_file'] != undefined) {
+        init_log(rv['_log_file'], false);
     }
 
     return rv;
@@ -129,18 +138,23 @@ function close_script_utils() {
 }
 
 /**
- * Logs an event to the initialized log file.
- * The event is logged as a JSON string containing source, timestamp, event type, name, and additional info.
+ * Logs an event by printing a JSON-encoded log line to stdout and, if a log
+ * file is open, writing it there as well.
+ *
+ * In DAZ Script Server mode the script's stdout is captured by the server and
+ * returned to the Python caller as part of the HTTP response, so every call to
+ * this function produces a structured result that the caller can parse.
+ *
+ * In subprocess mode stdout is not piped back to Python, but if a log file was
+ * configured via the `_log_file` script argument (or an explicit `init_log`
+ * call) the entry is also written there.
+ *
  * @param {string} event_type - The type of the event (e.g., "INFO", "ERROR").
  * @param {string} event_name - A name or category for the event.
- * @param {object} [event_info=null] - An optional object containing additional key-value pairs to include in the log entry.
+ * @param {object} [event_info=null] - An optional object with additional key-value pairs to include.
  * @returns {void}
  */
 function log_event(event_type, event_name, event_info) {
-    if (log_file == null || !log_file.isOpen()) {
-        return;
-    }
-
     var base_message = {
         'source': s_logSourceName,
         'dtg': Date.now(),
@@ -157,7 +171,15 @@ function log_event(event_type, event_name, event_info) {
         }
     }
 
-    log_file.writeLine(JSON.stringify(base_message));
+    var json_line = JSON.stringify(base_message);
+
+    // Always emit to stdout so server mode captures it as a return value.
+    print(json_line);
+
+    // Also write to the log file if one was opened (subprocess / explicit use).
+    if (log_file != null && log_file.isOpen()) {
+        log_file.writeLine(json_line);
+    }
 }
 
 /**