sshmd 0.1.0__py3-none-any.whl

sshm/state.py

@@ -0,0 +1,76 @@
+"""Runtime state files shared by the CLI and the daemon (~/.sshm)."""
+
+from __future__ import annotations
+
+import os
+import secrets
+import sys
+from pathlib import Path
+
+
+def sshm_dir() -> Path:
+    d = Path.home() / ".sshm"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def pid_file() -> Path:
+    return sshm_dir() / "sshmd.pid"
+
+
+def token_file() -> Path:
+    return sshm_dir() / "token"
+
+
+def log_file() -> Path:
+    return sshm_dir() / "sshmd.log"
+
+
+def port_file() -> Path:
+    return sshm_dir() / "port"
+
+
+DEFAULT_PORT = 19222
+
+
+def resolve_port() -> int:
+    """Effective IPC port: SSHM_PORT env > persisted ~/.sshm/port > default.
+
+    The env var wins for ad-hoc overrides; the persisted file lets an
+    autostarted daemon (systemd/launchd/Task Scheduler), which never sees the
+    interactive shell's environment, agree with the CLI on a non-default port.
+    """
+    env = os.environ.get("SSHM_PORT")
+    if env:
+        try:
+            return int(env)
+        except ValueError:
+            pass
+
+    pf = port_file()
+    try:
+        return int(pf.read_text(encoding="utf-8").strip())
+    except (ValueError, OSError):
+        return DEFAULT_PORT
+
+
+def write_port(port: int) -> None:
+    port_file().write_text(str(port), encoding="utf-8")
+
+
+def read_token() -> str | None:
+    tf = token_file()
+    if tf.exists():
+        return tf.read_text(encoding="utf-8").strip()
+    return None
+
+
+def new_token() -> str:
+    return secrets.token_hex(32)
+
+
+def write_token(token: str) -> None:
+    tf = token_file()
+    tf.write_text(token, encoding="utf-8")
+    if sys.platform != "win32":
+        os.chmod(tf, 0o600)

sshm/terminal.py

