@devscholar/node-ps1-dotnet 0.0.0

package/scripts/PsBridge/Protocol.cs

@@ -0,0 +1,222 @@
+
+// scripts/PsBridge/Protocol.cs
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+public static class Protocol
+{
+    public static Dictionary<string, object> ConvertToProtocol(object inputObject)
+    {
+        if (inputObject == null)
+        {
+            return new Dictionary<string, object> { { "type", "null" } };
+        }
+        
+        if (inputObject is bool || inputObject is string)
+        {
+            return new Dictionary<string, object> { { "type", "primitive" }, { "value", inputObject } };
+        }
+
+        if (inputObject.GetType().IsPrimitive)
+        {
+            var val = inputObject;
+            if (val is double || val is float)
+            {
+                double dVal = Convert.ToDouble(val);
+                if (double.IsNaN(dVal) || double.IsInfinity(dVal))
+                {
+                    val = null;
+                }
+            }
+            return new Dictionary<string, object> { { "type", "primitive" }, { "value", val } };
+        }
+
+        if (inputObject is Task)
+        {
+            var refId = Guid.NewGuid().ToString();
+            BridgeState.ObjectStore[refId] = inputObject;
+            return new Dictionary<string, object>
+            {
+                { "type", "task" },
+                { "id", refId },
+                { "netType", inputObject.GetType().FullName }
+            };
+        }
+
+        if (inputObject is Array)
+        {
+            var arr = (Array)inputObject;
+            var arrResult = new List<Dictionary<string, object>>();
+            foreach (var item in arr)
+            {
+                arrResult.Add(ConvertToProtocol(item));
+            }
+            return new Dictionary<string, object> { { "type", "array" }, { "value", arrResult } };
+        }
+
+        var objRefId = Guid.NewGuid().ToString();
+        BridgeState.ObjectStore[objRefId] = inputObject;
+        
+        return new Dictionary<string, object>
+        {
+            { "type", "ref" },
+            { "id", objRefId },
+            { "netType", inputObject.GetType().FullName }
+        };
+    }
+
+    public static object[] ResolveArgs(object argsObj)
+    {
+        var realArgs = new List<object>();
+        
+        IEnumerable<object> cmdArgs = null;
+        if (argsObj is object[])
+        {
+            cmdArgs = ((object[])argsObj);
+        }
+        else if (argsObj is List<object>)
+        {
+            cmdArgs = (List<object>)argsObj;
+        }
+        
+        if (cmdArgs != null)
+        {
+            foreach (var arg in cmdArgs)
+            {
+                var dict = arg as Dictionary<string, object>;
+                if (dict != null && dict.ContainsKey("__ref"))
+                {
+                    realArgs.Add(BridgeState.ObjectStore[dict["__ref"].ToString()]);
+                }
+                else if (dict != null && dict.ContainsKey("type") && dict["type"].ToString() == "callback")
+                {
+                    var cbId = dict["callbackId"].ToString();
+                    
+                    Func<object, object, object, object, object> callback = (p1, p2, p3, p4) =>
+                    {
+                        var netCallbackArgs = new object[] { p1, p2, p3, p4 };
+                        
+                        var validProtoArgs = new List<Dictionary<string, object>>();
+                        foreach (var a in netCallbackArgs)
+                        {
+                            if (a != null)
+                            {
+                                validProtoArgs.Add(ConvertToProtocol(a));
+                            }
+                        }
+
+                        var msg = new Dictionary<string, object>
+                        {
+                            { "type", "event" },
+                            { "callbackId", cbId },
+                            { "args", validProtoArgs }
+                        };
+                        
+                        var json = SimpleJson.Serialize(msg);
+                        
+                        BridgeState.Writer.WriteLine(json);
+                        
+                        object result = null;
+                        try
+                        {
+                            if (PsHost.ProcessNestedCommands != null)
+                            {
+                                result = PsHost.ProcessNestedCommands();
+                            }
+                        }
+                        catch { }
+                        
+                        return result;
+                    };
+                    
+                    realArgs.Add(callback);
+                }
+                else
+                {
+                    realArgs.Add(arg);
+                }
+            }
+        }
+        return realArgs.ToArray();
+    }
+
+    public static void RemoveBridgeObject(string id)
+    {
+        BridgeState.ObjectStore.Remove(id);
+    }
+}
+
+public static class SimpleJson
+{
+    public static string Serialize(object obj)
+    {
+        if (obj == null) return "null";
+        
+        if (obj is Dictionary<string, object>)
+        {
+            var dict = (Dictionary<string, object>)obj;
+            var parts = new List<string>();
+            foreach (var kvp in dict)
+            {
+                parts.Add(string.Format("\"{0}\":{1}", EscapeString(kvp.Key), Serialize(kvp.Value)));
+            }
+            return "{" + string.Join(",", parts.ToArray()) + "}";
+        }
+        
+        if (obj is List<Dictionary<string, object>>)
+        {
+            var list = (List<Dictionary<string, object>>)obj;
+            var parts = new List<string>();
+            foreach (var item in list)
+            {
+                parts.Add(Serialize(item));
+            }
+            return "[" + string.Join(",", parts.ToArray()) + "]";
+        }
+        
+        if (obj is string)
+        {
+            return "\"" + EscapeString((string)obj) + "\"";
+        }
+        
+        if (obj is bool)
+        {
+            return (bool)obj ? "true" : "false";
+        }
+        
+        if (obj == null)
+        {
+            return "null";
+        }
+        
+        if (obj.GetType().IsPrimitive || obj is decimal)
+        {
+            return obj.ToString();
+        }
+        
+        return "\"" + EscapeString(obj.ToString()) + "\"";
+    }
+    
+    private static string EscapeString(string s)
+    {
+        if (s == null) return "";
+        var sb = new StringBuilder();
+        foreach (var c in s)
+        {
+            switch (c)
+            {
+                case '\\': sb.Append("\\\\"); break;
+                case '"': sb.Append("\\\""); break;
+                case '\n': sb.Append("\\n"); break;
+                case '\r': sb.Append("\\r"); break;
+                case '\t': sb.Append("\\t"); break;
+                default: sb.Append(c); break;
+            }
+        }
+        return sb.ToString();
+    }
+}

