sshscript 5.0.0__py3-none-any.whl → 6.0.0__py3-none-any.whl

sshscript/__init__.py

@@ -59,6 +59,7 @@ run_file = sshscript.run_file
 check_file = sshscript.check_file
 run_script = sshscript.run_script
 Session = session.Session
+ScriptResult = session.ScriptResult
 CommandResult = session.CommandResult
 CommandJob = session.CommandJob
 CommandTimeoutError = session.CommandTimeoutError
@@ -89,6 +90,7 @@ __all__ = [
     'run_script',
     'Session',
     'CommandResult',
+    'ScriptResult',
     'CommandJob',
     'CommandTimeoutError',
     'JobResult',

sshscript/__init__.pyi

@@ -1,6 +1,7 @@
 from typing import Any, ContextManager
 from os import PathLike
 from .session import Session as Session
+from .scriptcontrol import ScriptResult as ScriptResult
 from .commandresult import CommandResult as CommandResult
 from .commandjob import CommandJob as CommandJob, JobResult as JobResult, CommandTimeoutError as CommandTimeoutError
 from .errorutils import SSHScriptException as SSHScriptException
@@ -9,7 +10,7 @@ __version__: str
 
 def check_file(script_path: str | PathLike[str]) -> int: ...
 def run_file(script_path: str | PathLike[str], vars: dict[str, Any] | None = ..., showScript: bool = ...) -> int: ...
-def run_script(script: str, varGlobals: dict[str, Any] | None = ..., showScript: bool = ...) -> dict[str, Any]: ...
+def run_script(script: str, varGlobals: dict[str, Any] | None = ..., showScript: bool = ...) -> ScriptResult: ...
 def spy_imports() -> ContextManager[None]: ...
 def get_logger() -> Any: ...
 def set_logger(userlogger: Any = ..., logname: str | None = ...) -> Any: ...

sshscript/_version.py

@@ -1,3 +1,3 @@
 """Single source of the SSHScript package version."""
 
-__version__ = "5.0.0"
+__version__ = "6.0.0"

sshscript/channelgeneric.py

@@ -1492,6 +1492,11 @@ class GenericChannel(object):
         Existing newlines are retained. Use send() to write exact text instead.
         A readiness/silence status does not establish command success.
         """
+        return self._input_text(text, timeout=timeout, append_newline=True)
+
+    def _input_text(self, text, timeout=60, *, append_newline=True):
+        """Shared interactive protocol for lines and raw terminal control bytes."""
+        payload = text + ('\n' if append_newline else '') if isinstance(text, str) else text
         if not isinstance(text, str):
             raise TypeError('input text must be str')
 
@@ -1504,7 +1509,7 @@ class GenericChannel(object):
             )
 
         if not self.hijacked:
-            return self.send(text + '\n', timeout=timeout)
+            return self.send(payload, timeout=timeout)
 
         deadline = time.monotonic() + timeout
         executing_lock = self.executing_lock
@@ -1555,7 +1560,7 @@ class GenericChannel(object):
                 stderr.set_callback(prompt_found, current_prompt)
 
             self.send(
-                text + '\n',
+                payload,
                 timeout=self._remaining(deadline),
             )
 

sshscript/dollarparser.py

@@ -138,7 +138,7 @@ def _token_syntax_error(error, script_path, spyscript):
     return _source_syntax_error(synthetic, script_path, spyscript)
 
 
-def parse(script_path, spyscript):
+def parse(script_path, spyscript, *, preprocess=None):
     """Return a transformed AST whose locations still refer to *spyscript*."""
     _cache_source(script_path, spyscript)
     try:
@@ -156,6 +156,8 @@ def parse(script_path, spyscript):
         raise _source_syntax_error(error, script_path, spyscript) from None
 
     try:
+        if preprocess is not None:
+            tree = preprocess.visit(tree)
         py_tree = DollarChanger().visit(tree)
         return ast.fix_missing_locations(py_tree)
     except Exception as error:

sshscript/errorutils.py

@@ -32,13 +32,6 @@ class SSHScriptException(Exception):
     def __str__(self):
         return f'{self.message}(#{self.errno})'
 
-class SSHScriptBreak(SSHScriptException):
-    """Control-flow signal for $.break(status), handled by the script runner."""
-    pass
-
-class SSHScriptExit(SSHScriptException):
-    """Control-flow signal for $.exit(status), propagated to the command-line runner."""
-    pass
 
 def dumpScript(source,tb_lineno=None,linerange=10):
     """Print source with line numbers and optional error-line context."""

sshscript/interactive.py

@@ -0,0 +1,606 @@
+"""Persistent text console for humans and agents using a retained terminal session."""
+import argparse
+import ast
+import builtins
+import code
+from io import StringIO
+import tokenize
+from contextlib import ExitStack, redirect_stdout, redirect_stderr
+from dataclasses import dataclass
+from getpass import getpass
+import sys
+import time
+import subprocess
+
+if __package__:
+    from . import dollarparser, tokenparser, patching
+    from .session import Session
+else:
+    import dollarparser, tokenparser, patching
+    from session import Session
+
+
+class _LeaveLayer(BaseException):
+    pass
+
+
+class _QuitConsole(BaseException):
+    pass
+
+
+class _ConsoleSyntax(ast.NodeTransformer):
+    """Route prompt-level dollar syntax through the environment manager.
+
+    Lexical with blocks retain the normal .spy compiler's context ownership.
+    Generated names are changed as AST nodes, never by replacing source strings.
+    """
+    def __init__(self):
+        self.lexical_depth = 0
+
+    def visit_With(self, node):
+        self.lexical_depth += 1
+        try:
+            return self.generic_visit(node)
+        finally:
+            self.lexical_depth -= 1
+
+    visit_AsyncWith = visit_With
+
+    def visit_Name(self, node):
+        if not self.lexical_depth and node.id in ('_sshscript_in_context_', '_c'):
+            return ast.copy_location(ast.Name(id='_console_control_', ctx=node.ctx), node)
+        return node
+
+    def visit_Call(self, node):
+        if (not self.lexical_depth and isinstance(node.func, ast.Name)
+                and node.func.id in ('exec_command', 'onedollar', 'twodollars')):
+            node.func = ast.copy_location(ast.Attribute(
+                value=ast.Name(id='_console_control_', ctx=ast.Load()),
+                attr='exec_command', ctx=ast.Load()), node.func)
+        return self.generic_visit(node)
+
+    def visit_Expr(self, node):
+        raw_command = (isinstance(node.value, ast.Call)
+                       and isinstance(node.value.func, ast.Name)
+                       and node.value.func.id in ('exec_command', 'onedollar', 'twodollars'))
+        node = self.generic_visit(node)
+        if raw_command:
+            # A raw shell line displays its output, not a JobResult repr.
+            return ast.copy_location(ast.Assign(
+                targets=[ast.Name(id='result', ctx=ast.Store())], value=node.value), node)
+        return node
+
+
+class _PythonConsole(code.InteractiveConsole):
+    def __init__(self, namespace):
+        super().__init__(namespace)
+        self.cell = 1
+
+    def runsource(self, source, filename='<input>', symbol='single'):
+        filename = f'<sshscript-console-{self.cell}>'
+        try:
+            try:
+                compiled = self.compile(source, filename, symbol)
+            except SyntaxError:
+                # Use the existing tokenizer/compiler for dollar syntax, including
+                # properties inside Python expressions and f-strings.
+                try:
+                    translated = tokenparser.convert(source)
+                except tokenize.TokenError as error:
+                    if error.args[0] in ('EOF in multi-line statement',
+                                         'EOF in multi-line string',
+                                         'unexpected EOF in multi-line statement',
+                                         'unexpected EOF in multi-line string'):
+                        # Older tokenizers also report EOF after an unmatched
+                        # closing delimiter. That is invalid, not unfinished.
+                        delimiters = []
+                        pairs = {')': '(', ']': '[', '}': '{'}
+                        try:
+                            for token in tokenize.generate_tokens(StringIO(source).readline):
+                                if token.type != tokenize.OP:
+                                    continue
+                                if token.string in ('(', '[', '{'):
+                                    delimiters.append(token.string)
+                                elif token.string in pairs:
+                                    if not delimiters or delimiters.pop() != pairs[token.string]:
+                                        diagnostic = SyntaxError(
+                                            f'unmatched {token.string!r}',
+                                            (filename, token.start[0], token.start[1] + 1, None))
+                                        raise dollarparser._source_syntax_error(
+                                            diagnostic, filename, source) from None
+                        except tokenize.TokenError:
+                            pass
+                        return True
+                    raise dollarparser._token_syntax_error(error, filename, source) from None
+                try:
+                    compiled = self.compile(translated, filename, symbol)
+                except SyntaxError as error:
+                    raise dollarparser._source_syntax_error(error, filename, source) from None
+                if compiled is not None:
+                    tree = dollarparser.parse(filename, source, preprocess=_ConsoleSyntax())
+                    # The script compiler adds stack setup; keep future imports
+                    # before that setup when compiling an interactive cell.
+                    futures = [n for n in tree.body if isinstance(n, ast.ImportFrom)
+                               and n.module == '__future__']
+                    body = futures + [n for n in tree.body if n not in futures]
+                    tree = ast.Interactive(body=body) if symbol == 'single' else ast.Module(body=body, type_ignores=[])
+                    compiled = compile(ast.fix_missing_locations(tree), filename, symbol,
+                                       flags=self.compile.compiler.flags)
+            if compiled is None:
+                return True
+        except (SyntaxError, OverflowError, ValueError):
+            self.cell += 1
+            self.showsyntaxerror(filename)
+            return False
+        self.cell += 1
+        self.runcode(compiled)
+        return False
+
+    def runcode(self, code_object):
+        try:
+            exec(code_object, self.locals)
+        except (_LeaveLayer, _QuitConsole, SystemExit, KeyboardInterrupt):
+            raise
+        except BaseException as error:
+            self.locals['error'] = error
+            if isinstance(error, NameError):
+                self.write(f'{type(error).__name__}: {error}\n')
+            else:
+                # Do not echo credential-bearing source or arbitrary server text.
+                self.write(f'{type(error).__name__}: operation failed; inspect error for details.\n')
+
+
+@dataclass
+class _Layer:
+    resources: ExitStack
+    session: Session
+    console: object
+    kind: str
+    host: str
+    user: str
+    result: object = None
+    program_buffers: tuple = ()
+    program_positions: tuple = (0, 0)
+
+
+class InteractiveConsole:
+    """Own a stack of connection/console contexts and a persistent Python namespace.
+
+    All context entry and exit occurs on the calling thread. No input history is
+    persisted. Connections under sudo/su are rejected rather than implying that
+    the SSH Session has adopted the console's effective identity or key files.
+    """
+    def __init__(self, *, stdout=None, stderr=None, input_func=None,
+                 password_func=None, session_factory=Session):
+        self._stdout = stdout or sys.stdout
+        self._stderr = stderr or sys.stderr
+        self.input_func = input_func or input
+        self.password_func = password_func or getpass
+        self.session_factory = session_factory
+        self.layers = []
+        self.namespace = {'__name__': '__console__', 'getpass': self.password_func,
+                          'control': self, '_console_control_': self,
+                          'patching': patching, 'result': None, 'error': None}
+        self._helpers = {'help': self.help, 'exit': self._exit_layer, 'quit': self.quit}
+        self.namespace.update(self._helpers)
+        self.python = _PythonConsole(self.namespace)
+        self.more = False
+        self.done = False
+
+    @property
+    def current(self):
+        if not self.layers:
+            raise RuntimeError('console is not open')
+        return self.layers[-1]
+
+    def _refresh(self):
+        self.namespace.update(session=self.current.session,
+                              console=self.current.console,
+                              _sshscript_session_=self.current.session)
+
+    def _push(self, resources, session, console, kind, host, *, program=False):
+        user = '?' if program else console('id -un', check=True).stdout.strip()
+        self.layers.append(_Layer(resources.pop_all(), session, console, kind, host, user))
+        self._refresh()
+
+    def open(self, host=None, **options):
+        if self.layers or self.done:
+            raise RuntimeError('console has already been opened')
+        with ExitStack() as resources:
+            local = self.session_factory()
+            resources.callback(local.close, strict=True)
+            resources.enter_context(local)
+            local.set(verbose=False, verbose_stderr=False, check=False)
+            shell = resources.enter_context(local.shell('bash'))
+            self._push(resources, local, shell, 'local', 'local')
+        try:
+            if host is not None:
+                self.connect(host, **options)
+        except BaseException:
+            self.close()
+            raise
+        return self
+
+    def connect(self, *args, **kwargs):
+        layer = self.current
+        if layer.kind not in ('local', 'ssh'):
+            raise RuntimeError('leave the current sudo/su/shell/program layer before connect(); SSH credentials belong to the connection Session')
+        with ExitStack() as resources:
+            remote = layer.session.connect(*args, **kwargs)
+            resources.callback(remote.close, strict=True)
+            resources.enter_context(remote)
+            remote.set(verbose=False, verbose_stderr=False, check=False)
+            shell = resources.enter_context(remote.shell('bash'))
+            self._push(resources, remote, shell, 'ssh', remote.host or '?')
+
+    def _console_layer(self, kind, *args, **kwargs):
+        layer = self.current
+        if layer.kind == 'program':
+            raise RuntimeError('leave the interactive program before entering another layer')
+        with ExitStack() as resources:
+            console = resources.enter_context(getattr(layer.console, kind)(*args, **kwargs))
+            self._push(resources, layer.session, console,
+                       'program' if kind == 'enter' else kind, layer.host,
+                       program=kind == 'enter')
+        if kind == 'enter':
+            self._drain_program()
+
+    def shell(self, *args, **kwargs):
+        self._console_layer('shell', *args, **kwargs)
+
+    def _identity_layer(self, kind, *args, **kwargs):
+        if 'password' not in kwargs:
+            # su's first positional argument is username; sudo's is password.
+            supplied_positionally = len(args) >= (2 if kind == 'su' else 1)
+            if not supplied_positionally:
+                if self.password_func is getpass and not sys.stdin.isatty():
+                    raise ValueError('provide password explicitly (password=None for passwordless authentication) when stdin is not a terminal')
+                kwargs['password'] = self.password_func(kind + ' password: ')
+        self._console_layer(kind, *args, **kwargs)
+
+    def sudo(self, *args, **kwargs):
+        self._identity_layer('sudo', *args, **kwargs)
+
+    def su(self, *args, **kwargs):
+        self._identity_layer('su', *args, **kwargs)
+
+    def enter(self, *args, **kwargs):
+        """Explicitly enter a text program; configure its prompt and exit text."""
+        self._console_layer('enter', *args, **kwargs)
+
+    def _exit_layer(self):
+        raise _LeaveLayer()
+
+    def quit(self):
+        """Unwind Python contexts before closing every managed layer."""
+        raise _QuitConsole()
+
+    def help(self, *args, **kwargs):
+        if not args and not kwargs:
+            self._write(HELP + '\n', self._stdout)
+            return None
+        return builtins.help(*args, **kwargs)
+
+    def _bare_helper(self, line):
+        try:
+            node = ast.parse(line, mode='eval').body
+        except SyntaxError:
+            return None
+        if self.current.kind == 'program':
+            if (isinstance(node, ast.Call) and not node.args and not node.keywords
+                    and isinstance(node.func, ast.Name) and node.func.id in ('exit', 'quit')):
+                node = node.func
+            if not isinstance(node, ast.Name) or node.id not in ('exit', 'quit'):
+                return None
+        if (isinstance(node, ast.Name) and node.id in self._helpers
+                and self.namespace.get(node.id) is self._helpers[node.id]):
+            return node.id
+        return None
+
+    def stop(self, *args, **kwargs):
+        return self.current.session.stop(*args, **kwargs)
+
+    def run(self, source, vars=None, showScript=False):
+        """Run a script in the current connection Session; stop returns here."""
+        if vars is None:
+            vars = dict(self.namespace)
+            # Console convenience helpers must not change a child script's
+            # ordinary Python exit()/quit()/help() semantics.
+            for name, helper in self._helpers.items():
+                if vars.get(name) is helper:
+                    del vars[name]
+        return self.current.session.run(source, vars, showScript)
+
+    def run_file(self, path, **kwargs):
+        if __package__:
+            from .sshscript import run_file
+        else:
+            from sshscript import run_file
+        return run_file(path, **kwargs)
+
+    def __getattr__(self, name):
+        # Non-environment operations keep the regular API's session/console owner.
+        if name in ('upload', 'download', 'pkey', 'set', 'get'):
+            return getattr(self.current.session, name)
+        if name in ('send', 'input', 'expect', 'start'):
+            return getattr(self.current.console, name)
+        if name in ('stdout', 'stderr', 'exitcode'):
+            if self.current.kind == 'program':
+                return getattr(self.current.console, name)
+            result = self.current.result
+            return getattr(result, name) if result is not None else (None if name == 'exitcode' else '')
+        raise AttributeError(name)
+
+    def leave(self):
+        layer = self.layers.pop()
+        try:
+            layer.resources.close()
+        finally:
+            if self.layers:
+                self._refresh()
+            else:
+                self.done = True
+                self.namespace.update(session=None, console=None)
+
+    def close(self):
+        failures = []
+        while self.layers:
+            try:
+                self.leave()
+            except BaseException as error:
+                failures.append(error)
+        self.done = True
+        if failures:
+            raise BaseExceptionGroup('console cleanup failed', failures)
+
+    def _write(self, text, stream):
+        if text:
+            stream.write(text)
+            stream.flush()
+
+    def exec_command(self, command, *, check=None, timeout=None,
+                     capture_limit=8 * 1024 * 1024, stop_timeout=3):
+        """Execute a dollar command in the current shell and retain its snapshot."""
+        enabled = self.current.session.check if check is None else check
+        if not isinstance(enabled, bool):
+            raise TypeError('check must be bool')
+        result = self._command(command, timeout=timeout, capture_limit=capture_limit,
+                               stop_timeout=stop_timeout)
+        if (enabled and result is not None and result.stop_reason == 'completed'
+                and result.exitcode != 0):
+            error = subprocess.CalledProcessError(result.exitcode, command,
+                                                 output=result.stdout, stderr=result.stderr)
+            error.result = result
+            raise error
+        return result
+
+    def _command(self, line, *, timeout=None, capture_limit=8 * 1024 * 1024,
+                 stop_timeout=3):
+        if self.current.kind == 'program':
+            outcome = self.current.console.input(line)
+            self._drain_program()
+            if outcome == 'exited':
+                self.leave()
+            return
+        # Managed foreground jobs retain shell state, stream output and recover
+        # the parent shell after Ctrl-C. Completion is never inferred from silence.
+        job = self.current.console.start(line, timeout=timeout, capture_limit=capture_limit,
+                                         stop_timeout=stop_timeout, check=False)
+        positions = [0, 0]
+        def drain():
+            for index, (text, stream) in enumerate(((job.stdout, self._stdout),
+                                                   (job.stderr, self._stderr))):
+                self._write(text[positions[index]:], stream)
+                positions[index] = len(text)
+        try:
+            while not job.done:
+                drain()
+                time.sleep(0.03)
+            result = job.wait()
+        except KeyboardInterrupt:
+            result = job.stop()
+            self._write('\nKeyboardInterrupt\n', self._stderr)
+        finally:
+            drain()
+        self.namespace['result'] = self.current.result = result
+        if result.exitcode not in (0, None):
+            self._write(f'[exit {result.exitcode}]\n', self._stderr)
+        if result.stdout_truncated or result.stderr_truncated:
+            self._write('[output capture limit reached]\n', self._stderr)
+        return result
+
+    def _drain_program(self):
+        layer = self.current
+        channel = layer.console.channel
+        buffers = (channel._stdout, channel._stderr)
+        positions = []
+        for index, (buffer, stream) in enumerate(zip(buffers, (self._stdout, self._stderr))):
+            text = str(buffer)
+            previous = (layer.program_positions[index]
+                        if layer.program_buffers and layer.program_buffers[index] is buffer
+                        else 0)
+            visible = text[previous:]
+            if (channel._interactive_layer_exited(channel.executing_lock)
+                    and len(channel.prompts) > 1):
+                parent_prompt = channel.prompts[-2]
+                if isinstance(parent_prompt, str):
+                    visible = visible.replace(parent_prompt, '')
+            self._write(visible, stream)
+            positions.append(len(text))
+        layer.program_buffers = buffers
+        layer.program_positions = tuple(positions)
+
+    def _program_control(self, character):
+        """Send Ctrl-C/D without a newline and observe the program's real prompts."""
+        self._drain_program()
+        channel = self.current.console.channel
+        try:
+            outcome = channel._input_text(character, timeout=2, append_newline=False)
+        except TimeoutError:
+            # A program may ignore the control byte. Do not invent an exit.
+            outcome = None
+        self._drain_program()
+        if outcome == 'exited':
+            self.leave()
+
+    def _interrupt(self):
+        self.python.resetbuffer()
+        self.more = False
+        if self.layers and self.current.kind == 'program':
+            self._program_control('\x03')
+        else:
+            self._write('\nKeyboardInterrupt\n', self._stderr)
+
+    def _eof(self):
+        if self.layers and self.current.kind == 'program':
+            self._program_control('\x04')
+        else:
+            self.python.resetbuffer()
+            self.more = False
+            self.close()
+
+    def _discard_failed_layers(self):
+        while self.layers:
+            channel = self.current.console.channel
+            if not channel.closed and getattr(channel, '_state', None) not in ('failed', 'closed'):
+                break
+            self._write('Current shell is unavailable; leaving its environment.\n', self._stderr)
+            try:
+                self.leave()
+            except Exception as error:
+                self._write('Cleanup failed: ' + type(error).__name__ + '\n', self._stderr)
+
+    def execute(self, line):
+        """Process one input line; variables and contexts survive later calls."""
+        if self.done:
+            return
+        try:
+            helper = self._bare_helper(line) if not self.more else None
+            if helper == 'quit':
+                self.quit()
+            elif helper == 'help':
+                self.help()
+            elif helper == 'exit':
+                self._exit_layer()
+            elif not self.more and line.strip() == ':quit':
+                self.close()
+            elif not self.more and line.strip() == ':help':
+                self._write(HELP + '\n', self._stdout)
+            elif not self.more and line.strip() == ':status':
+                for layer in self.layers:
+                    self._write(f'{layer.kind}: {layer.host} [{layer.user}]\n', self._stdout)
+                self._write('Transfers and SSH credentials use the connection account.\n', self._stdout)
+            elif (not self.more and self.current.kind == 'program'
+                  and not line.lstrip().startswith('$.')):
+                self._command(line)
+            else:
+                with redirect_stdout(self._stdout), redirect_stderr(self._stderr):
+                    self.more = self.python.push(line)
+        except _QuitConsole:
+            self.python.resetbuffer()
+            self.more = False
+            self.close()
+        except KeyboardInterrupt:
+            self._interrupt()
+        except _LeaveLayer:
+            self.python.resetbuffer()
+            self.more = False
+            self.leave()
+        except SystemExit as error:
+            self.python.resetbuffer()
+            self.more = False
+            self._write(f'Python/script exited ({error.code}); console remains open.\n', self._stderr)
+        finally:
+            self._discard_failed_layers()
+
+    @property
+    def prompt(self):
+        if self.more:
+            return '... '
+        layer = self.current
+        suffix = ' program' if layer.kind == 'program' else ''
+        return f'{layer.host} [{layer.user}]{suffix}> '
+
+    def interact(self):
+        if self.input_func is builtins.input and sys.stdin.isatty():
+            # Python loads readline for its own REPL, but not when running a
+            # script. Enable terminal editing before our first input() call.
+            try:
+                import readline  # noqa: F401
+            except ImportError:
+                pass  # Minimal Python builds retain input()'s basic editing.
+        self._write('SSHScript console. Type help for commands; quit to finish.\n', self._stdout)
+        try:
+            while not self.done:
+                try:
+                    line = self.input_func(self.prompt)
+                except EOFError:
+                    self._eof()
+                    continue
+                except KeyboardInterrupt:
+                    self._interrupt()
+                    continue
+                try:
+                    self.execute(line)
+                except KeyboardInterrupt:
+                    self._interrupt()
+                except Exception as error:
+                    # Avoid echoing credential-bearing expressions or arbitrary
+                    # server error text; the original exception is available as error.
+                    self.namespace['error'] = error
+                    self._write('Operation failed (' + type(error).__name__ + '). Use :status or inspect error.\n', self._stderr)
+        finally:
+            self.close()
+
+
+HELP = '''Input is Python with SSHScript dollar syntax; variables persist between inputs.
+$hostname executes a command in the current persistent Bash shell.
+print($.stdout), $.stderr and $.exitcode inspect the last dollar-command result.
+$.connect(host, **options) connects and automatically enters a persistent shell.
+$.sudo(password=...), $.su("user", password=...) enter identity layers.
+$.shell("bash") enters a nested shell.
+$.enter("python3 -q", prompt=">>>", exit="quit()") enters a text program.
+exit / exit() leave one layer; at the local root they end the console.
+Use Python multiline blocks with a blank line to execute, just like a Python REPL.
+Python names: session (connection), console (current identity), result, error, getpass.
+$.run(source) / $.run_file(path) execute scripts; $.stop() ends only that script.
+help / help() show this guide; help(object) shows Python object documentation.
+quit / quit() close all layers. $.exit() is not available.
+:status shows the environment stack. Ctrl-C cancels current input or execution.
+Ctrl-D at the Python prompt closes the console. In enter(), Ctrl-C/D go to the program.
+:help and :quit remain aliases.
+Inside enter(), plain input goes to that program; $. expressions remain controls.
+No input history is persisted. Full-screen programs are not supported in this preview.'''
+
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog='sshscript console', description=HELP,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('host', nargs='?')
+    parser.add_argument('--username')
+    parser.add_argument('--port', type=int)
+    parser.add_argument('--pkey-path')
+    parser.add_argument('--timeout', type=float)
+    parser.add_argument('--ssh-config')
+    parser.add_argument('--known-hosts', choices=('local', 'parent', 'chain'))
+    parser.add_argument('--known-hosts-path')
+    parser.add_argument('--ask-pass', action='store_true')
+    args = parser.parse_args(argv)
+    options = {name: value for name, value in vars(args).items()
+               if name not in ('host', 'ask_pass', 'known_hosts_path') and value is not None}
+    if args.host is None and (options or args.ask_pass):
+        parser.error('connection options require a host')
+    console = InteractiveConsole()
+    try:
+        console.open()
+        if args.known_hosts_path is not None:
+            console.current.session.set(known_hosts_path=args.known_hosts_path)
+        if args.ask_pass:
+            options['password'] = getpass('SSH password: ')
+        if args.host is not None:
+            console.connect(args.host, **options)
+        console.interact()
+    finally:
+        console.close()
+    return 0

sshscript/scriptcontrol.py

@@ -0,0 +1,34 @@
+"""Script completion and interactive-scope control, separate from execution errors."""
+from contextvars import ContextVar
+from typing import Any
+
+
+class ScriptResult(dict[str, Any]):
+    """Executed namespace plus completion status; also returned after stop()."""
+    def __init__(self, namespace: dict[str, Any], *, exitcode: int = 0,
+                 stopped: bool = False, message: str = "") -> None:
+        super().__init__(namespace)
+        self.exitcode = exitcode
+        self.stopped = stopped
+        self.message = message
+
+
+class ScriptStopped(BaseException):
+    """Internal normal-completion signal, caught by the nearest script runner."""
+    def __init__(self, code: int = 0, message: str = "") -> None:
+        super().__init__(message)
+        self.code = code
+        self.message = message
+
+
+script_active: ContextVar[bool] = ContextVar("sshscript_script_active", default=False)
+
+
+def stop_script(code: int = 0, message: str = "") -> None:
+    if not script_active.get():
+        raise RuntimeError("stop() requires a running script; use exit() to leave a console layer")
+    if isinstance(code, bool) or not isinstance(code, int):
+        raise TypeError("stop code must be an integer")
+    if not isinstance(message, str):
+        raise TypeError("stop message must be a string")
+    raise ScriptStopped(code, message)

sshscript/session.py

@@ -51,7 +51,7 @@ if __package__:
     from .dollar import Dollar
     from .sessionwrapper import SessionWrapper,SudoConsole,SuConsole
     from .channelutils import _validate_enter_timeout
-    from .errorutils import get_logger, SSHScriptExit, SSHScriptBreak, SSHScriptException, dumpScript, listRightIndex
+    from .errorutils import get_logger, SSHScriptException, dumpScript, listRightIndex
     ## v2.0.3 changes from sshscriptparserng to dollarparser
     from . import dollarparser
 
@@ -65,9 +65,14 @@ else:
     from dollar import Dollar
     from sessionwrapper import SessionWrapper,SudoConsole,SuConsole
     from channelutils import _validate_enter_timeout
-    from errorutils import get_logger, SSHScriptException, SSHScriptExit, SSHScriptBreak, dumpScript, listRightIndex
+    from errorutils import get_logger, SSHScriptException, dumpScript, listRightIndex
     import dollarparser
 
+if __package__:
+    from .scriptcontrol import ScriptResult, ScriptStopped, script_active, stop_script
+else:
+    from scriptcontrol import ScriptResult, ScriptStopped, script_active, stop_script
+
 ## setup logger
 _COMMAND_TIMEOUT_UNSET = object()
 logger = get_logger()
@@ -303,9 +308,6 @@ class ConsoleWrapper:
                     raise
                 self.channel.logger.debug('Unable to finish console cleanup after an exception')
 
-    def exit(self):
-        return self.__exit__(None,None,None)
-    
     def __repr__(self):
         return f'ConsoleWrapper({self.funcname})'
     ##
@@ -362,7 +364,7 @@ class Session(object):
         self._host = None
         self._port = None
         self._username = None
-        self.runLocker = threading.Lock()
+        self.runLocker = threading.RLock()
 
         self.ownerstack = None
         ## homony i/o of this thread
@@ -673,15 +675,10 @@ class Session(object):
         while p.parent is not None:
             p = p.parent
         return p
-    @export2Dollar('break')
-    def _break(self,code=0,message=''):
-        self.logger.debug('Script requested break (exit_code=%s)', code)
-        raise SSHScriptBreak(message,code)
-
     @export2Dollar
-    def exit(self,code=0,message=''):
-        self.logger.debug('Script requested exit (exit_code=%s)', code)
-        raise SSHScriptExit(message,code)
+    def stop(self, code=0, message=''):
+        """Normally finish the nearest script execution, preserving its namespace."""
+        return stop_script(code, message)
 
     def _read_known_hosts(self):
         """Read a host-owned trust file strictly; never execute a remote shell."""
@@ -1122,7 +1119,9 @@ class Session(object):
         """Execute Python or .spy source in this session and return its namespace.
 
         vars supplies initial names (default: the caller's locals); execution uses
-        a copy. This session is active for the duration of the run. showScript=True
+        a copy. Return ScriptResult, including names defined before stop(), with
+        exitcode/stopped/message completion attributes. Nested stop() ends only
+        its nearest run. This session is active for the run. showScript=True
         displays translated source and returns an empty dict without executing it.
         """
         if vars is None:
@@ -1156,7 +1155,7 @@ class Session(object):
                     if is_dollar_script else script
                 )
                 dumpScript(scriptChunk)
