fix: Prevent API calls during discovery and correct arg parsing

- Python Library (`ObsidianPluginDevPythonToJS.py`):
  - Fixed `NameError: name 'args' is not defined` in `_handle_cli_args`
    by adding `args, unknown = parser.parse_known_args()`.
  - Ensured `_script_settings_definitions` defaults to an empty list
    if not defined by the user script before `_handle_cli_args` is called.
  - Introduced `OBSIDIAN_BRIDGE_MODE` environment variable handling:
    - Plugin sets `OBSIDIAN_BRIDGE_MODE="discovery"` when running scripts
      for settings discovery.
    - Library `__init__` reads this mode.
    - `_send_receive` now checks `self._execution_mode`. If "discovery",
      it raises an `ObsidianCommError` immediately, preventing API calls
      and providing a clear error message. This effectively sandboxes
      library API usage during discovery for scripts not properly handling
      `--get-settings-json`.
- TypeScript Plugin (`src/python_executor.ts`):
  - Added `OBSIDIAN_BRIDGE_MODE: "discovery"` to the environment variables
    when spawning scripts for settings discovery.

This resolves issues where scripts not handling `--get-settings-json`
could execute unintended API calls during the plugin's startup/settings
refresh phase. It also fixes a bug in the Python library's CLI argument
handling. Auto-start logic appears to be functioning correctly with
existing settings checks.

Author: mathe00

ObsidianPluginDevPythonToJS.py

@@ -121,7 +121,7 @@ def _handle_cli_args():
     )
     # Parse only known args defined above, ignore others that might be passed
     # This prevents errors if Obsidian or the user passes other args accidentally
-
+    args, unknown = parser.parse_known_args()
     # --- Check for Event Trigger Environment Variables ---
     # This check happens AFTER parsing CLI args but BEFORE checking --get-settings-json
     # because event triggers should take precedence over settings discovery.
@@ -142,15 +142,17 @@ def _handle_cli_args():
         # print("DEBUG: --get-settings-json flag detected.", file=sys.stderr) # Optional debug
         try:
             # Use the globally stored definitions populated by define_settings
-            json_output = json.dumps(_script_settings_definitions) # No indent for production
+            # Ensure _script_settings_definitions exists, default to empty list if not defined by user script
+            definitions_to_output = _script_settings_definitions if '_script_settings_definitions' in globals() else []
+            json_output = json.dumps(definitions_to_output) # No indent for production
             print(json_output) # Print JSON to stdout
             sys.exit(0) # Exit successfully, preventing rest of script execution
         except TypeError as e:
             # Error during JSON serialization (e.g., non-serializable default value)
             error_msg = {
                 "status": "error",
                 "error": f"Failed to serialize settings definitions to JSON: {e}. Check default values.",
-                "definitions": _script_settings_definitions # Include definitions for debugging
+                "definitions": definitions_to_output # Include definitions for debugging
             }
             print(json.dumps(error_msg), file=sys.stderr)
             sys.exit(1) # Exit with error