package/scripts/PsBridge/PsBridge.psd1

@@ -0,0 +1,10 @@
+
+# scripts/PsBridge/PsBridge.psd1
+@{
+    ModuleVersion = '1.0.0'
+    RootModule = 'PsBridge.psm1'
+    FunctionsToExport = '*'
+    CmdletsToExport = '*'
+    VariablesToExport = '*'
+    AliasesToExport = '*'
+}

package/scripts/PsBridge/PsBridge.psm1

@@ -0,0 +1,22 @@
+# scripts/PsBridge/PsBridge.psm1
+$scriptDir = Split-Path $MyInvocation.MyCommand.Path
+
+$csFiles = @(
+    "$scriptDir\BridgeState.cs",
+    "$scriptDir\Protocol.cs",
+    "$scriptDir\Reflection.cs",
+    "$scriptDir\PsHost.cs",
+    "$scriptDir\PsHostEntry.cs"
+)
+
+$referencedAssemblies = @(
+    'System.dll',
+    'System.Core.dll',
+    'System.Windows.Forms.dll',
+    'System.Drawing.dll',
+    'System.Runtime.InteropServices.dll'
+)
+
+Add-Type -Path $csFiles -ReferencedAssemblies $referencedAssemblies
+
+Export-ModuleMember -Function ConvertTo-Protocol, Resolve-Args, Invoke-ReflectionLogic, Remove-BridgeObject -Variable BridgeState

package/scripts/PsBridge/PsHost.cs