-                return {}
+                return ScriptResult({})
 
 
             source_path = filepath or '<str>'
@@ -1185,15 +1184,17 @@ class Session(object):
             else:
                 dollarparser._cache_source(source_path, script)
                 code = compile(script, source_path, 'exec')
+            active_token = script_active.set(True)
             try:
                 exec(code, exec_vars)  # Run the modified code inside the module's namespace
-            except (SSHScriptBreak, SSHScriptExit):
-                # Preserve the control-flow exception until run_file()/the CLI
-                # can translate it into the documented process exit status.
-                raise
+            except ScriptStopped as stopped:
+                return ScriptResult(exec_vars, exitcode=stopped.code,
+                                    stopped=True, message=stopped.message)
             else:
-                return exec_vars
-            
+                return ScriptResult(exec_vars)
+            finally:
+                script_active.reset(active_token)
+
         ## v.1.18
         if not self.runLocker.acquire(timeout=60):
             raise TimeoutError('Timed out waiting for the script execution lock')
@@ -1238,9 +1239,7 @@ class Session(object):
         try:
             ret = runner(script,vars,showScript)
         finally:
-            ## self.runLocker might be already released by caller because of timeout
-            if self.runLocker.locked():
-                self.runLocker.release()
+            self.runLocker.release()
         
         if ret.get('exception'):
             raise ret['exception']

