...

examples/basics/directories.rhai

@@ -1,5 +1,3 @@
-// 05_directory_operations.rhai
-// Demonstrates directory operations using SAL, including the new chdir function
 
 // Create a test directory structure
 let base_dir = "rhai_dir_test";
@@ -81,4 +79,4 @@ println(`Directory change result: ${chdir_parent_result}`);
 // delete(base_dir);
 // println("Cleanup complete");
 
-"Directory operations script completed successfully!"
+"Directory operations script completed successfully!"

examples/process/kill.rhai

@@ -0,0 +1,28 @@
+print("Caution: Use the kill() function with extreme care as it can terminate running applications.");
+print("Terminating essential system processes can make your system unstable or unusable.");
+print("");
+
+print("This example attempts to kill processes matching a specific name.");
+print("Replace 'process_name_to_kill' with the actual name of a process you intend to stop.");
+print("Make sure you know what the process does before attempting to kill it.");
+print("");
+
+let target_process_name = "process_name_to_kill"; // <--- CHANGE THIS TO A REAL PROCESS NAME (e.g., "sleep" if you start a sleep process)
+
+print(`Attempting to kill processes matching pattern: '${target_process_name}'...`);
+
+// To safely test this, you might want to start a simple process first, like 'sleep 60 &'.
+// Then replace 'process_name_to_kill' with 'sleep'.
+
+// Uncomment the line below to execute the kill command.
+// let result_message = kill(target_process_name); // Halts on OS error during kill attempt
+
+// if result_message != "" {
+//     print(`Kill command sent. Result: ${result_message}`);
+// } else {
+//     print("Kill command finished, but no message returned (check for errors above).");
+// }
+
+print("");
+print("kill() example finished (command was commented out for safety).");
+print("Uncomment the 'kill(...)' line to make it active.");

examples/process/process_get.rhai

@@ -0,0 +1,39 @@
+print("Getting a single process using process_get()...\n");
+
+// process_get expects *exactly one* process matching the pattern.
+// If zero or more than one processes match, it will halt script execution.
+
+// Example: Get information for a specific process name.
+// Replace "my_critical_service" with a name that is likely to match
+// exactly one running process on your system.
+// Common examples might be "Dock" or "Finder" on macOS,
+// "explorer.exe" on Windows, or a specific service name on Linux.
+let target_process_name = "process_name_to_get"; // <--- CHANGE THIS TO A REAL, UNIQUE PROCESS NAME
+
+print(`Attempting to get info for process matching pattern: '${target_process_name}'...`);
+
+// This line will halt if the process is not found OR if multiple processes match the name.
+// It will only proceed if exactly one process is found.
+let service_proc_info = process_get(target_process_name); // Halts on 0 or >1 matches, or OS error
+
+print(`Successfully found exactly one process matching '${target_process_name}':`);
+
+// Access properties of the ProcessInfo object
+print(`- PID: ${service_proc_info.pid}`);
+print(`- Name: ${service_proc_info.name}`);
+print(`- CPU: ${service_proc_info.cpu}%`);
+print(`- Memory: ${service_proc_info.memory}`);
+
+
+// To demonstrate the halting behavior, you could uncomment one of these:
+
+// Example that will halt if "nonexistent_process_xyz" is not running:
+// print("\nAttempting to get a nonexistent process (will halt if not found)...");
+// let nonexistent_proc = process_get("nonexistent_process_xyz"); // This line likely halts
+
+// Example that might halt if "sh" matches multiple processes:
+// print("\nAttempting to get 'sh' (might halt if multiple shell processes exist)...");
+// let sh_proc = process_get("sh"); // This line might halt depending on your system processes
+
+
+print("\nprocess_get() example finished (if the script did not halt above).");

examples/process/process_list.rhai