@@ -0,0 +1,393 @@
+// scripts/PsBridge/PsHost.cs
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.IO.Pipes;
+using System.Text;
+using System.Threading;
+
+public static class PsHost
+{
+    public static Func<object> ProcessNestedCommands { get; set; }
+
+    public static BlockingCollection<Dictionary<string, object>> CommandQueue = new BlockingCollection<Dictionary<string, object>>();
+    public static BlockingCollection<Dictionary<string, object>> ReplyQueue = new BlockingCollection<Dictionary<string, object>>();
+    public static SynchronizationContext MainSyncContext { get; set; }
+
+    public static object RunProcessNestedCommands()
+    {
+        var queues = new BlockingCollection<Dictionary<string, object>>[] { ReplyQueue, CommandQueue };
+        
+        while (BridgeState.PipeServer != null && BridgeState.PipeServer.IsConnected)
+        {
+            Dictionary<string, object> item;
+            int index = BlockingCollection<Dictionary<string, object>>.TakeFromAny(queues, out item);
+
+            if (index == 0)
+            {
+                if (item != null && item.ContainsKey("result"))
+                {
+                    return item["result"];
+                }
+                return null;
+            }
+            else if (index == 1)
+            {
+                if (item != null)
+                {
+                    ExecuteCommand(item);
+                }
+            }
+        }
+        return null;
+    }
+
+    private static void UpdateSyncContext()
+    {
+        if (SynchronizationContext.Current != null && MainSyncContext != SynchronizationContext.Current)
+        {
+            MainSyncContext = SynchronizationContext.Current;
+        }
+    }
+
+    public static void ExecuteCommand(Dictionary<string, object> cmd)
+    {
+        if (cmd == null) return;
+        
+        try
+        {
+            var result = Reflection.InvokeReflectionLogic(cmd);
+            UpdateSyncContext();
+
+            var json = SimpleJson.Serialize(result);
+            lock (BridgeState.Writer)
+            {
+                BridgeState.Writer.WriteLine(json);
+            }
+        }
+        catch (Exception ex)
+        {
+            UpdateSyncContext();
+            var errMsg = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
+            var errJson = SimpleJson.Serialize(new Dictionary<string, object>
+            {
+                { "type", "error" },
+                { "message", errMsg.Replace("\"", "'") }
+            });
+            lock (BridgeState.Writer)
+            {
+                BridgeState.Writer.WriteLine(errJson);
+            }
+        }
+    }
+
+    public static void DrainCommandQueue(object state)
+    {
+        Dictionary<string, object> cmd;
+        while (CommandQueue.TryTake(out cmd))
+        {
+            UpdateSyncContext();
+            ExecuteCommand(cmd);
+        }
+    }
+
+    public static void StartServer()
+    {
+        // Key change: Changed PipeOptions.None to PipeOptions.Asynchronous
+        // This allows Windows to perform concurrent overlapped I/O on the handle, so reader thread suspension will never block main thread writes!
+        BridgeState.PipeServer = new NamedPipeServerStream(
+            BridgeState.PipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
+        
+        BridgeState.PipeServer.WaitForConnection();
+        BridgeState.Reader = new StreamReader(BridgeState.PipeServer);
+        BridgeState.Writer = new StreamWriter(BridgeState.PipeServer);
+        BridgeState.Writer.AutoFlush = true;
+
+        var readerThread = new Thread(() =>
+        {
+            try
+            {
+                while (BridgeState.PipeServer.IsConnected)
+                {
+                    var line = BridgeState.Reader.ReadLine();
+                    if (line == null) break;
+
+                    var msg = SimpleJsonDeserializer.Deserialize(line) as Dictionary<string, object>;
+                    if (msg == null) continue;
+
+                    if (msg.ContainsKey("type") && msg["type"].ToString() == "reply")
+                    {
+                        ReplyQueue.Add(msg);
+                    }
+                    else
+                    {
+                        CommandQueue.Add(msg);
+                        if (MainSyncContext != null)
+                        {
+                            MainSyncContext.Post(DrainCommandQueue, null);
+                        }
+                    }
+                }
+            }
+            catch { }
+            finally
+            {
+                CommandQueue.CompleteAdding();
+                ReplyQueue.CompleteAdding();
+            }
+        });
+        readerThread.IsBackground = true;
+        readerThread.Start();
+
+        try
+        {
+            foreach (var cmd in CommandQueue.GetConsumingEnumerable())
+            {
+                UpdateSyncContext();
+                ExecuteCommand(cmd);
+            }
+        }
+        catch { }
+
+        Environment.Exit(0);
+    }
+}
+
+// SimpleJsonDeserializer requires no changes, it works as-is...
+public static class SimpleJsonDeserializer
+{
+    private static int _index;
+    private static string _json;
+
+    public static object Deserialize(string json)
+    {
+        _json = json;
+        _index = 0;
+        return ParseValue();
+    }
+
+    private static void SkipWhitespace()
+    {
+        while (_index < _json.Length && char.IsWhiteSpace(_json[_index]))
+        {
+            _index++;
+        }
+    }
+
+    private static object ParseValue()
+    {
+        SkipWhitespace();
+        
+        if (_index >= _json.Length) return null;
+        
+        var c = _json[_index];
+        
+        if (c == 'n')
+        {
+            _index += 4;
+            return null;
+        }
+        
+        if (c == 't')
+        {
+            _index += 4;
+            return true;
+        }
+        
+        if (c == 'f')
+        {
+            _index += 5;
+            return false;
+        }
+        
+        if (c == '"')
+        {
+            return ParseString();
+        }
+        
+        if (c == '{')
+        {
+            return ParseObject();
+        }
+        
+        if (c == '[')
+        {
+            return ParseArray();
+        }
+        
+        if (c == '-' || char.IsDigit(c))
+        {
+            return ParseNumber();
+        }
+        
+        return null;
+    }
+
+    private static string ParseString()
+    {
+        _index++;
+        var start = _index;
+        var result = new StringBuilder();
+        
+        while (_index < _json.Length && _json[_index] != '"')
+        {
+            if (_json[_index] == '\\')
+            {
+                result.Append(_json.Substring(start, _index - start));
+                _index++;
+                if (_index < _json.Length)
+                {
+                    var escaped = _json[_index];
+                    switch (escaped)
+                    {
+                        case '"': result.Append('"'); break;
+                        case '\\': result.Append('\\'); break;
+                        case 'n': result.Append('\n'); break;
+                        case 'r': result.Append('\r'); break;
+                        case 't': result.Append('\t'); break;
+                        default: result.Append(escaped); break;
+                    }
+                    _index++;
+                    start = _index;
+                }
+            }
+            else
+            {
+                _index++;
+            }
+        }
+        
+        result.Append(_json.Substring(start, _index - start));
+        _index++;
+        
+        return result.ToString();
+    }
+
+    private static object ParseNumber()
+    {
+        var start = _index;
+        
+        if (_json[_index] == '-') _index++;
+        
+        while (_index < _json.Length && char.IsDigit(_json[_index]))
+        {
+            _index++;
+        }
+        
+        var isDouble = false;
+        if (_index < _json.Length && _json[_index] == '.')
+        {
+            isDouble = true;
+            _index++;
+            while (_index < _json.Length && char.IsDigit(_json[_index]))
+            {
+                _index++;
+            }
+        }
+        
+        if (_index < _json.Length && (_json[_index] == 'e' || _json[_index] == 'E'))
+        {
+            isDouble = true;
+            _index++;
+            if (_index < _json.Length && (_json[_index] == '+' || _json[_index] == '-'))
+            {
+                _index++;
+            }
+            while (_index < _json.Length && char.IsDigit(_json[_index]))
+            {
+                _index++;
+            }
+        }
+        
+        var numStr = _json.Substring(start, _index - start);
+        
+        if (isDouble)
+        {
+            return double.Parse(numStr, CultureInfo.InvariantCulture);
+        }
+        else
+        {
+            return long.Parse(numStr);
+        }
+    }
+
+    private static Dictionary<string, object> ParseObject()
+    {
+        var result = new Dictionary<string, object>();
+        _index++;
+        
+        SkipWhitespace();
+        
+        if (_index < _json.Length && _json[_index] == '}')
+        {
+            _index++;
+            return result;
+        }
+        
+        while (_index < _json.Length)
+        {
+            SkipWhitespace();
+            
+            var key = ParseString();
+            
+            SkipWhitespace();
+            _index++;
+            
+            var value = ParseValue();
+            
+            result[key] = value;
+            
+            SkipWhitespace();
+            
+            if (_index < _json.Length && _json[_index] == '}')
+            {
+                _index++;
+                break;
+            }
+            
+            if (_index < _json.Length && _json[_index] == ',')
+            {
+                _index++;
+            }
+        }
+        
+        return result;
+    }
+
+    private static List<object> ParseArray()
+    {
+        var result = new List<object>();
+        _index++;
+        
+        SkipWhitespace();
+        
+        if (_index < _json.Length && _json[_index] == ']')
+        {
+            _index++;
+            return result;
+        }
+        
+        while (_index < _json.Length)
+        {
+            var value = ParseValue();
+            result.Add(value);
+            
+            SkipWhitespace();
+            
+            if (_index < _json.Length && _json[_index] == ']')
+            {
+                _index++;
+                break;
+            }
+            
+            if (_index < _json.Length && _json[_index] == ',')
+            {
+                _index++;
+            }
+        }
+        
+        return result;
+    }
+}

package/scripts/PsBridge/PsHostEntry.cs

@@ -0,0 +1,23 @@
+// scripts/PsBridge/PsHostEntry.cs
+using System;
+
+public static class PsHostEntry
+{
+    public static void Run(string pipeName)
+    {
+        BridgeState.PipeName = pipeName;
+        PsHost.ProcessNestedCommands = PsHost.RunProcessNestedCommands;
+        
+        try
+        {
+            PsHost.StartServer();
+        }
+        finally
+        {
+            if (BridgeState.PipeServer != null)
+            {
+                BridgeState.PipeServer.Dispose();
+            }
+        }
+    }
+}