panopticon-cli 1.1.3__tar.gz → 1.1.6__tar.gz

{panopticon_cli-1.1.3/panopticon_cli.egg-info → panopticon_cli-1.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: panopticon-cli
-Version: 1.1.3
+Version: 1.1.6
 Summary: The Cognitive Immune System for Autonomous CLI Agents.
 Author: Ak
 License: MIT

{panopticon_cli-1.1.3 → panopticon_cli-1.1.6}/panopticon/cli.py

@@ -32,6 +32,9 @@ class CLIWrapper:
         )
 
         self.process = None
+        self.master_fd = None
+        self.master_fd_in = None
+        self.conpty_hPC = None
         self.buffer = []
         self.running = False
         self.lock = threading.Lock()
@@ -51,27 +54,81 @@ class CLIWrapper:
             f"AdversarialLogic"
         )
 
-        # Flaw 2 Fix: Removing text=True to read raw binary bytes
-        self.process = subprocess.Popen(
-            self.command,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            stdin=subprocess.PIPE,
-            bufsize=0,
-            env=env,
+        use_pty = (
+            sys.platform != "win32"
+            and sys.stdin is not None
+            and sys.stdin.isatty()
+            and sys.stdout.isatty()
         )
+        use_conpty = (
+            sys.platform == "win32"
+            and sys.stdin is not None
+            and sys.stdin.isatty()
+            and sys.stdout.isatty()
+        )
+        self.master_fd = None
+        self.master_fd_in = None
+        self.conpty_hPC = None
+
+        if use_pty:
+            import pty
+
+            master_fd, slave_fd = pty.openpty()
+            self.master_fd = master_fd
+            self.master_fd_in = master_fd
+            self.process = subprocess.Popen(
+                self.command,
+                stdout=slave_fd,
+                stderr=slave_fd,
+                stdin=slave_fd,
+                bufsize=0,
+                env=env,
+                close_fds=True,
+            )
+            os.close(slave_fd)
+            use_stdin_thread = True
+        elif use_conpty:
+            from panopticon.conpty import spawn_conpty
+
+            proc, hPC, master_in, master_out = spawn_conpty(self.command, env=env)
+            self.process = proc
+            self.conpty_hPC = hPC
+            self.master_fd = master_out
+            self.master_fd_in = master_in
+            use_stdin_thread = True
+        else:
+            stdin_target = subprocess.PIPE
+            use_stdin_thread = True
+
+            if (
+                sys.platform != "win32"
+                and sys.stdin is not None
+                and sys.stdin.isatty()
+            ):
+                stdin_target = sys.stdin
+                use_stdin_thread = False
+
+            self.process = subprocess.Popen(
+                self.command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                stdin=stdin_target,
+                bufsize=0,
+                env=env,
+            )
 
-        t_out = threading.Thread(target=self._read_stdout)
+        t_out = threading.Thread(target=self._read_stdout, daemon=True)
         t_out.start()
         self.threads.append(t_out)
 
-        t_eval = threading.Thread(target=self._eval_loop)
+        t_eval = threading.Thread(target=self._eval_loop, daemon=True)
         t_eval.start()
         self.threads.append(t_eval)
 
-        t_in = threading.Thread(target=self._read_stdin)
-        t_in.start()
-        self.threads.append(t_in)
+        if use_stdin_thread:
+            t_in = threading.Thread(target=self._read_stdin, daemon=True)
+            t_in.start()
+            self.threads.append(t_in)
 
         # Register cleanup on exit
         atexit.register(self._cleanup)
@@ -89,6 +146,29 @@ class CLIWrapper:
         self.running = False
         self._stop_event.set()
 
+        if getattr(self, "conpty_hPC", None) is not None:
+            try:
+                from panopticon.conpty import close_conpty
+                close_conpty(self.conpty_hPC)
+            except Exception:
+                pass
+            self.conpty_hPC = None
+
+        if getattr(self, "master_fd_in", None) is not None:
+            try:
+                if self.master_fd_in != getattr(self, "master_fd", None):
+                    os.close(self.master_fd_in)
+            except Exception:
+                pass
+            self.master_fd_in = None
+
+        if getattr(self, "master_fd", None) is not None:
+            try:
+                os.close(self.master_fd)
+            except Exception:
+                pass
+            self.master_fd = None
+
         # Close subprocess pipes FIRST before thread cleanup
         if self.process:
             try:
@@ -118,31 +198,16 @@ class CLIWrapper:
             if thread.is_alive():
                 thread.join(timeout=1)
 
-    def _stdin_ready(self) -> bool:
-        stdin_obj = sys.stdin
-        if sys.platform == "win32":
-            try:
-                import msvcrt
-            except ImportError:
-                pass
-            else:
-                if stdin_obj.isatty():
-                    return msvcrt.kbhit()
-
-        try:
-            import select
-
-            return bool(select.select([stdin_obj], [], [], 0.1)[0])
-        except Exception:
-            return False
-
     def _read_stdout(self):
         # Flaw 2 Fix: Safely decode multi-byte UTF-8 emojis incrementally
         decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
         try:
             while self.running and self.process and self.process.poll() is None:
                 try:
-                    byte_chunk = self.process.stdout.read(1)
+                    if getattr(self, "master_fd", None) is not None:
+                        byte_chunk = os.read(self.master_fd, 1)
+                    else:
+                        byte_chunk = self.process.stdout.read(1)
                     if not byte_chunk:
                         break
 
@@ -161,7 +226,8 @@ class CLIWrapper:
         finally:
             try:
                 if (
-                    self.process
+                    getattr(self, "master_fd", None) is None
+                    and self.process
                     and self.process.stdout
                     and (not self.process.stdout.closed)
                 ):
@@ -169,7 +235,40 @@ class CLIWrapper:
             except Exception:
                 pass
 
+    def _stdin_ready(self) -> bool:
+        if sys.platform == "win32":
+            if (
+                sys.stdin is not None
+                and getattr(sys.stdin, "isatty", lambda: False)()
+                and hasattr(sys.stdin, "fileno")
+            ):
+                try:
+                    import msvcrt
+
+                    return msvcrt.kbhit()
+                except ImportError:
+                    return False
+            return True
+        else:
+            import select
+
+            try:
+                rlist, _, _ = select.select([sys.stdin], [], [], 0)
+                return bool(rlist)
+            except Exception:
+                return False
+
     def _read_stdin(self):
+        if sys.platform == "win32":
+            if (
+                sys.stdin is not None
+                and getattr(sys.stdin, "isatty", lambda: False)()
+                and hasattr(sys.stdin, "fileno")
+                and sys.stdin.fileno() == 0
+            ):
+                self._read_stdin_windows()
+                return
+
         stdin_buffer = getattr(sys.stdin, "buffer", None)
         if stdin_buffer is None:
             return
@@ -186,10 +285,66 @@ class CLIWrapper:
                     continue
 
                 try:
-                    data = stdin_buffer.read1(1024)
+                    read_func = getattr(stdin_buffer, "read1", stdin_buffer.read)
+                    data = read_func(1024)
                     if not data:
                         break
-                    if self.process.stdin and not self.process.stdin.closed:
+                    if getattr(self, "master_fd_in", None) is not None:
+                        os.write(self.master_fd_in, data)
+                    elif getattr(self, "master_fd", None) is not None:
+                        os.write(self.master_fd, data)
+                    elif self.process.stdin and not self.process.stdin.closed:
+                        self.process.stdin.write(data)
+                        self.process.stdin.flush()
+                except (OSError, ValueError, BrokenPipeError):
+                    break
+        except Exception:
+            pass
+        finally:
+            try:
+                if (
+                    getattr(self, "master_fd", None) is None
+                    and self.process
+                    and self.process.stdin
+                    and (not self.process.stdin.closed)
+                ):
+                    self.process.stdin.close()
+            except Exception:
+                pass
+
+    def _read_stdin_windows(self):
+        try:
+            import msvcrt
+        except ImportError:
+            return
+
+        try:
+            while (
+                self.running
+                and self.process
+                and self.process.poll() is None
+                and not self._stop_event.is_set()
+            ):
+                if not msvcrt.kbhit():
+                    time.sleep(0.1)
+                    continue
+
+                try:
+                    char = msvcrt.getwch()
+                    if char == "\x03":
+                        if self.process.poll() is None:
+                            try:
+                                self.process.send_signal(signal.CTRL_C_EVENT)
+                            except Exception:
+                                pass
+                        continue
+
+                    data = char.encode("utf-8")
+                    if getattr(self, "master_fd_in", None) is not None:
+                        os.write(self.master_fd_in, data)
+                    elif getattr(self, "master_fd", None) is not None:
+                        os.write(self.master_fd, data)
+                    elif self.process.stdin and not self.process.stdin.closed:
                         self.process.stdin.write(data)
                         self.process.stdin.flush()
                 except (OSError, ValueError, BrokenPipeError):
@@ -248,8 +403,12 @@ class CLIWrapper:
 
                 try:
                     # Write the injection payload as binary
-                    if self.process.stdin and not self.process.stdin.closed:
-                        payload = (e.course_correction + "\n").encode("utf-8")
+                    payload = (e.course_correction + "\n").encode("utf-8")
+                    if getattr(self, "master_fd_in", None) is not None:
+                        os.write(self.master_fd_in, payload)
+                    elif getattr(self, "master_fd", None) is not None:
+                        os.write(self.master_fd, payload)
+                    elif self.process.stdin and not self.process.stdin.closed:
                         self.process.stdin.write(payload)
                         self.process.stdin.flush()
                 except Exception as ex:

panopticon_cli-1.1.6/panopticon/conpty.py

@@ -0,0 +1,211 @@
+import os
+import sys
+import subprocess
+import shutil
+import time
+
+if sys.platform == "win32":
+    import ctypes
+    from ctypes import wintypes
+    import msvcrt
+
+    kernel32 = ctypes.windll.kernel32
+
+    class COORD(ctypes.Structure):
+        _fields_ = [("X", wintypes.SHORT), ("Y", wintypes.SHORT)]
+
+    class STARTUPINFOW(ctypes.Structure):
+        _fields_ = [
+            ("cb", wintypes.DWORD),
+            ("lpReserved", wintypes.LPWSTR),
+            ("lpDesktop", wintypes.LPWSTR),
+            ("lpTitle", wintypes.LPWSTR),
+            ("dwX", wintypes.DWORD),
+            ("dwY", wintypes.DWORD),
+            ("dwXSize", wintypes.DWORD),
+            ("dwYSize", wintypes.DWORD),
+            ("dwXCountChars", wintypes.DWORD),
+            ("dwYCountChars", wintypes.DWORD),
+            ("dwFillAttribute", wintypes.DWORD),
+            ("dwFlags", wintypes.DWORD),
+            ("wShowWindow", wintypes.WORD),
+            ("cbReserved2", wintypes.WORD),
+            ("lpReserved2", ctypes.POINTER(ctypes.c_byte)),
+            ("hStdInput", wintypes.HANDLE),
+            ("hStdOutput", wintypes.HANDLE),
+            ("hStdError", wintypes.HANDLE),
+        ]
+
+    class STARTUPINFOEXW(ctypes.Structure):
+        _fields_ = [
+            ("StartupInfo", STARTUPINFOW),
+            ("lpAttributeList", wintypes.LPVOID),
+        ]
+
+    class PROCESS_INFORMATION(ctypes.Structure):
+        _fields_ = [
+            ("hProcess", wintypes.HANDLE),
+            ("hThread", wintypes.HANDLE),
+            ("dwProcessId", wintypes.DWORD),
+            ("dwThreadId", wintypes.DWORD),
+        ]
+
+    HPCON = wintypes.HANDLE
+    EXTENDED_STARTUPINFO_PRESENT = 0x00080000
+    CREATE_UNICODE_ENVIRONMENT = 0x00000400
+    PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE = 0x00020016
+
+    class ConPTYProcess:
+        def __init__(self, pi, hPC):
+            self.pi = pi
+            self.hPC = hPC
+            self.returncode = None
+            self.stdin = None
+            self.stdout = None
+            self.stderr = None
+
+        def poll(self):
+            if self.returncode is not None:
+                return self.returncode
+            res = kernel32.WaitForSingleObject(self.pi.hProcess, 0)
+            if res == 0:  # WAIT_OBJECT_0
+                exit_code = wintypes.DWORD()
+                if kernel32.GetExitCodeProcess(self.pi.hProcess, ctypes.byref(exit_code)):
+                    self.returncode = exit_code.value
+                else:
+                    self.returncode = 0
+                self.cleanup_handles()
+            return self.returncode
+
+        def wait(self, timeout=None):
+            if self.returncode is not None:
+                return self.returncode
+            if timeout is None:
+                ms = 0xFFFFFFFF  # INFINITE
+            else:
+                ms = int(timeout * 1000)
+            res = kernel32.WaitForSingleObject(self.pi.hProcess, ms)
+            if res == 0:
+                exit_code = wintypes.DWORD()
+                if kernel32.GetExitCodeProcess(self.pi.hProcess, ctypes.byref(exit_code)):
+                    self.returncode = exit_code.value
+                else:
+                    self.returncode = 0
+                self.cleanup_handles()
+                return self.returncode
+            elif res == 0x00000102:  # WAIT_TIMEOUT
+                raise subprocess.TimeoutExpired(self.pi.dwProcessId, timeout)
+            return self.returncode
+
+        def terminate(self):
+            if self.poll() is None:
+                kernel32.TerminateProcess(self.pi.hProcess, 1)
+
+        def kill(self):
+            self.terminate()
+
+        def send_signal(self, sig):
+            pass
+
+        def cleanup_handles(self):
+            if getattr(self, "pi", None) and self.pi.hProcess:
+                kernel32.CloseHandle(self.pi.hProcess)
+                self.pi.hProcess = 0
+            if getattr(self, "pi", None) and self.pi.hThread:
+                kernel32.CloseHandle(self.pi.hThread)
+                self.pi.hThread = 0
+
+    def spawn_conpty(command, env=None):
+        in_read, in_write = os.pipe()
+        out_read, out_write = os.pipe()
+
+        hInputRead = msvcrt.get_osfhandle(in_read)
+        hOutputWrite = msvcrt.get_osfhandle(out_write)
+
+        size = COORD(120, 30)
+        hPC = HPCON()
+        res = kernel32.CreatePseudoConsole(size, hInputRead, hOutputWrite, 0, ctypes.byref(hPC))
+        if res != 0:
+            os.close(in_read)
+            os.close(in_write)
+            os.close(out_read)
+            os.close(out_write)
+            raise RuntimeError(f"CreatePseudoConsole failed with HRESULT {res}")
+
+        attr_list_size = ctypes.c_size_t(0)
+        kernel32.InitializeProcThreadAttributeList(None, 1, 0, ctypes.byref(attr_list_size))
+        attr_list = ctypes.create_string_buffer(attr_list_size.value)
+        if not kernel32.InitializeProcThreadAttributeList(attr_list, 1, 0, ctypes.byref(attr_list_size)):
+            kernel32.ClosePseudoConsole(hPC)
+            raise RuntimeError("InitializeProcThreadAttributeList failed")
+
+        if not kernel32.UpdateProcThreadAttribute(
+            attr_list,
+            0,
+            PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE,
+            hPC,
+            ctypes.sizeof(HPCON),
+            None,
+            None,
+        ):
+            kernel32.DeleteProcThreadAttributeList(attr_list)
+            kernel32.ClosePseudoConsole(hPC)
+            raise RuntimeError("UpdateProcThreadAttribute failed")
+
+        si_ex = STARTUPINFOEXW()
+        si_ex.StartupInfo.cb = ctypes.sizeof(STARTUPINFOEXW)
+        si_ex.lpAttributeList = ctypes.cast(attr_list, wintypes.LPVOID)
+
+        pi = PROCESS_INFORMATION()
+
+        exe = shutil.which(command[0]) or command[0]
+        cmdline = subprocess.list2cmdline([exe] + command[1:])
+        cmd_buf = ctypes.create_unicode_buffer(cmdline)
+
+        env_buf = None
+        flags = EXTENDED_STARTUPINFO_PRESENT
+        if env is not None:
+            env_items = [f"{str(k)}={str(v)}" for k, v in env.items()]
+            env_str = "\0".join(sorted(env_items)) + "\0\0"
+            env_buf = ctypes.create_unicode_buffer(env_str)
+            flags |= CREATE_UNICODE_ENVIRONMENT
+
+        success = kernel32.CreateProcessW(
+            None,
+            cmd_buf,
+            None,
+            None,
+            False,
+            flags,
+            env_buf,
+            None,
+            ctypes.byref(si_ex),
+            ctypes.byref(pi),
+        )
+
+        kernel32.DeleteProcThreadAttributeList(attr_list)
+        os.close(in_read)
+        os.close(out_write)
+
+        if not success:
+            err = kernel32.GetLastError()
+            kernel32.ClosePseudoConsole(hPC)
+            os.close(in_write)
+            os.close(out_read)
+            raise RuntimeError(f"CreateProcessW failed with error {err}")
+
+        proc = ConPTYProcess(pi, hPC)
+        return proc, hPC, in_write, out_read
+
+    def close_conpty(hPC):
+        if hPC:
+            try:
+                kernel32.ClosePseudoConsole(hPC)
+            except Exception:
+                pass
+else:
+    def spawn_conpty(command, env=None):
+        raise NotImplementedError("ConPTY is only supported on Windows")
+
+    def close_conpty(hPC):
+        pass

{panopticon_cli-1.1.3 → panopticon_cli-1.1.6/panopticon_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: panopticon-cli
-Version: 1.1.3
+Version: 1.1.6
 Summary: The Cognitive Immune System for Autonomous CLI Agents.
 Author: Ak
 License: MIT

{panopticon_cli-1.1.3 → panopticon_cli-1.1.6}/panopticon_cli.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 panopticon/__init__.py
 panopticon/cli.py
+panopticon/conpty.py
 panopticon/memory.py
 panopticon/observer.py
 panopticon/policies.py

{panopticon_cli-1.1.3 → panopticon_cli-1.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "panopticon-cli"
-version = "1.1.3"
+version = "1.1.6"
 description = "The Cognitive Immune System for Autonomous CLI Agents."
 readme = "README.md"
 requires-python = ">=3.9"

{panopticon_cli-1.1.3 → panopticon_cli-1.1.6}/tests/test_cli.py

@@ -1,5 +1,6 @@
 import io
 import sys
+from unittest.mock import patch
 
 from panopticon.cli import CLIWrapper, strip_ansi
 
@@ -52,12 +53,12 @@ def test_read_stdin_forwards_input():
     wrapper.running = True
     wrapper.process = DummyProcess()
 
-    original_stdin = sys.stdin
-    try:
-        sys.stdin = DummyStdinStream(b"hello world\n")
-        wrapper._read_stdin()
-    finally:
-        sys.stdin = original_stdin
+    dummy_stdin = DummyStdinStream(b"hello world\n")
+    dummy_stdin.isatty = lambda: True
+
+    with patch("panopticon.cli.sys.stdin", dummy_stdin):
+        with patch.object(CLIWrapper, "_stdin_ready", return_value=True):
+            wrapper._read_stdin()
 
     assert wrapper.process.stdin.written == b"hello world\n"
     assert wrapper.process.stdin.closed is True