@@ -217,6 +219,12 @@ def __init__(self, http_port: int = HTTP_PORT, connect_timeout: float = 2.0, req
         self.session = requests.Session()
         # Store script path for event listener registration payload
         self._script_relative_path_for_api: Optional[str] = None
+        
+        # --- Determine execution mode (normal or discovery) ---
+        self._execution_mode = os.environ.get("OBSIDIAN_BRIDGE_MODE", "normal")
+        if self._execution_mode == "discovery":
+            # Use stderr for info messages during discovery to avoid polluting stdout (which is used for JSON)
+            print("INFO: ObsidianPluginDevPythonToJS: Initialized in settings discovery mode. API calls will be disabled.", file=sys.stderr)
 
         # --- Read script relative path from environment variable ---
         # This is crucial for the get_script_settings method.
@@ -309,6 +317,15 @@ def _send_receive(self, action: str, payload: Optional[Dict[str, Any]] = None, t
                                with status 'error'. Includes the failing action name.
             requests.exceptions.RequestException: For underlying HTTP request issues.
         """
+        # --- Prevent API calls during settings discovery ---
+        if self._execution_mode == "discovery":
+            error_message = (
+                "API calls are disabled during settings discovery mode. "
+                "Ensure your script handles the --get-settings-json argument "
+                "(e.g., using _handle_cli_args() before initializing ObsidianPluginDevPythonToJS)."
+            )
+            # Raise specific error to indicate the cause clearly
+            raise ObsidianCommError(error_message, action=action)
         request_data = {"action": action, "payload": payload if payload is not None else {}}
         request_timeout = timeout if timeout is not None else self.request_timeout
         response_text = "" # Initialize for potential use in error reporting

src/python_executor.ts

@@ -81,7 +81,11 @@ export async function discoverScriptSettings(plugin: ObsidianPythonBridge, scrip
 			discoveryPYTHONPATH = `${discoveryPYTHONPATH}${path.delimiter}${currentPYTHONPATH}`;
 		}
 		// --- End PYTHONPATH for discovery ---
-		const env = { ...process.env, PYTHONPATH: discoveryPYTHONPATH };
+		const env = {
+			...process.env, // Inherit existing environment
+			PYTHONPATH: discoveryPYTHONPATH,
+			OBSIDIAN_BRIDGE_MODE: "discovery"
+		};
 		// --- End PYTHONPATH for discovery ---
 		plugin.logDebug(`Executing discovery with PYTHONPATH: ${discoveryPYTHONPATH} and cwd: ${scriptDir}`);
 		const pythonProcess = spawn(plugin.pythonExecutable!, args, { timeout: discoveryTimeoutMs, cwd: scriptDir, env: env }); // Set working directory to the script's folder // Pass modified environment
@@ -340,40 +344,80 @@ export async function runAllPythonScripts(plugin: ObsidianPythonBridge): Promise
  * Called after plugin load, server start, and initial settings sync.
  * @param plugin The ObsidianPythonBridge plugin instance.
  */
-export function runAutoStartScripts(plugin: ObsidianPythonBridge): void {
+export async function runAutoStartScripts(plugin: ObsidianPythonBridge): Promise<void> { // Make async to await loadData
 	plugin.logInfo("Checking for scripts to run on startup...");
-	const scriptsFolder = getScriptsFolderPath(plugin);
-	if (!scriptsFolder) { plugin.logWarn("Cannot run auto-start scripts: Scripts folder path is invalid."); return; }
+
+	// Reload settings just before checking to ensure the latest values are used.
+	// This is a safeguard against potential async state issues.
+	await plugin.loadSettings();
+	const currentSettings = plugin.settings; // Use a local copy for the loop
+
+	const scriptsFolder = getScriptsFolderPath(plugin); // Uses plugin.settings which was just reloaded
+	if (!scriptsFolder) {
+		plugin.logWarn("Cannot run auto-start scripts: Scripts folder path is invalid.");
+		return;
+	}
+
 	let scriptsRunCount = 0;
-	for (const relativePath in plugin.settings.scriptAutoStartStatus) {
-		const shouldAutoStart = plugin.settings.scriptAutoStartStatus[relativePath];
-		const isScriptActive = plugin.settings.scriptActivationStatus[relativePath] !== false;
-		if (shouldAutoStart && isScriptActive) {
-			const absolutePath = path.join(scriptsFolder, relativePath);
-			try {
-				if (fs.existsSync(absolutePath) && fs.statSync(absolutePath).isFile()) {
-					plugin.logInfo(`Auto-starting script: ${relativePath}`);
-					const delaySeconds = plugin.settings.scriptAutoStartDelay[relativePath] ?? 0;
-					const delayMs = Math.max(0, delaySeconds) * 1000;
-					if (delayMs > 0) {
-						plugin.logInfo(` -> Delaying execution by ${delaySeconds} second(s).`);
-						setTimeout(() => {
-							if (plugin.settings.scriptActivationStatus[relativePath] !== false) { // Re-check activation status inside timeout
-								plugin.logInfo(`Executing delayed auto-start script: ${relativePath}`);
-								runPythonScript(plugin, absolutePath, "auto-start"); // No await
-							} else plugin.logWarn(`Skipping delayed auto-start for ${relativePath}: Script was disabled during delay.`);
-						}, delayMs);
-					} else runPythonScript(plugin, absolutePath, "auto-start"); // No await
-					scriptsRunCount++;
-				} else {
-					plugin.logWarn(`Skipping auto-start for ${relativePath}: Script file not found at ${absolutePath}.`);
-					// Consider cleaning up stale auto-start/delay entries here if desired
+	plugin.logDebug("Current AutoStart Status:", currentSettings.scriptAutoStartStatus);
+	plugin.logDebug("Current Activation Status:", currentSettings.scriptActivationStatus);
+
+	// Iterate over scripts that have an entry in scriptAutoStartStatus
+	for (const relativePath in currentSettings.scriptAutoStartStatus) {
+		const shouldAutoStart = currentSettings.scriptAutoStartStatus[relativePath];
+		// Explicitly check if shouldAutoStart is true
+		if (shouldAutoStart === true) {
+			// Then check if the script is active
+			const isScriptActive = currentSettings.scriptActivationStatus[relativePath] !== false;
+			plugin.logDebug(`Checking script ${relativePath}: shouldAutoStart=${shouldAutoStart}, isScriptActive=${isScriptActive}`);
+
+			if (isScriptActive) {
+				const absolutePath = path.join(scriptsFolder, relativePath);
+				try {
+					if (fs.existsSync(absolutePath) && fs.statSync(absolutePath).isFile()) {
+						plugin.logInfo(`Auto-starting script: ${relativePath}`);
+						const delaySeconds = currentSettings.scriptAutoStartDelay[relativePath] ?? 0;
+						const delayMs = Math.max(0, delaySeconds) * 1000;
+
+						if (delayMs > 0) {
+							plugin.logInfo(` -> Delaying execution by ${delaySeconds} second(s).`);
+							setTimeout(async () => { // Make callback async to reload settings
+								// Re-check status just before delayed execution
+								await plugin.loadSettings(); // Reload again
+								const latestActivationStatus = plugin.settings.scriptActivationStatus[relativePath] !== false;
+								const latestAutoStartStatus = plugin.settings.scriptAutoStartStatus[relativePath] === true;
+
+								if (latestActivationStatus && latestAutoStartStatus) {
+									plugin.logInfo(`Executing delayed auto-start script: ${relativePath}`);
+									runPythonScript(plugin, absolutePath, "auto-start"); // No await needed here
+								} else {
+									plugin.logWarn(`Skipping delayed auto-start for ${relativePath}: Script status changed during delay (Active: ${latestActivationStatus}, AutoStart: ${latestAutoStartStatus}).`);
+								}
+							}, delayMs);
+						} else {
+							// Immediate execution (no need to re-check here as we just loaded settings)
+							runPythonScript(plugin, absolutePath, "auto-start"); // No await needed here
+						}
+						scriptsRunCount++;
+					} else {
+						plugin.logWarn(`Skipping auto-start for ${relativePath}: Script file not found at ${absolutePath}.`);
+					}
+				} catch (error) {
+					plugin.logError(`Error checking file status for auto-start script ${absolutePath}:`, error);
 				}
-			} catch (error) { plugin.logError(`Error checking file status for auto-start script ${absolutePath}:`, error); }
+			} else {
+				plugin.logDebug(`Skipping auto-start for ${relativePath}: Script is not active.`);
+			}
+		} else {
+			plugin.logDebug(`Skipping auto-start for ${relativePath}: Auto-start setting is false.`);
 		}
+	} // End for loop
+
+	if (scriptsRunCount > 0) {
+		plugin.logInfo(`Finished launching ${scriptsRunCount} auto-start script(s).`);
+	} else {
+		plugin.logInfo("No active scripts configured for auto-start based on current settings.");
 	}
-	if (scriptsRunCount > 0) plugin.logInfo(`Finished launching ${scriptsRunCount} auto-start script(s).`);
-	else plugin.logInfo("No active scripts configured for auto-start.");
 }
 
 // --- Dynamic Command Management ---