psmux 3.3.4

Terminal multiplexer for Windows - tmux alternative for PowerShell and Windows Terminal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;

// Batch keystroke injector for issue #237.
// Sends ALL characters in a SINGLE WriteConsoleInput call so they arrive
// in the same console input buffer read cycle. This triggers psmux's
// stage2 paste heuristic (>=3 chars in <20ms).
//
// Usage: injector_batch.exe <pid> <chars>
// Example: injector_batch.exe 1234 ABCDEFGHIJ
//
// Unlike injector.cs, there is NO Thread.Sleep between characters.
// All KEY_EVENT records are batched into one WriteConsoleInput call.

class BatchInjector
{
    [DllImport("kernel32.dll", SetLastError = true)]
    static extern bool FreeConsole();

    [DllImport("kernel32.dll", SetLastError = true)]
    static extern bool AttachConsole(uint pid);

    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    static extern IntPtr CreateFileW(string name, uint access, uint share,
        IntPtr sec, uint disp, uint flags, IntPtr tmpl);

    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    static extern bool WriteConsoleInput(IntPtr h, INPUT_RECORD[] buf, uint len, out uint written);

    [DllImport("user32.dll")]
    static extern uint MapVirtualKeyW(uint code, uint mapType);

    const ushort KEY_EVENT = 1;
    const uint SHIFT_PRESSED = 0x0010;

    [StructLayout(LayoutKind.Sequential)]
    struct KEY_EVENT_RECORD
    {
        public int bKeyDown;
        public ushort wRepeatCount;
        public ushort wVirtualKeyCode;
        public ushort wVirtualScanCode;
        public char UnicodeChar;
        public uint dwControlKeyState;
    }

    [StructLayout(LayoutKind.Explicit)]
    struct INPUT_RECORD
    {
        [FieldOffset(0)] public ushort EventType;
        [FieldOffset(4)] public KEY_EVENT_RECORD KeyEvent;
    }

    static INPUT_RECORD MakeKey(bool down, ushort vk, char ch, uint ctrl)
    {
        var r = new INPUT_RECORD();
        r.EventType = KEY_EVENT;
        r.KeyEvent.bKeyDown = down ? 1 : 0;
        r.KeyEvent.wRepeatCount = 1;
        r.KeyEvent.wVirtualKeyCode = vk;
        r.KeyEvent.wVirtualScanCode = (ushort)MapVirtualKeyW(vk, 0);
        r.KeyEvent.UnicodeChar = ch;
        r.KeyEvent.dwControlKeyState = ctrl;
        return r;
    }

    static int Main(string[] args)
    {
        var log = new List<string>();
        string logFile = Path.Combine(Path.GetTempPath(), "psmux_batch_inject.log");

        if (args.Length < 2)
        {
            File.WriteAllText(logFile, "Usage: injector_batch.exe <pid> <chars>\n");
            return 99;
        }

        uint pid;
        if (!uint.TryParse(args[0], out pid))
        {
            File.WriteAllText(logFile, "Invalid PID: " + args[0]);
            return 98;
        }

        string chars = string.Join(" ", args, 1, args.Length - 1);
        log.Add("PID=" + pid + " Chars=" + chars + " Count=" + chars.Length);

        FreeConsole();
        if (!AttachConsole(pid))
        {
            log.Add("AttachConsole FAILED err=" + Marshal.GetLastWin32Error());
            File.WriteAllText(logFile, string.Join("\n", log));
            return 2;
        }

        IntPtr handle = CreateFileW("CONIN$", 0xC0000000u, 3, IntPtr.Zero, 3, 0, IntPtr.Zero);
        if (handle == new IntPtr(-1))
        {
            log.Add("CreateFile(CONIN$) FAILED err=" + Marshal.GetLastWin32Error());
            FreeConsole();
            File.WriteAllText(logFile, string.Join("\n", log));
            return 3;
        }
        log.Add("Handle=" + handle);

        // Build ALL key events in one array (press+release for each char)
        var records = new List<INPUT_RECORD>();
        foreach (char c in chars)
        {
            ushort vk;
            uint ctrl = 0;

            if (c >= 'a' && c <= 'z') vk = (ushort)(0x41 + c - 'a');
            else if (c >= 'A' && c <= 'Z') { vk = (ushort)(0x41 + c - 'A'); ctrl = SHIFT_PRESSED; }
            else if (c >= '0' && c <= '9') vk = (ushort)(0x30 + c - '0');
            else if (c == ' ') vk = 0x20;
            else if (c == '-') vk = 0xBD;
            else if (c == '_') { vk = 0xBD; ctrl = SHIFT_PRESSED; }
            else if (c == '.') vk = 0xBE;
            else if (c == '\r' || c == '\n') vk = 0x0D;
            else vk = (ushort)c;

            char outChar = (c == '\n') ? '\r' : c;
            records.Add(MakeKey(true, vk, outChar, ctrl));
            records.Add(MakeKey(false, vk, outChar, 0));
        }

        // Send ALL records in ONE WriteConsoleInput call
        var arr = records.ToArray();
        uint written;
        bool ok = WriteConsoleInput(handle, arr, (uint)arr.Length, out written);
        int err = ok ? 0 : Marshal.GetLastWin32Error();
        log.Add(string.Format("Batch write: {0} records, ok={1}, written={2}, err={3}",
            arr.Length, ok, written, err));

        FreeConsole();
        File.WriteAllText(logFile, string.Join("\n", log));
        return ok ? 0 : 1;
    }
}