sshscript/session.pyi

@@ -5,6 +5,7 @@ from paramiko import MissingHostKeyPolicy
 from .commandjob import CommandJob, CommandTimeoutError as CommandTimeoutError, JobResult
 from .commandresult import CommandResult as CommandResult
 from .sessionwrapper import SessionWrapper
+from .scriptcontrol import ScriptResult as ScriptResult
 
 Command = str | list[str] | tuple[str, ...]
 HostKeyPolicy = MissingHostKeyPolicy | type[MissingHostKeyPolicy] | None
@@ -79,6 +80,8 @@ class Session:
     def upload(self, src: str | PathLike[str], dst: str, makedirs: bool = ..., overwrite: bool = ...) -> tuple[str, str]: ...
     def download(self, src: str, dst: str | PathLike[str] | None = ...) -> tuple[str, str]: ...
     def clear(self) -> None: ...
+    def stop(self, code: int = ..., message: str = ...) -> None: ...
+    def run(self, script: str, vars: dict[str, Any] | None = ..., showScript: bool = ...) -> ScriptResult: ...
     def close(self, strict: bool = ...) -> bool: ...
     disconnect = close
     def __enter__(self) -> Session: ...

sshscript/sessionwrapper.py

@@ -406,8 +406,9 @@ class SessionWrapper(object):
     def __repr__(self):
         return f'SessionWrapper(id:{id(self)}, hijacked:{self.channel.hijacked})'
 