@@ -0,0 +1,29 @@
+print("Listing processes using process_list()...\n");
+
+// Example: List all processes (use empty string as pattern)
+// print("Listing all running processes (this might be a long list!)...\n");
+// let all_processes = process_list("");
+// print(`Found ${all_processes.len()} total processes.`);
+// // Optional: print details for a few processes
+// for i in 0..min(all_processes.len(), 5) {
+//     let proc = all_processes[i];
+//     print(`- PID: ${proc.pid}, Name: ${proc.name}, CPU: ${proc.cpu}%, Memory: ${proc.memory}`);
+// }
+
+print("Listing processes matching 'bash'...\n");
+
+// Example: List processes matching a pattern
+let pattern_to_list = "bash"; // Or another common process like "SystemSettings" or "Finder" on macOS, "explorer.exe" on Windows, "systemd" on Linux
+let matching_processes = process_list(pattern_to_list); // Halts on OS error during list attempt
+
+if (matching_processes.len() > 0) {
+    print(`Found ${matching_processes.len()} processes matching '${pattern_to_list}':`);
+    for proc in matching_processes {
+        // Access properties of the ProcessInfo object
+        print(`- PID: ${proc.pid}, Name: ${proc.name}, CPU: ${proc.cpu}%, Memory: ${proc.memory}`);
+    }
+} else {
+    print(`No processes found matching '${pattern_to_list}'.`);
+}
+
+print("\nprocess_list() example finished.");

examples/process/run_all_options.rhai

@@ -0,0 +1,36 @@
+print("Running a command using multiple builder options...");
+
+// Example combining log, silent, and ignore_error
+// This command will:
+// 1. Be logged before execution (.log())
+// 2. Have its output suppressed during execution (.silent())
+// 3. Exit with a non-zero code (fail)
+// 4. NOT halt the script execution because .ignore_error() is used
+let result = run("echo 'This is logged and silent stdout'; echo 'This is logged and silent stderr' >&2; exit 5")
+    .log()           // Log the command string
+    .silent()        // Suppress real-time output
+    .ignore_error()  // Prevent script halt on non-zero exit code
+    .execute();           // Execute the command
+
+print("Command execution finished.");
+
+// Print the captured result
+print(`Success: ${result.success}`);     // Should be false
+print(`Exit Code: ${result.code}`);       // Should be 5
+print(`Captured Stdout:\n${result.stdout}`); // Should contain the stdout string
+
+
+// The script continues execution because ignore_error() was used
+print("Script continues after handling the failed command.");
+
+// Another example with a successful command, still silent and logged
+print("\nRunning another command (successful)...");
+let success_result = run("echo 'Success message'").log().silent().execute();
+print(`Command finished.`);
+print(`Success: ${success_result.success}`);   // Should be true
+print(`Exit Code: ${success_result.code}`);     // Should be 0
+print(`Captured Stdout:\n${success_result.stdout}`);
+
+
+
+print("\nrun().execute() all options example finished.");

examples/process/run_basic.rhai

@@ -0,0 +1,18 @@
+print("Running a basic command using run().do()...");
+
+// Execute a simple command
+let result = run("echo Hello from run_basic!").do();
+
+// Print the command result
+print(`Command: echo Hello from run_basic!`);
+print(`Success: ${result.success}`);
+print(`Exit Code: ${result.code}`);
+print(`Stdout:\n${result.stdout}`);
+print(`Stderr:\n${result.stderr}`);
+
+// Example of a command that might fail (if 'nonexistent_command' doesn't exist)
+// This will halt execution by default because ignore_error() is not used.
+// print("Running a command that will fail (and should halt)...");
+// let fail_result = run("nonexistent_command").do(); // This line will cause the script to halt if the command doesn't exist
+
+print("Basic run() example finished.");

examples/process/run_ignore_error.rhai