@@ -0,0 +1,199 @@
+"""Raw terminal I/O bridge between the local console and a daemon socket."""
+
+from __future__ import annotations
+
+import os
+import socket
+import sys
+import threading
+from collections.abc import Callable
+
+CHUNK = 4096
+
+# Called with (cols, rows) when the local terminal is resized. Returns nothing;
+# implementations should be non-blocking / best-effort.
+ResizeCallback = Callable[[int, int], None]
+
+
+def stream_bridge(
+    sock: socket.socket, initial: bytes = b"", on_resize: ResizeCallback | None = None
+) -> None:
+    """Pump bytes between the local terminal and the socket until either side closes.
+
+    ``initial`` is session output that arrived bundled with the attach response
+    and is written to the terminal before streaming begins. ``on_resize`` is
+    invoked with the new (cols, rows) whenever the local terminal is resized
+    (POSIX only; Windows keeps the size it attached with).
+    """
+    if sys.platform == "win32":
+        _bridge_windows(sock, initial)
+    else:
+        _bridge_unix(sock, initial, on_resize)
+
+
+def _bridge_unix(
+    sock: socket.socket, initial: bytes = b"", on_resize: ResizeCallback | None = None
+) -> None:
+    import select
+    import signal
+    import termios
+    import tty
+
+    stdin_fd = sys.stdin.fileno()
+    # Raw mode only makes sense (and tcgetattr only works) on a real terminal.
+    # When stdin is redirected (a pipe, /dev/null) we still bridge, just non-raw.
+    is_tty = sys.stdin.isatty()
+    old_attrs = termios.tcgetattr(stdin_fd) if is_tty else None
+
+    # SIGWINCH self-pipe (set up inside the try so the finally always reclaims the
+    # fds and the handler). The handler does almost nothing — just writes a byte;
+    # the select loop does the signal-unsafe work of reading the size.
+    winch_r = winch_w = -1
+    old_winch = None
+    use_winch = is_tty and on_resize is not None and hasattr(signal, "SIGWINCH")
+
+    def _notify_resize() -> None:
+        try:
+            sz = os.get_terminal_size(stdin_fd)
+            on_resize(sz.columns, sz.lines)
+        except Exception:
+            pass  # never let a resize hiccup break the bridge
+
+    try:
+        if use_winch:
+            winch_r, winch_w = os.pipe()
+            os.set_blocking(winch_r, False)
+            os.set_blocking(winch_w, False)
+
+            def _winch_handler(_signum, _frame):
+                try:
+                    os.write(winch_w, b"\x01")
+                except OSError:
+                    pass
+
+            old_winch = signal.signal(signal.SIGWINCH, _winch_handler)
+
+        if is_tty:
+            tty.setraw(stdin_fd)
+
+        if initial:
+            sys.stdout.buffer.write(initial)
+            sys.stdout.buffer.flush()
+
+        watch = [stdin_fd, sock]
+        if use_winch:
+            watch.append(winch_r)
+
+        while True:
+            ready, _, _ = select.select(watch, [], [], 1.0)
+
+            for fd in ready:
+                if fd is sock:
+                    data = sock.recv(CHUNK)
+                    if not data:
+                        return
+                    sys.stdout.buffer.write(data)
+                    sys.stdout.buffer.flush()
+                elif use_winch and fd == winch_r:
+                    while True:  # fully drain coalesced signals (winch_r is non-blocking)
+                        try:
+                            if not os.read(winch_r, 4096):
+                                break
+                        except OSError:
+                            break
+                    _notify_resize()
+                elif fd == stdin_fd:
+                    data = os.read(stdin_fd, CHUNK)
+                    if not data:
+                        return
+                    sock.sendall(data)
+    except OSError:
+        pass
+    finally:
+        if old_winch is not None:
+            signal.signal(signal.SIGWINCH, old_winch)
+        if winch_r != -1:
+            os.close(winch_r)
+        if winch_w != -1:
+            os.close(winch_w)
+        if is_tty and old_attrs is not None:
+            termios.tcsetattr(stdin_fd, termios.TCSADRAIN, old_attrs)
+        sock.close()
+
+
+def _bridge_windows(sock: socket.socket, initial: bytes = b"") -> None:
+    import ctypes
+    from ctypes import wintypes
+
+    kernel32 = ctypes.windll.kernel32
+    STD_INPUT_HANDLE = -10
+    STD_OUTPUT_HANDLE = -11
+
+    h_in = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+    h_out = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+
+    old_in_mode = wintypes.DWORD()
+    old_out_mode = wintypes.DWORD()
+    kernel32.GetConsoleMode(h_in, ctypes.byref(old_in_mode))
+    kernel32.GetConsoleMode(h_out, ctypes.byref(old_out_mode))
+
+    ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200
+    kernel32.SetConsoleMode(h_in, ENABLE_VIRTUAL_TERMINAL_INPUT)
+
+    ENABLE_PROCESSED_OUTPUT = 0x0001
+    ENABLE_WRAP_AT_EOL_OUTPUT = 0x0002
+    ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+    kernel32.SetConsoleMode(
+        h_out,
+        ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING,
+    )
+
+    if initial:
+        written = wintypes.DWORD()
+        kernel32.WriteFile(h_out, initial, len(initial), ctypes.byref(written), None)
+
+    stop_event = threading.Event()
+
+    def _read_socket() -> None:
+        try:
+            written = wintypes.DWORD()
+            while not stop_event.is_set():
+                data = sock.recv(CHUNK)
+                if not data:
+                    break
+                kernel32.WriteFile(h_out, data, len(data), ctypes.byref(written), None)
+        except OSError:
+            pass
+        finally:
+            stop_event.set()
+
+    def _read_stdin() -> None:
+        try:
+            buf = ctypes.create_string_buffer(CHUNK)
+            bytes_read = wintypes.DWORD()
+            while not stop_event.is_set():
+                success = kernel32.ReadFile(h_in, buf, CHUNK, ctypes.byref(bytes_read), None)
+                if success and bytes_read.value > 0:
+                    sock.sendall(buf.raw[: bytes_read.value])
+                elif not success:
+                    break
+                else:
+                    sock.sendall(b"\x1a")  # Ctrl-Z: signal EOF to the remote shell
+        except OSError:
+            pass
+        finally:
+            stop_event.set()
+
+    t_sock = threading.Thread(target=_read_socket, daemon=True)
+    t_stdin = threading.Thread(target=_read_stdin, daemon=True)
+    t_sock.start()
+    t_stdin.start()
+
+    try:
+        stop_event.wait()
+    finally:
+        kernel32.SetConsoleMode(h_in, old_in_mode.value)
+        kernel32.SetConsoleMode(h_out, old_out_mode.value)
+        sock.close()
+        t_sock.join(timeout=1)
+        t_stdin.join(timeout=1)