-    def _break(self,code=0,message=''):
-        self.channel.owner.session._break(code,message) 
+    def stop(self, code=0, message=''):
+        """Normally finish the nearest script, including inside a console scope."""
+        return self.channel.owner.session.stop(code, message)
     
     def _enter_thread(self,thread):    
         self.channel.owner.session._enter_thread(thread) 
@@ -426,5 +427,3 @@ class SessionWrapper(object):
     def __exit__(self,*args):
         patching.get_thread_stack().pop(self)
         return False
-    def exit(self):
-        return self.__exit__(None,None,None)

sshscript/sessionwrapper.pyi

@@ -11,6 +11,7 @@ class SessionWrapper:
     def exitcode(self) -> int: ...
     @property
     def closed(self) -> bool: ...
+    def stop(self, code: int = ..., message: str = ...) -> None: ...
     def start(self, command: str, *, timeout: float | None = ..., stop_timeout: float = ..., capture_limit: int = ..., check: bool = ...) -> CommandJob: ...
     def set(self, *, check: bool = ..., verbose: bool = ..., verbose_stderr: bool = ..., log_level: int | str = ...) -> None: ...
     def get(self, name: str | None = ...) -> Any: ...

sshscript/spyimporter.py

@@ -29,10 +29,12 @@ if __package__:
     from . import dollarparser
     from . import patching
     from .dollar import Dollar