@@ -0,0 +1,29 @@
+print("Running a command that will fail, but ignoring the error...");
+
+// Run a command that exits with a non-zero code (will fail)
+// Using .ignore_error() prevents the script from halting
+let result = run("exit 1").ignore_error().do();
+
+print(`Command finished.`);
+print(`Success: ${result.success}`); // This should be false
+print(`Exit Code: ${result.code}`);   // This should be 1
+
+// We can now handle the failure in the script
+if (!result.success) {
+    print("Command failed, but we handled it because ignore_error() was used.");
+    // Optionally print stderr if needed
+    // print(`Stderr:\\n${result.stderr}`);
+} else {
+    print("Command unexpectedly succeeded.");
+}
+
+print("\nScript continued execution after the potentially failing command.");
+
+// Example of a command that might fail due to OS error (e.g., command not found)
+// This *might* still halt depending on how the underlying Rust function handles it,
+// as ignore_error() primarily prevents halting on *command* non-zero exit codes.
+// let os_error_result = run("nonexistent_command_123").ignore_error().do();
+// print(`OS Error Command Success: ${os_error_result.success}`);
+// print(`OS Error Command Exit Code: ${os_error_result.code}`);
+
+print("ignore_error() example finished.");

examples/process/run_log.rhai

@@ -0,0 +1,13 @@
+print("Running a command using run().log().do()...");
+
+// The .log() method will print the command string to the console before execution.
+// This is useful for debugging or tracing which commands are being run.
+let result = run("echo This command is logged").log().do();
+
+print(`Command finished.`);
+print(`Success: ${result.success}`);
+print(`Exit Code: ${result.code}`);
+print(`Stdout:\n${result.stdout}`);
+print(`Stderr:\n${result.stderr}`);
+
+print("run().log() example finished.");

examples/process/run_silent.rhai

@@ -0,0 +1,22 @@
+print("Running a command using run().silent().do()...\n");
+
+// This command will print to standard output and standard error
+// However, because .silent() is used, the output will not appear in the console directly
+let result = run("echo 'This should be silent stdout.'; echo 'This should be silent stderr.' >&2; exit 0").silent().do();
+
+// The output is still captured in the CommandResult
+print(`Command finished.`);
+print(`Success: ${result.success}`);
+print(`Exit Code: ${result.code}`);
+print(`Captured Stdout:\\n${result.stdout}`);
+print(`Captured Stderr:\\n${result.stderr}`);
+
+// Example of a silent command that fails (but won't halt because we only suppress output)
+// let fail_result = run("echo 'This is silent failure stderr.' >&2; exit 1").silent().do();
+// print(`Failed command finished (silent):`);
+// print(`Success: ${fail_result.success}`);
+// print(`Exit Code: ${fail_result.code}`);
+// print(`Captured Stdout:\\n${fail_result.stdout}`);
+// print(`Captured Stderr:\\n${fail_result.stderr}`);
+
+print("\nrun().silent() example finished.");

examples/process/which.rhai

@@ -0,0 +1,25 @@
+print("Checking if a command exists in the system PATH using which()...\n");
+
+// Check for a command that likely exists (e.g., 'node' or 'git')
+let command_name_exists = "node";
+let command_path_exists = which(command_name_exists);
+
+if (command_path_exists != "") {
+    print(`'${command_name_exists}' executable found at: ${command_path_exists}`);
+} else {
+    print(`'${command_name_exists}' executable not found in PATH.`);
+}
+
+print("\nChecking for a command that likely does NOT exist...");
+
+// Check for a command that likely does not exist
+let command_name_nonexistent = "nonexistent_command_abc_123";
+let command_path_nonexistent = which(command_name_nonexistent);
+
+if (command_path_nonexistent != "") {
+    print(`'${command_name_nonexistent}' executable found at: ${command_path_nonexistent}`);
+} else {
+    print(`'${command_name_nonexistent}' executable not found in PATH.`);
+}
+
+print("\nwhich() example finished.");

examples/rhai_file_test_dir/append_file.txt

@@ -1,5 +0,0 @@
-Initial content - line 1
-Initial content - line 2
-Appended content - line 3
-Appended content - line 4
-Log entry #1 at \nLog entry #2 at \nLog entry #3 at \n

examples/rhai_file_test_dir/test_file.txt

@@ -1,2 +0,0 @@
-This is the first line of text.
-This is the second line of text.