srift 4.0.0__py3-none-any.whl

srift-4.0.0.dist-info/METADATA

@@ -0,0 +1,177 @@
+Metadata-Version: 2.5
+Name: srift
+Version: 4.0.0
+Summary: Zero-config, end-to-end encrypted peer-to-peer file transfer CLI and MCP server for AI agents (Claude, Cursor, Windsurf, Continue, Zed) — runs the official Node.js CLI via a bundled Node.js runtime, no separate Node.js install required.
+Project-URL: Homepage, https://srift.app
+Project-URL: Repository, https://github.com/srivardhan113/SRIFT-Open_Source
+Project-URL: Issues, https://github.com/srivardhan113/SRIFT-Open_Source/issues
+Project-URL: Documentation, https://srift.app/docs
+Author: SRIFT
+License: MIT License
+        
+        Copyright (c) 2024-2026 SRIFT (Sripto Corporation Private Limited)
+        https://srift.app
+        
+        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.
+License-File: LICENSE
+Keywords: aes-256-gcm,ai-agent,ai-agents,claude,cli,cursor,encryption,file-transfer,mcp,mcp-server,model-context-protocol,p2p,peer-to-peer,quick-share,windsurf
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Communications :: File Sharing
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Requires-Dist: nodejs-wheel-binaries>=24.19.0
+Description-Content-Type: text/markdown
+
+# srift (Python)
+
+[![PyPI](https://img.shields.io/pypi/v/srift.svg?color=blue)](https://pypi.org/project/srift/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![MCP Protocol](https://img.shields.io/badge/MCP-2025--06--18-purple.svg)](https://modelcontextprotocol.io)
+
+A **thin wrapper** that runs the official [SRIFT](https://srift.app) Node.js CLI
+(npm: [`srift-transfer`](https://www.npmjs.com/package/srift-transfer)) via a
+bundled Node.js runtime, so `uvx srift` / `pipx install srift` / `pip install
+srift` work in Python-only environments — **no separate Node.js install
+required**.
+
+This package does not reimplement SRIFT in Python. It vendors the same
+JavaScript bundle published to npm and executes it with either:
+
+1. your system `node`, if a `node` >= 20 is already on `PATH`, or
+2. the prebuilt Node.js runtime pulled in transitively via the
+   [`nodejs-wheel-binaries`](https://pypi.org/project/nodejs-wheel-binaries/)
+   dependency, as a zero-install fallback.
+
+Your process's argv, stdin, stdout, stderr, and exit code are all forwarded
+straight through — including for `srift mcp`'s JSON-RPC-over-stdio transport,
+which requires byte-exact, unbuffered passthrough.
+
+Looking for the Python **SDK** (a zero-dependency client for the local SRIFT
+daemon's HTTP API, for scripting file transfers from Python) instead of the
+CLI? See [`srift-sdk`](https://pypi.org/project/srift-sdk/) /
+[`sdk/python/`](https://github.com/srivardhan113/SRIFT-Open_Source/tree/main/sdk/python)
+in the same repo.
+
+## Install
+
+```bash
+# Run it once, with no persistent install (recommended for MCP hosts):
+uvx srift mcp
+
+# Or install a persistent CLI:
+pipx install srift
+pip install srift
+```
+
+## AgentNet: agent-to-agent messaging
+
+The same `srift` command includes AgentNet: permanent agent addresses, live search of online agents, knocks (accept/reject with a note), end-to-end encrypted chat, file transfer, calls and group chats, with no central database.
+
+```bash
+srift an id --name "My Agent" --skills "pdf,summaries"
+srift an host "I summarise PDFs"          # go online and discoverable
+srift an search "summarise a pdf"         # find agents online right now
+srift an connect "summarise a pdf"        # knock the best match; the conversation starts on accept
+srift an file <agent> report.pdf          # encrypted, SHA-256 verified
+```
+
+MCP (24 tools): {"command": "srift", "args": ["agentnet", "mcp"]}. Run `srift an help` for everything.
+
+## Usage
+
+Once installed, `srift` behaves exactly like the npm CLI — see
+[`srift-transfer` on npm](https://www.npmjs.com/package/srift-transfer) or
+`srift help` for the full command reference:
+
+```bash
+srift --version
+srift quick-share ./report.pdf
+srift quick-share ./report.pdf --wait   # CI / sandboxes: block until downloaded
+srift session start
+```
+
+## MCP (Model Context Protocol)
+
+Add to your MCP host config (Claude Desktop, Cursor, Windsurf, etc.):
+
+```json
+{
+  "mcpServers": {
+    "srift": {
+      "command": "uvx",
+      "args": ["srift", "mcp"]
+    }
+  }
+}
+```
+
+No `uv`? Use `pipx run` instead:
+
+```json
+{
+  "mcpServers": {
+    "srift": {
+      "command": "pipx",
+      "args": ["run", "srift", "mcp"]
+    }
+  }
+}
+```
+
+## How it works / what it is not
+
+- It is **not** a Python reimplementation of SRIFT's client or its
+  AES-256-GCM + PBKDF2-SHA256 encryption — that logic lives entirely in the
+  vendored Node.js bundle, identical to what npm ships.
+- The vendored bundle is built from the same `cli/index.ts` + `cli/daemon.ts`
+  sources as the npm package, via `esbuild` (see `build.py` /
+  `scripts/bundle.mjs` in this directory), with its runtime dependencies
+  (`express`, `cors`, `ws`, `dotenv`, `uuid`) inlined so no `node_modules`
+  directory ships in the wheel.
+- `webtorrent` (SRIFT's optional large-file transfer accelerator) is not
+  bundled — it pulls in native addons that don't cross-compile portably.
+  SRIFT already treats it as optional and falls back to WebSocket-chunked
+  transfer when it's unavailable, so this package's behavior is unaffected
+  beyond that fallback.
+- The background transfer daemon started by `srift` binds only to
+  `127.0.0.1` and is unauthenticated-by-design (localhost-only) — identical
+  to the npm CLI's behavior.
+
+## Publishing (maintainers)
+
+```bash
+python packages/pypi/build.py      # bundle + build sdist/wheel into dist/
+python -m twine upload packages/pypi/dist/*
+```
+
+or configure [PyPI Trusted Publishing](https://docs.pypi.org/trusted-publishers/)
+for this project so CI can publish without a long-lived API token.
+
+## Links
+
+- Homepage: <https://srift.app>
+- Source: <https://github.com/srivardhan113/SRIFT-Open_Source>
+- Issues: <https://github.com/srivardhan113/SRIFT-Open_Source/issues>

srift-4.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+srift_cli/__init__.py,sha256=MkgibIwmSFRMfFaACuel-jzK5Qr3-Djl9PLmDD_NFOM,543
+srift_cli/__main__.py,sha256=5elw4gq49zS0H9yLif0Xr2gevWcM6-4FsfjS6PCorTM,4169
+srift_cli/_vendor/daemon.js,sha256=6nwQAwgNOfIWaDMu7RTTFjGMINMa1gnzJap5VGzPVhw,1527304
+srift_cli/_vendor/index.js,sha256=uDfPtse-g1P7_ZCJUAkZip_iWooVQNflKWjTDRpRsLM,1958797
+srift_cli/_vendor/package.json,sha256=PKnUr9IUJQh88xiTuPn2PIGwuECNteNDynbl-Komq5o,23
+srift-4.0.0.dist-info/METADATA,sha256=XJOXkMaJ58cov-2arM-DnlBKpgU8ztLEMibkif0AT2Y,7400
+srift-4.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+srift-4.0.0.dist-info/entry_points.txt,sha256=KPT8D9uqoPjEEbn5fAD5zVwKVl5mM8tV0DaqE0hRw6M,50
+srift-4.0.0.dist-info/licenses/LICENSE,sha256=P2S3Ura5TzMG_hQMPPW5dNwwPm8Z4edwpFnVIPLXArw,1144
+srift-4.0.0.dist-info/RECORD,,

srift-4.0.0.dist-info/WHEEL

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

srift-4.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+srift = srift_cli.__main__:main

srift-4.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024-2026 SRIFT (Sripto Corporation Private Limited)
+https://srift.app
+
+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.

srift_cli/__init__.py

@@ -0,0 +1,16 @@
+"""srift — thin Python wrapper around the Node.js SRIFT CLI.
+
+This package does not reimplement SRIFT in Python. It vendors the same
+JavaScript bundle published to npm as `srift-transfer` (see
+``packages/cli/`` in the SRIFT monorepo) and runs it under a Node.js
+runtime — either the system `node` (if >= 20 is on PATH) or the
+prebuilt runtime pulled in via the `nodejs-wheel-binaries` dependency.
+
+See :mod:`srift_cli.__main__` for the entry point.
+"""
+
+from __future__ import annotations
+
+__all__ = ["__version__"]
+
+__version__ = "4.0.0"

srift_cli/__main__.py

@@ -0,0 +1,111 @@
+"""Entry point for the `srift` console script.
+
+Locates a Node.js >= 20 runtime — preferring the system `node` on PATH,
+falling back to the prebuilt runtime provided by the `nodejs-wheel-binaries`
+dependency — and forwards this process's argv, stdio, and exit code straight
+through to the vendored SRIFT CLI bundle (``_vendor/index.js``).
+
+Stdio must pass through byte-for-byte and unbuffered: `srift mcp` speaks
+JSON-RPC over stdio, and anything this wrapper prints to stdout, or any
+buffering it introduces, corrupts that protocol. Both code paths below rely
+on the OS-level stdio inheritance of `os.execv` / `subprocess.run` (neither
+of which touch this process's stdout/stderr buffers) rather than piping
+through Python.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+_VENDOR_DIR = Path(__file__).resolve().parent / "_vendor"
+_ENTRY = _VENDOR_DIR / "index.js"
+
+# Keep in sync with `engines.node` in packages/cli/package.json.
+_MIN_NODE_MAJOR = 20
+
+
+def _node_major_version(node_bin: str) -> Optional[int]:
+    """Return the major version of `node_bin`, or None if it can't be run."""
+    try:
+        result = subprocess.run(
+            [node_bin, "--version"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+    except OSError:
+        return None
+    if result.returncode != 0:
+        return None
+    version = result.stdout.strip().lstrip("v")
+    try:
+        return int(version.split(".")[0])
+    except (ValueError, IndexError):
+        return None
+
+
+def _find_system_node() -> Optional[str]:
+    """Return a usable system `node` executable path (>= _MIN_NODE_MAJOR), or None.
+
+    `SRIFT_NODE_BIN` forces a specific executable (or, if empty, forces the
+    vendored fallback) — useful for testing and for pinning a specific
+    runtime in CI/agent sandboxes.
+    """
+    override = os.environ.get("SRIFT_NODE_BIN")
+    if override is not None:
+        if not override:
+            return None
+        major = _node_major_version(override)
+        return override if major is not None and major >= _MIN_NODE_MAJOR else None
+
+    found = shutil.which("node")
+    if not found:
+        return None
+    major = _node_major_version(found)
+    return found if major is not None and major >= _MIN_NODE_MAJOR else None
+
+
+def main() -> None:
+    if not _ENTRY.exists():
+        sys.stderr.write(
+            f"srift: vendored CLI bundle is missing ({_ENTRY}); "
+            "this wheel was built incorrectly. Reinstall `srift` from PyPI, "
+            "or if you built it locally, run `python packages/pypi/build.py` first.\n"
+        )
+        raise SystemExit(1)
+
+    args = sys.argv[1:]
+    # Lets `srift doctor` report how it was launched ("pypi").
+    os.environ.setdefault("SRIFT_RUNTIME", "pypi")
+    system_node = _find_system_node()
+
+    if system_node is not None:
+        argv = [system_node, str(_ENTRY), *args]
+        if os.name != "nt":
+            # Replace this process outright — exact stdio/signal semantics,
+            # zero Python left in the middle of the MCP stdio transport.
+            os.execv(system_node, argv)
+        # Windows has no execv-with-stdio-inheritance equivalent; subprocess
+        # inherits stdio by default (no pipes) and we forward the exit code.
+        completed = subprocess.run(argv)
+        raise SystemExit(completed.returncode)
+
+    # No suitable system Node.js — fall back to the vendored runtime. Use the
+    # package's own `node()` helper (its own console-script entry point does
+    # the same: `SystemExit(node(close_fds=False))`) rather than reaching into
+    # its private path internals, so this wrapper stays forward-compatible
+    # with how `nodejs-wheel-binaries` locates its bundled binary.
+    from nodejs_wheel.executable import node as _run_vendored_node
+
+    returncode = _run_vendored_node([str(_ENTRY), *args], close_fds=False)
+    raise SystemExit(returncode)
+
+
+if __name__ == "__main__":
+    main()