+    from .scriptcontrol import ScriptStopped, script_active
 else:
     import dollarparser
     import patching
     from dollar import Dollar
+    from scriptcontrol import ScriptStopped, script_active
 
 class SpyLoader(importlib.abc.Loader):
     """Compile and execute .spy modules while preserving their original source locations."""
@@ -68,7 +70,14 @@ class SpyLoader(importlib.abc.Loader):
             g["_sshscript_session_"] = stack[-1]
         module.__dict__.update(g)
         code = dollarparser.compile_spy(self.path, original_code)
-        exec(code, module.__dict__)  # Run the modified code inside the module's namespace
+        active_token = script_active.set(True)
+        try:
+            exec(code, module.__dict__)
+        except ScriptStopped:
+            # A stopped imported module is initialized with its partial namespace.
+            pass
+        finally:
+            script_active.reset(active_token)
 
 
 class SpyFileFinder(importlib.abc.MetaPathFinder):

sshscript/sshscript.py

@@ -40,8 +40,8 @@ def warning_on_one_line(message, category, filename, lineno, file=None, line=Non
 if __package__:
     from ._version import __version__
     from .sessionsettings import execution_defaults
-    from .session import Session, CommandResult, CommandJob, CommandTimeoutError, JobResult
-    from .errorutils import SSHScriptExit, SSHScriptBreak, get_logger, set_logger, SSHScriptException,command_summary
+    from .session import ScriptResult, Session, CommandResult, CommandJob, CommandTimeoutError, JobResult
+    from .errorutils import get_logger, set_logger, SSHScriptException,command_summary
     ## 2025/3/3 v2.0.3 feature: import *.spy file directly
     from . import spyimporter
     from . import dollarparser
@@ -51,8 +51,8 @@ else:
     if not mydir in sys.path: sys.path.insert(0,mydir)
     from _version import __version__
     from sessionsettings import execution_defaults
-    from session import Session, CommandResult, CommandJob, CommandTimeoutError, JobResult
-    from errorutils import SSHScriptExit, SSHScriptBreak, get_logger, set_logger, SSHScriptException,command_summary
+    from session import ScriptResult, Session, CommandResult, CommandJob, CommandTimeoutError, JobResult
+    from errorutils import get_logger, set_logger, SSHScriptException,command_summary
     import spyimporter
     import dollarparser
     ## 2024/8/16, should remove mydir out of sys.path for python 3.11
@@ -96,8 +96,8 @@ def run_file(
     execution already failed, that exception remains primary and receives a
     cleanup-failure note.
 
-    Return 0 on normal completion, or the status passed to $.break(status).
-    $.exit(status) raises SSHScriptExit; other execution errors propagate.
+    Return 0 on normal completion, or the status passed to $.stop(status).
+    Execution errors and Python SystemExit propagate.
     Use run_script() for source text and a returned namespace.
     """
     if not isinstance(script_path, (str, os.PathLike)):
@@ -132,19 +132,11 @@ def run_file(
         script_vars['__name__'] = '__main__'
         script_vars['__file__'] = absfile
         with spyimporter.spy_imports():
-            session.run(
+            result = session.run(
                 script,
                 script_vars,
                 showScript=showScript,
             )
-    except SSHScriptBreak as exc:
-        exitcode = exc.errno
-        script_exitcode = exc.errno
-        outcome = 'break'
-    except SSHScriptExit as exc:
-        script_exitcode = exc.errno
-        outcome = 'exit'
-        raise
     except SSHScriptException as exc:
         primary_exception = exc
         script_exitcode = exc.errno
@@ -157,8 +149,8 @@ def run_file(
         exception_type = type(exc).__name__
         raise
     else:
-        outcome = 'completed'
-        script_exitcode = 0
+        outcome = 'stopped' if result.stopped else 'completed'
+        script_exitcode = exitcode = result.exitcode
     finally:
         if inserted_path:
             sys.path.remove(script_folder)
@@ -199,8 +191,6 @@ def run_script(script,varGlobals=None,showScript=False):
         result = the_session.run(script,vars=varGlobals,showScript=showScript)
         outcome = 'completed'
         return result
-    except (SSHScriptBreak, SSHScriptExit):
-        raise
     except BaseException as exc:
         primary_exception = exc
         exception_type = type(exc).__name__
@@ -278,9 +268,24 @@ def main():
     set_logger()
     warnings.formatwarning = warning_on_one_line
 
+    if len(sys.argv) > 1 and sys.argv[1] == 'console':
+        if __package__:
+            from .interactive import main as console_main
+        else:
+            # Flat development CLI removes its bootstrap path after imports.
+            # Keep it available while the REPL imports local product modules.
+            sys.path.insert(0, mydir)
+            try:
+                from interactive import main as console_main
+                return console_main(sys.argv[2:])
+            finally:
+                sys.path.remove(mydir)
+        return console_main(sys.argv[2:])
+
     import argparse
 
-    parser = argparse.ArgumentParser(description='SSHScript: automation tools for Subprocess and SSH')
+    parser = argparse.ArgumentParser(description='SSHScript: automation tools for Subprocess and SSH',
+                                     epilog='Interactive preview: sshscript console [host] (console --help for options)')
 
 
     parser.add_argument('--script','-s', dest='showScript', action='store_true',
@@ -385,8 +390,6 @@ def main():
                         args.path,
                         showScript=args.showScript,
                     )
-        except SSHScriptExit as e:
-            sys.exit(e.errno)
         except SSHScriptException as e:
             if args.show_traceback:
                 logger.exception(

{sshscript-5.0.0.dist-info → sshscript-6.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sshscript
-Version: 5.0.0
+Version: 6.0.0
 Summary: Python automation for local processes, SSH, and SSHScript .spy files
 Author-email: "Yeh, Hsin-Yuan" <iapyeh@gmail.com>
 License-Expression: MIT
@@ -31,6 +31,10 @@ Dynamic: license-file
 
 # SSHScript
 
+SSHScript 6.0.0: [interactive console and script completion](CONSOLE.md).
+Run `python3 -B sshscript.py console` from the development checkout.
+
+
 [![PyPI](https://img.shields.io/pypi/v/sshscript)](https://pypi.org/project/sshscript/)
 [![Python](https://img.shields.io/pypi/pyversions/sshscript)](https://pypi.org/project/sshscript/)
 [![CI](https://github.com/iapyeh/sshscript/actions/workflows/ci.yml/badge.svg?branch=release)](https://github.com/iapyeh/sshscript/actions/workflows/ci.yml)
@@ -50,7 +54,9 @@ output and status, distinguish failure from timeout, and make cleanup and
 unknown termination explicit. A successful command exit is evidence about
 that command; verify the deployment or other application outcome separately.
 
-**Current release:** [5.0.0](https://github.com/iapyeh/sshscript/releases/tag/v5.0.0)
+**Source contract: 6.0.0.** The release branch and local artifacts target this
+version; this source update does not publish a package or create a release tag.
+**Latest published release:** [5.0.0](https://github.com/iapyeh/sshscript/releases/tag/v5.0.0)
 (Production/Stable) · **Python:** 3.11 or newer · **Tested:** Python
 3.11–3.14 on Linux and macOS
 
@@ -60,8 +66,10 @@ that command; verify the deployment or other application outcome separately.
 [Security](https://github.com/iapyeh/sshscript/security/policy) ·
 [Support](https://github.com/iapyeh/sshscript/blob/release/SUPPORT.md)
 
-**Version 5.0.0** preserves the 4.0 command execution contract and changes the
-default host-key source to the calling host. Provision its known_hosts file or
+**Version 6.0.0** adds a Python-first interactive console and normal script
+completion through `$.stop()`. It removes `$.exit()`, `$.break()` and their old
+control exceptions; review the [6.0 migration](VERSIONING.md#60-console-and-script-completion-migration).
+It retains the 5.0 calling-host default for host-key sources. Provision its known_hosts file or
 select `known_hosts="local"` when migrating existing nested connections.
 Upgrade 3.1.5 automation using the migration guide and application regressions.
 See [version policy and migration](VERSIONING.md) before upgrading automation.
@@ -153,7 +161,7 @@ pin SSHScript and all transitive dependencies in your application's lock file.
 To install this release explicitly:
 
 ```sh
-python3 -m pip install "sshscript==5.0.0"
+python3 -m pip install /path/to/sshscript-6.0.0-py3-none-any.whl
 ```
 
 Use `python3 -m pip install --upgrade sshscript` to upgrade. The optional
@@ -162,7 +170,11 @@ it never installs an update by itself.
 
 ## 60-second local quickstart
 
-This example runs on 5.0.0 and retains compatibility with the 3.1.5 command API.
+For 6.0.0, install a verified local wheel as shown above until package publication.
+After publication, pin `sshscript==6.0.0` instead. The latest published 5.0.0
+package does not contain the new console.
+
+This example runs on 6.0.0 and retains compatibility with the 3.1.5 command API.
 The metadata below records that older compatibility baseline.
 
 <!-- example: {"id":"readme-quickstart", "profile":"3.1.5", "stdout":"sshscript is ready\nexit code: 0\n"} -->
@@ -607,3 +619,5 @@ for maintainer-only release steps.
 
 SSHScript is released under the
 [MIT License](https://github.com/iapyeh/sshscript/blob/release/LICENSE.txt).
+
+*Last modified: 2026-10-22 23:24:55*

{sshscript-5.0.0.dist-info → sshscript-6.0.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
 _sshscript_cli.py,sha256=Z3BwvYFLKJAmy8Wi6xDUqHiIbXT498_uX4WEiguD9n0,576
-sshscript/__init__.py,sha256=bVqkgcifvePikqOTTMBC8bTSFz-UeFjSV-12seFONgw,3114
-sshscript/__init__.pyi,sha256=HOvKjFhwqm6OqTfBDkSGHyo2pGcmAB0cHOPz2jEow2c,810
+sshscript/__init__.py,sha256=g-8qM2hSxx9a_OOVnOTCAnTQ4z3uv8rUcF3G7cdG1go,3170
+sshscript/__init__.pyi,sha256=rZfxqkAHa3ZewvHzmaxfABTAyZULWIqgBRO6CH9yGeY,864
 sshscript/_runtime.py,sha256=wJt8XSxK21Ntt-oSUhEF4lN8Nx10H1X8JyIG2ebaPSo,443
-sshscript/_version.py,sha256=ssRZ5iGxPpxYOxW6pHi-PtvxOGEaaBmJt3P5ZoMxybk,77
-sshscript/channelgeneric.py,sha256=J_tBZa4xrXLjDN3xjfkHukzynhkT0-bKkz-Ds3RKIaA,75822
+sshscript/_version.py,sha256=OenAa_lZfEcAnQebYG3wLxiSbvUUUVTKx4zVuHmbhEw,77
+sshscript/channelgeneric.py,sha256=-5HdoarpeGwI19wCw1w5qtGPfRv7YLWU3MKbftcts4M,76137
 sshscript/channelssh.py,sha256=aVdI3KsUoSOujCDLpuI0I3m5YDWZCvIeB8a4J93P7r0,12038
 sshscript/channelsubprocess.py,sha256=mWPMxFMV6ZMx-VPWPNgtRvOAW9pjRZNtXddl0qY7UQk,12162
 sshscript/channelutils.py,sha256=0rdC8a-RctLHb28GvGSsKANgRy1L4y45sbry0KB3KaA,33514
@@ -14,23 +14,25 @@ sshscript/commandresult.pyi,sha256=gflxZGoI5V8R6MThGyEXMlJigKOnit61tmG1_BnTTVo,5
 sshscript/consolejob.py,sha256=QKzhjA_qbiOzg7R-PbhjP9-ZIPAnJba0csjMdJ8RC5g,14201
 sshscript/dollar.py,sha256=xCesXAU-mj_wVm1-m41Sw_nIZR-Z7Wl3kFnJxQZvFiw,26265
 sshscript/dollarchanger.py,sha256=BvKqUaPgYmAkXyv_rbmSSbvowneAs_wlYSDm1Hic7PA,31159
-sshscript/dollarparser.py,sha256=7cl4QgffzfueeGOPN-NeoLP_3bKm04I9cVtCyag7JcE,9638
-sshscript/errorutils.py,sha256=MgwYoPipEVCa9L33FmVoYXl77CD-Mrq958q_ft3cuvw,16386
+sshscript/dollarparser.py,sha256=4fELB7lOEyyEteAr962v8liF5BjB_GmdgT5uJEZjEOU,9735
+sshscript/errorutils.py,sha256=AAZ2kOShZpnrhK25FxC5UiIOj5EjcVTn1fICbV1QDKQ,16114
+sshscript/interactive.py,sha256=xXkiEHS2jN8hZ93hTW4QOglsDU1g5olTt9AYLq4UQkY,26422
 sshscript/patching.py,sha256=OM6vjGeP0iyBnzpai5BHn9qqkzJp9375npVb97D06LY,6581
 sshscript/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sshscript/session.py,sha256=AvaqFhWbNRERE5qJfYp0uWdR8mQlzl2aT32FQSwqcIs,78406
-sshscript/session.pyi,sha256=gK0INrScwjTk0WqKGX458Iw-toOkRikRtSvdTvX0_-s,4857
+sshscript/scriptcontrol.py,sha256=M2NEMkI8A-fONa8l0oB_2c9p_uunBa6Kff1a1J53vNg,1342
+sshscript/session.py,sha256=g7qKoq4efY_IT-n8vBbazpfXfDtCqIgqPkB1FdaRtfs,78426
+sshscript/session.pyi,sha256=gObS6RHj4DJqWaqX3RyBcvYHXoNbNvbYYHvykGADqbA,5093
 sshscript/sessionsettings.py,sha256=QJnjQtPpJBNUbIboICKcuNxZh3yN4vAuL_yw_5LL3d4,4612
-sshscript/sessionwrapper.py,sha256=r6BI6xBwrA-nqqa6YsXzaUUtxz5pv_483Xu6Ywlzs4I,19019
-sshscript/sessionwrapper.pyi,sha256=vzdJjl-vPB1bP57uXe78jGpjC4ag2t_Aqowg_4ggbVY,1585
-sshscript/spyimporter.py,sha256=ASAs2nPBU1mtpI7FquXYJctLFQR_PeGMnhjcw1G6LPg,5574
+sshscript/sessionwrapper.py,sha256=hxW6JzNWaObZ216GkmybsUYBJKj-CaxVs3RKuSSSWpM,19043
+sshscript/sessionwrapper.pyi,sha256=wi7r6kz77yO4EY1fumznK9Fs4IIALZm_B2ytltsQGOk,1654
+sshscript/spyimporter.py,sha256=kdI7lWr1GJO4C_ZJ7qEsx6AuxKfMzeAOr5itkh-9quY,5895
 sshscript/sshconfig.py,sha256=aPfVOd-bx4k7gBuDeSb55Y812G4QNGeL3sbZPLPdiic,6295
-sshscript/sshscript.py,sha256=BXQG1yA-9M3l0JDbCwR3Lg5CCpn3qnJhQ1Xx6Q9-2eA,16940
+sshscript/sshscript.py,sha256=SFSupMAqknSagp3Ewnmzvt42o2gnehbsDMqKRnn3voo,17292
 sshscript/stdio.py,sha256=Ql_7wX7oJ5vY74uOlCaotwoyqXrNteYdSl-aM4ersVM,16040
 sshscript/tokenparser.py,sha256=dGHY2s8Twjz0Q-r6nanmAL8VCQxZWqmM6g4KvTgIuzs,22396
-sshscript-5.0.0.dist-info/licenses/LICENSE.txt,sha256=FPqC-mLQDBkQ26LK_CAUGEUQQ7eyFTbftywlk2GMlls,1075
-sshscript-5.0.0.dist-info/METADATA,sha256=WrYqMxN3lzhnL8whxN7gYOdVw7WKrrAoteeEue7tHBo,29353
-sshscript-5.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-sshscript-5.0.0.dist-info/entry_points.txt,sha256=JLkqym2UQso2R41RvFz9RAnCKFY8-nnrYgB4ER-zTGo,50
-sshscript-5.0.0.dist-info/top_level.txt,sha256=5d41PAJBhS-f-8aJKJegdhs8BIg_jpigSG83tCQhhfg,25
-sshscript-5.0.0.dist-info/RECORD,,
+sshscript-6.0.0.dist-info/licenses/LICENSE.txt,sha256=FPqC-mLQDBkQ26LK_CAUGEUQQ7eyFTbftywlk2GMlls,1075
+sshscript-6.0.0.dist-info/METADATA,sha256=KNYJLXcLG2TMgcywEwRc-aHdKJthpe2PDNVFnWpSZIk,30132
+sshscript-6.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+sshscript-6.0.0.dist-info/entry_points.txt,sha256=JLkqym2UQso2R41RvFz9RAnCKFY8-nnrYgB4ER-zTGo,50
+sshscript-6.0.0.dist-info/top_level.txt,sha256=5d41PAJBhS-f-8aJKJegdhs8BIg_jpigSG83tCQhhfg,25
+sshscript-6.0.0.dist-info/RECORD,,