sshmd-0.1.0.dist-info/METADATA

@@ -0,0 +1,309 @@
+Metadata-Version: 2.4
+Name: sshmd
+Version: 0.1.0
+Summary: Cross-platform SSH session manager with a background daemon
+Keywords: ssh,session-manager,daemon,port-forwarding,socks,terminal
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Utilities
+Requires-Dist: click>=8.0
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/revsearch/sshm
+Project-URL: Repository, https://github.com/revsearch/sshm
+Project-URL: Issues, https://github.com/revsearch/sshm/issues
+Description-Content-Type: text/markdown
+
+# sshm
+
+[![PyPI](https://img.shields.io/pypi/v/sshmd)](https://pypi.org/project/sshmd/) [![Tests](https://github.com/revsearch/sshm/actions/workflows/tests.yml/badge.svg)](https://github.com/revsearch/sshm/actions/workflows/tests.yml)
+
+An SSH session manager with a background daemon. Remote shells stay alive when you
+close the terminal, reconnect on their own when the link drops, and reattach
+instantly. State is kept in plain `~/.ssh/config`, so `ssh`, `scp`, and `rsync`
+keep working alongside it.
+
+```bash
+sshm add prod root@192.0.2.10   # keygen + copy key + write ~/.ssh/config
+sshm prod                       # attach to a live shell (or start one)
+# close the terminal — the shell keeps running; `sshm prod` reattaches it
+
+ssh prod                        # plain ssh/scp/rsync work too — same alias & key
+```
+
+## Install
+
+The package is published as **`sshmd`** and installs the `sshm` (and `sshmd`)
+commands. With [uv](https://docs.astral.sh/uv/) or [pipx](https://pipx.pypa.io/):
+
+```bash
+uv tool install sshmd
+# or
+pipx install sshmd
+```
+
+Latest from git instead of PyPI:
+
+```bash
+uv tool install git+https://github.com/revsearch/sshm
+```
+
+From a checkout:
+
+```bash
+git clone https://github.com/revsearch/sshm
+cd sshm
+uv tool install .        # or: pip install .
+```
+
+Needs Python 3.12+. The `sshm` and `sshmd` commands are installed to your tool bin
+directory (`~/.local/bin`, or the Python Scripts dir on Windows) — make sure it's
+on your PATH. Update with `uv tool upgrade sshm`.
+
+## Quick start
+
+```bash
+# Add a server: generates an ed25519 key, copies it to the remote, writes config
+sshm add myserver root@192.168.1.100
+
+# Connect (interactive shell via the daemon)
+sshm myserver
+
+# Or explicitly
+sshm c myserver
+```
+
+## Works with `ssh`, `scp`, `rsync`
+
+`sshm add` writes a normal `Host` entry to `~/.ssh/config`, so the alias works with
+any tool that reads it — not just `sshm`. The generated key and port are picked up
+automatically, so no `-i`/`-p` flags are needed:
+
+```bash
+ssh myserver                            # plain SSH, same alias
+ssh myserver htop                       # run a one-off command
+scp ./backup.tar.gz myserver:/srv/      # copy a file up
+scp myserver:/var/log/app.log .         # ...and back down
+rsync -avz ./site/ myserver:/var/www/   # sync a directory
+sftp myserver                           # sftp, git over ssh, etc. all work too
+git clone myserver:/srv/repo.git        # alias works as the ssh host anywhere
+```
+
+The difference: `sshm myserver` attaches to a persistent, auto-reconnecting shell
+via the daemon, while `ssh myserver` is a plain one-off connection — both to the
+same host, using the same key and config.
+
+## Commands
+
+Most commands have a short alias (shown first). `sshm <alias>` with no command is
+shorthand for `connect`.
+
+### Sessions
+
+```bash
+sshm <alias>                        # Connect (shorthand)
+sshm c,  connect <alias> [name]     # Attach to a session or create a new one
+sshm l,  list                       # List all hosts
+sshm l,  list <alias>               # List active sessions for a host
+sshm a,  add <alias> user@host      # Add a server (keygen + copy key)
+sshm r,  remove <alias>             # Remove a host and disconnect all sessions
+sshm mv, rename <alias> <new>       # Rename an alias (and its managed key)
+```
+
+`add` takes `user@host`, `user@host:port`, or bracketed IPv6
+(`user@[2001:db8::1]:22`).
+
+### Port forwarding and SOCKS
+
+Forwards are written as native `LocalForward` / `RemoteForward` / `DynamicForward`
+directives in `~/.ssh/config`, so any SSH client sees them. Direction is `-L` /
+`-R` / `-D`, same as `ssh`:
+
+```bash
+sshm p a, port add <alias> -L <local>:<host>:<remote>      # Local forward
+sshm p a, port add <alias> -R <remote>:<host>:<local>      # Reverse forward
+sshm p a, port add <alias> -D <port>                       # SOCKS proxy (ssh -D)
+sshm p r, port remove <alias> -L <local>:<host>:<remote>   # Remove a forward
+sshm p r, port remove <alias> -D <port>                    # Remove a SOCKS proxy
+```
+
+`-D <port>` is a dynamic forward — a SOCKS5 proxy on `127.0.0.1:<port>` tunnelled
+through the host. Point a browser or any SOCKS-aware app at it.
+
+### Auto-connect
+
+When enabled, the daemon keeps at least one shell alive and reconnects it on
+failure, so attaching is instant.
+
+```bash
+sshm e, enable <alias>       # Keep a session alive, auto-reconnect
+sshm d, disable <alias>      # Stop auto-connect
+```
+
+### Import / export
+
+Move hosts, including their keys, between machines as JSON.
+
+```bash
+sshm export servers.json                # Export all hosts
+sshm export prod.json web db api        # Export specific hosts
+sshm l servers.json                     # Preview a JSON file
+sshm import servers.json                # Import (skip existing)
+sshm import servers.json -o             # Import (override existing)
+sshm import servers.json web db         # Import only specific hosts
+sshm import servers.json web=prod       # Import 'web' under the alias 'prod'
+```
+
+### Daemon
+
+The daemon (`sshmd`) starts on first use.
+
+```bash
+sshm status          # Daemon status
+sshm stop            # Stop the daemon
+sshm install         # Autostart on login (systemd / launchd / Task Scheduler)
+sshm uninstall       # Remove autostart
+```
+
+## Shell completions
+
+### fish
+
+`sshm` ships fish completions: subcommands, `port -L/-R/-D` flags, and host aliases
+pulled live from `~/.ssh/config` (including the bare `sshm <alias>` shorthand).
+`uv tool install` does **not** wire these up automatically, so install them once
+(`exec fish` reloads the shell so they're active immediately):
+
+```fish
+sshm completions fish > ~/.config/fish/completions/sshm.fish && exec fish
+```
+
+fish autoloads from that directory — new sessions pick it up with no `source`. From
+a checkout you can instead symlink the source file so edits are picked up live:
+
+```fish
+ln -s (path resolve src/sshm/completions/sshm.fish) ~/.config/fish/completions/sshm.fish
+```
+
+## Session states
+
+| Icon | State    | Meaning                           |
+|------|----------|-----------------------------------|
+| `●`  | ready    | Shell running, waiting for attach |
+| `◆`  | attached | A client is connected             |
+| `○`  | dead     | Process exited                    |
+
+## How it works
+
+```
+sshm (CLI) ── TCP localhost:19222 ──> sshmd (daemon)
+                                        ├── SSH processes (one shell per session)
+                                        ├── Reader threads (scrollback buffer)
+                                        ├── Watchdog (health, reconnect, keep-warm)
+                                        └── IPC server (JSON protocol + I/O bridge)
+```
+
+- The daemon spawns `ssh -tt <alias>` under a real PTY (POSIX; pipes on Windows)
+  and holds the shell process.
+- `connect` bridges your terminal I/O to that process over TCP and forwards your
+  terminal size (and resizes / `SIGWINCH`) so the remote shell matches your window.
+- Detaching (closing the terminal, Ctrl-C) leaves the shell running; reattach later.
+- Typing `exit` in the shell removes the session cleanly — no reconnect.
+- A lost connection (SSH exit 255) triggers reconnect with exponential backoff.
+- Config stays in `~/.ssh/config`. Every rewrite goes to a temp file and is
+  replaced atomically (a `config.bak` is kept), so a crash mid-write won't corrupt it.
+- Runtime state lives in `~/.sshm/`: pid file, IPC token, `sshmd.log`.
+- The IPC server binds `127.0.0.1` only and checks a random per-daemon token
+  (stored `0600` in `~/.sshm/token`) on every request.
+- The IPC port defaults to `19222`; set `SSHM_PORT` to change it (e.g. to run sshm
+  in both Windows and WSL when mirrored networking shares localhost). `sshm install`
+  persists the port to `~/.sshm/port` so the autostarted daemon — which doesn't see
+  your shell env — uses the same one.
+
+## Platforms
+
+- Linux — systemd user service for autostart.
+- macOS — launchd LaunchAgent.
+- Windows — Task Scheduler for autostart, Win32 console VT mode for terminal I/O.
+
+On POSIX, ssh runs under a real PTY, so the remote shell tracks your window size
+and resizes. Windows has no `pty` module, so there a session keeps the size it
+attached with — full-screen apps (`vim`, `htop`) won't follow later resizes.
+
+## Development
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the full branch / commit / PR workflow.
+
+```bash
+uv sync           # install dependencies (including the dev group)
+uv run pytest     # run the tests
+```
+
+Module layout (`src/sshm/`):
+
+| Module         | Responsibility                                            |
+|----------------|-----------------------------------------------------------|
+| `cli.py`       | CLI commands (click), entry point `sshm`                  |
+| `daemon.py`    | `sshmd`: request dispatch, watchdog, entry `sshmd`        |
+| `process.py`   | SSH sessions: PTY spawn, scrollback, reconnect, health    |
+| `ipc.py`       | TCP IPC client/server on `127.0.0.1:19222` (token auth)   |
+| `protocol.py`  | JSON message schema for IPC                               |
+| `config.py`    | `~/.ssh/config` parser/writer, port-forward rules         |
+| `terminal.py`  | Raw terminal bridge (termios on Unix, Win32 console API)  |
+| `procutil.py`  | Cross-platform process helpers (pid checks, Popen flags)  |
+| `state.py`     | `~/.sshm` runtime files: pid, token, port, log            |
+| `autostart.py` | Task Scheduler / systemd / launchd integration            |
+
+## Troubleshooting
+
+### Windows: `Bad owner or permissions on ~/.ssh/config`
+
+OpenSSH on Windows refuses to read `~/.ssh/config` if the ACL contains extra
+principals like `OWNER RIGHTS` (S-1-3-4). Symptom:
+
+```
+Bad permissions. Try removing permissions for user: \\OWNER RIGHTS (S-1-3-4) on file C:/Users/<you>/.ssh/config.
+Bad owner or permissions on C:\\Users\\<you>/.ssh/config
+```
+
+Remove the offending principal:
+
+```powershell
+icacls "$env:USERPROFILE\.ssh\config" /remove "OWNER RIGHTS"
+```
+
+If other files in `.ssh` have the same issue (private keys, etc.):
+
+```powershell
+icacls "$env:USERPROFILE\.ssh\*" /remove "OWNER RIGHTS"
+```
+
+If that's not enough (inheritance can pull in other groups), reset the ACL so only
+you have access:
+
+```powershell
+$f = "$env:USERPROFILE\.ssh\config"
+icacls $f /inheritance:r
+icacls $f /grant:r "$($env:USERNAME):(F)"
+```
+
+If `icacls` returns `Access is denied`, you don't own the file. Take ownership
+first, then fix the ACL:
+
+```powershell
+takeown /F "$env:USERPROFILE\.ssh\config"
+icacls "$env:USERPROFILE\.ssh\config" /grant "$($env:USERNAME):F"
+icacls "$env:USERPROFILE\.ssh\config" /inheritance:r
+icacls "$env:USERPROFILE\.ssh\config" /grant:r "$($env:USERNAME):(F)"
+```
+
+If `takeown` fails, run PowerShell as Administrator and repeat. Verify with
+`icacls "$env:USERPROFILE\.ssh\config"` — only your user with `(F)` should remain.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

sshmd-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+sshm/__init__.py,sha256=Y08F-pbSNt9Qn4jKXwrI1RMqEfeUPQSOMR_-wbuTiLc,99
+sshm/__main__.py,sha256=Qe_SH_wVLnIAdV1SGaNNsXuByZEMfJlf-XMZ0JTaZrE,69
+sshm/autostart.py,sha256=Xd-55R6KfvRu5-_PmetiXDUPyTT5ACn9_FjeRDngcl0,4584
+sshm/cli.py,sha256=4LKV44Ai6d7h_DIWRGXbCKfXPIe7TF7BrxizyQbIk4w,26222
+sshm/completions/sshm.fish,sha256=9PNgf-W-bVQg0D61Ja1hTvSrfYOQEAADfkwCOtAIClA,5603
+sshm/config.py,sha256=c5kPWcSyrVAz4m2PNFjTshjy3wiwjg-weAWVfKFG_MU,12329
+sshm/daemon.py,sha256=0mcWHHsAMUx6_2lQg3S6eh-sKHcbkc8A8nF-bTt-Jug,10797
+sshm/ipc.py,sha256=m-Ym_bE8s8QhgkFYfzr3qpiivM7dUA7ADJJtkcPE_J8,8137
+sshm/process.py,sha256=rLtabhPGDS1Vh2gi4JXHbdly4Mro1g4UPAKRj_BXeo0,21101
+sshm/procutil.py,sha256=nzfG0ukHYqDtjpPGCFVO1PZF1A2CyLrDkJqEcLID9PE,2033
+sshm/protocol.py,sha256=axTnLqUC4zbTza4QX5x64zbVtrPhU2eWlAuQckfQhcc,1272
+sshm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sshm/state.py,sha256=myemTcAHgC7U4m-IBZkFKX9RkazXYCILz6XJtNYIpq8,1634
+sshm/terminal.py,sha256=KM7GeBfNdC6CMK2UN0oSXpVf4xNW61qNSJ-uBjj2EUM,6598
+sshmd-0.1.0.dist-info/licenses/LICENSE,sha256=DtR0oMTDZc6VZkhxNNyWp5U4b1uCYyTEAzyfP3eRQ_4,1066
+sshmd-0.1.0.dist-info/WHEEL,sha256=8ZlpUMJ7mlDirmlHRhDirEx_nPnARrwDjeE92mlk68E,81
+sshmd-0.1.0.dist-info/entry_points.txt,sha256=YiUEbn59iKt0OAuvYdNw_Bk2NThpg6Y7b1YaIieNs8I,65
+sshmd-0.1.0.dist-info/METADATA,sha256=qnh82o19wA8NtBzgCIQyMu08Lwqc0NQALc3MIwb0l4Y,11687
+sshmd-0.1.0.dist-info/RECORD,,

sshmd-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.21
+Root-Is-Purelib: true
+Tag: py3-none-any

sshmd-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+sshm = sshm.cli:main
+sshmd = sshm.daemon:main
+

sshmd-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 revsearch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.