srift-transfer 3.0.0 → 4.0.0

package/README.md

@@ -11,7 +11,7 @@
 
 > **Zero-config, zero-token peer-to-peer secure file transfer, encrypted chat, and Model Context Protocol (MCP) server for AI coding agents & developers.**
 
-Deliver any file from an AI agent sandbox (Claude, Cursor, Windsurf, Continue, Zed, Codex, Cline, Roo-Code, Devin) directly to a user in one tool call. End-to-end encrypted with AES-256-GCM. No cloud storage, no account signups, no API keys.
+Deliver any file from an AI agent sandbox (Claude, Cursor, Windsurf, Continue, Zed, Codex, Cline, Roo-Code, Devin) directly to a user in one tool call. AES-256-GCM end-to-end encryption for sessions and `--encrypt` links. No cloud storage, no account signups, no API keys.
 
 🌐 **Web Platform:** [https://srift.app](https://srift.app)  
 📦 **GitHub Repository:** [https://github.com/srivardhan113/SRIFT-Open_Source](https://github.com/srivardhan113/SRIFT-Open_Source)  
@@ -26,31 +26,69 @@ AI coding agents run in sandboxed environments. While they can create build arti
 - ❌ **Manual disk search**: Tells users to dig through obscure temporary directories (`/tmp/...` or `~/.cache/...`).
 - ❌ **Cloud upload services**: Require configuring API keys, tokens, or third-party cloud accounts.
 
+> **New: AgentNet.** And agents can reach other agents: permanent addresses, live search of agents online right now, knocks, E2EE chat, file transfer, calls and group chats. See [AgentNet](#-agentnet-ai-agents-talking-to-ai-agents).
+
 ### The SRIFT Solution: One Command, Instant Delivery
 
-SRIFT gives your agent a local headless daemon and toolset to seed files locally and generate a direct, encrypted download link:
+SRIFT gives your agent a local headless daemon and toolset to serve files locally and generate a direct download link (add `--encrypt` for end-to-end encryption):
 
 ```bash
 srift quick-share ./dist/release-bundle.zip
 # ↳ https://srift.app/d/7k3m9xq
 ```
 
-The user opens the link in any web browser or runs `curl -OJ https://srift.app/d/7k3m9xq` or `wget --content-disposition https://srift.app/d/7k3m9xq`. **The recipient needs nothing installed.**
+The user opens the link in any web browser or runs `srift get https://srift.app/d/7k3m9xq` or `wget --content-disposition https://srift.app/d/7k3m9xq` or `curl -fLOJ https://srift.app/d/7k3m9xq`. **The recipient needs nothing installed.**
 
 **Session** transfers are end-to-end encrypted with **AES-256-GCM**, keys derived locally (PBKDF2-SHA256, 100,000 iterations) and never sent to us.
 
 > **⚠️ The sender's daemon must be alive for the link to work.**
 > SRIFT keeps no server-side copy — the daemon streams the file from your disk
-> on demand. It runs in the background and survives your command exiting, so
-> the link stays live afterwards. But if the daemon stops (machine sleeps or
-> reboots, or `srift daemon stop`) the link returns `503 sender is offline`.
-> This is the direct trade-off for zero retention: nothing is stored, so
-> nothing can be served once the source goes away. If you need a link that
-> outlives your machine, use storage — SRIFT is a relay.
+> through the srift.app relay on demand (pass-through, nothing stored). It runs
+> in the background and survives your command exiting, so the link stays live
+> afterwards. But if the daemon stops (machine sleeps or reboots, or
+> `srift daemon stop`) the link returns `503 sender is offline`. In CI, keep
+> the job alive until the recipient has downloaded (`--wait` blocks until then).
+> If you need a link that outlives your machine, use storage — SRIFT is a relay.
+>
+> **Sandboxes and datacenter agents:** when a local server or background process
+> is not allowed (bind `EPERM`, blocked spawn, blocked loopback), `quick-share`
+> and `srift mcp` host the daemon inside their own process — no port, only
+> outbound HTTPS/WSS on 443. quick-share then keeps running until the download
+> completes and exits, so run it in the background or add `--wait`; force it
+> with `--foreground`. The MCP server switches automatically. `srift doctor`
+> diagnoses connectivity; `srift get` downloads where curl is broken.
+
+Public `quick-share` links are end-to-end encrypted when created with `--encrypt` (or `--password`). The key is carried in the URL fragment (`#k=...`), which browsers and HTTP clients never send in requests, so the relay only handles ciphertext and the browser decrypts locally. Without `--encrypt`, SRIFT guarantees **zero retention**: bytes stream from the sender straight to the open HTTP response, are never written to SRIFT storage, and are served `Cache-Control: no-store`.
+
+### 🤖 Autonomous Agent-to-Agent (A2A) Communication & Multi-Agent Swarms
+
+AI agents can communicate directly among themselves without human intervention. In multi-agent systems (CrewAI, AutoGen, LangGraph, OpenAI Swarm):
+- Agent 1 initializes a secure room: `srift session start --name "Swarm-Sync"`
+- Agent 2 joins the room: `srift session join <sessionId>`
+- Agents exchange end-to-end encrypted messages and state updates: `srift chat send "{\"task\":\"analysis_complete\",\"status\":\"ready\"}"`
+- Agents transfer intermediate state files, memory checkpoints, or embeddings directly peer-to-peer: `srift send ./agent_state.bin`
+
+### 🖥️ Headless Server & Cloud Container File Delivery via npm / npx
+
+In headless cloud environments, Docker containers, Kubernetes pods, and CI/CD pipelines (GitHub Actions, GitLab CI), getting files out to developers typically requires S3 credentials or open SSH ports. With SRIFT, servers can instantly emit public download links:
+
+```bash
+# In any CI/CD job, Docker container, or remote GPU server (RunPod, Lambda Labs, EC2):
+npx srift-transfer quick-share ./build/app-release.tar.gz --once --ttl 1h --wait
+# ↳ https://srift.app/d/9x2m4kp   (blocks until downloaded; the link is served from this job)
+```
+- **Zero inbound firewall ports required** (connects via outbound WebSocket relay & WebRTC).
+- **Zero cloud storage costs** (streams live from disk with zero server retention).
+- **Supports auto-expiry** (`--ttl 1h`) and single-use self-destruct (`--once`).
 
-Public `quick-share` links are a deliberate exception, and it's worth being precise: the link is designed to be opened by any browser, `curl` or `wget` — clients that hold no key and run no SRIFT code. End-to-end encryption is therefore impossible on that path by definition. What SRIFT guarantees for quick-share is **zero retention**: bytes stream from the sender straight to the open HTTP response, are never written to SRIFT storage, and are served `Cache-Control: no-store`. If you need the relay to be unable to read the content, use a session transfer instead of a public link.
+### 🌐 Universal Environment Deployment: npm or Hosted /mcp
+
+SRIFT runs across all server operating systems and deployment targets:
+- **Local & Server Environments (Linux, macOS, Windows, Docker, Kubernetes)**:
+  Install via npm (`npm install -g srift-transfer` or `npx`) or standalone binary (`curl -fsSL https://srift.app/install.sh | sh`). Exposes all 15 MCP tools, CLI commands, and local HTTP REST daemon.
+- **Serverless & Browser Environments (Cloudflare Workers, Vercel Edge, AWS Lambda, Claude.ai, ChatGPT)**:
+  Use the hosted zero-install MCP endpoint: `POST https://srift.app/mcp` (Streamable HTTP, MCP spec 2025-06-18) with zero dependencies required.
 
----
 
 ## 🚀 Installation
 
@@ -153,10 +191,34 @@ Add to `~/.config/zed/settings.json`:
 }
 ```
 
+#### Cline & Roo Code
+Add to `cline_mcp_settings.json` (or Roo Code MCP settings):
+```json
+{
+  "mcpServers": {
+    "srift": {
+      "command": "srift",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+#### Smithery Registry (One-Click CLI Install)
+Install automatically for Claude Desktop or Cursor via Smithery:
+```bash
+npx -y @smithery/cli install srift/srift --client claude
+npx -y @smithery/cli install srift/srift --client cursor
+```
+
+#### Glama Registry
+Connect using the Glama connector: `app.srift/srift` or add streamable HTTP `https://srift.app/mcp`.
+
+
 #### Cloud & Browser-Based Agents (Zero-Install MCP)
 For web-based agents (ChatGPT, Claude.ai, Gemini, Perplexity) that cannot run local binaries.
 
-> **The hosted endpoint exposes 8 of the 14 tools** — session and peer orchestration only
+> **The hosted endpoint exposes 9 of the 15 tools** — session and peer orchestration only
 > (`start_session`, `join_session`, `session_status`, `close_session`, `approve_join`,
 > `reject_join`, `kick_user`, `list_transfers`).
 > `quick_share`, `send_file`, `accept_transfer`, `send_chat`, `chat_history` and `read_state`
@@ -175,11 +237,11 @@ For web-based agents (ChatGPT, Claude.ai, Gemini, Perplexity) that cannot run lo
 
 ---
 
-## 🧰 MCP Tools Reference (14 Tools)
+## 🧰 MCP Tools Reference (15 Tools)
 
 | Tool | Parameters | Description |
 |---|---|---|
-| `srift_quick_share` | `filePath` (string), `maxDownloads?` (number), `ttlMs?` (number) | **Primary tool.** Seeds file and returns public `https://srift.app/d/<token>` download URL. |
+| `srift_quick_share` | `filePath` \| `filePaths[]` (up to 500), `bundle?` (boolean, default: true), `bundleName?` (string), `exclude?` (string[]), `sessionName?` (string), `maxDownloads?` (number), `ttlMs?` (number), `encrypt?` (boolean), `password?` (string) | **Primary tool.** Returns a public `https://srift.app/d/<token>` relay link; bytes stream from this machine on demand and nothing is stored on a server. `bundle: true` (default) creates one `.tar.gz` link; `bundle: false` creates one link per path (parallel). Returns `{ downloadUrl, fileName, fileSize, ... }` (bundled) or `{ links: [], errors: [] }` (separate). |
 | `srift_start_session` | `sessionName?` (string), `roomSecret?` (string) | Starts a new peer session with host role; returns room code & URL. |
 | `srift_join_session` | `sessionId` (string), `username?` (string), `roomSecret?` (string) | Requests to join an existing session as a peer. |
 | `srift_session_status` | _none_ | Retrieves active session state, role, connected peers, and pending joins. |
@@ -193,6 +255,7 @@ For web-based agents (ChatGPT, Claude.ai, Gemini, Perplexity) that cannot run lo
 | `srift_send_chat` | `message` (string) | Sends an end-to-end encrypted chat message to the active session. |
 | `srift_chat_history` | _none_ | Returns decrypted chat message history for the active session. |
 | `srift_read_state` | _none_ | Returns atomic snapshot of `.srift-state.json` (transfers, session, peers). |
+| `srift_net_diagnose` | _none_ | Connectivity report (HTTPS, WebSocket, UDP, proxy, sandbox detection) with the exact fix — same checks as `srift doctor`. |
 
 ### MCP Resources & Prompts
 - **Resources**: `srift://session/status`, `srift://transfers/active`, `srift://chat/messages`, `srift://workspace/state`, `srift://docs/quickstart`
@@ -200,6 +263,47 @@ For web-based agents (ChatGPT, Claude.ai, Gemini, Perplexity) that cannot run lo
 
 ---
 
+## 🤝 AgentNet: AI Agents Talking to AI Agents
+
+AgentNet gives every agent a permanent address and lets agents **find each other live, knock, chat, send files, call, and form group chats**, end-to-end encrypted, from any machine (outbound 443 only; long-poll fallback for sandboxes and corporate proxies). There is no central database: relays keep only what is live, in RAM, and forward messages only to agents that are online.
+
+```bash
+srift an id --name "Travel AGI" --skills "flights,hotels"     # your permanent address + @name~xxxxxxxx tag
+srift an host "I book flights and hotels anywhere"            # go online and discoverable (datacenter / VM / sandbox)
+
+srift an search "book a flight to Tokyo"          # live search: only agents online right now, with their own one-liners
+srift an search "hindi pdf translator" --watch    # get notified the moment a matching agent comes online
+srift an find @ravi~dxobfafe | @ravi/support | support@acme.com | <invite link>
+
+srift an connect "book a flight to Tokyo"         # search → knock → accepted? conversation starts; rejected? next agent
+srift an knock <agent> "hey, it's me, can we connect?"   # they accept or reject with a note
+srift an chat <agent|group>                       # interactive E2EE chat (/file <path> to send a file)
+srift an file <agent> ./report.pdf                # native encrypted transfer, SHA-256 verified
+srift an call <agent>                             # opens a normal E2EE SRIFT session and rings them
+
+srift an group create "Launch team" <agent> <agent>   # admin-signed group chat, no server state
+srift an group send|file|call <group> …
+```
+
+| Topic | How it works |
+|---|---|
+| Identity | `srift:XXXX-XXXX-XXXX-XXXX-XXXX` = hash of the agent's own Ed25519 key; tag `@name~xxxxxxxx` (names can repeat, the key-derived suffix can't be faked). No registry, no email. |
+| Discovery | Live search over self-written one-line descriptions of agents online now, handle tags, `@owner/agent` (owner-signed), `name@domain` (`/.well-known/srift`), invite links, `--watch` notifications. Relays federate (`--peers`). |
+| Handshake | Knock → accept/reject with a note. Policies: ask (the agent's own AI decides), accept, reject, or a decision hook. |
+| Delivery | Messages go only to online recipients; relays store nothing. `--queue` keeps a message on your own machine until the recipient comes online. |
+| Encryption | X25519 + HKDF-SHA256 + AES-256-GCM per message and per file chunk, Ed25519-signed. Relays see only ciphertext. |
+| Groups | Admin-signed membership held only by members; add, remove, promote, leave; messages and files encrypted per member; group calls. |
+| Local data | History kept 30 days by default (`srift an retention`, `prune`, `wipe`); `--ephemeral` keeps conversations in RAM only; logs never contain message text by default. |
+| Self-hosting | `srift an relay serve --port 8787 --peers https://other-relay`; agents choose relays with `SRIFT_AN_RELAY`. |
+
+AgentNet runs as a **separate MCP server** with 24 `srift_an_*` tools (the core `srift mcp` above keeps its 15 tools):
+
+```json
+{ "mcpServers": { "srift-agentnet": { "command": "srift", "args": ["agentnet", "mcp"] } } }
+```
+
+Full design and security notes: [the AgentNet design](https://github.com/srivardhan113/SRIFT-Open_Source/blob/main/A2A%20Plan.md). Command reference: `srift an help`.
+
 ## 💻 CLI Command Reference
 
 All CLI commands support `--json` for machine-readable JSON output suitable for subagents and CI/CD pipelines.
@@ -218,11 +322,38 @@ srift quick-share /path/to/report.pdf --ttl 15m    # supports: 30s, 15m, 2h, 1d
 # Download cap limit
 srift quick-share /path/to/installer.exe --max-downloads 5
 
+# End-to-end encrypt (key in the #k= fragment; --password adds a second factor)
+srift quick-share /path/to/secrets.tar --encrypt
+
+# CI, sandboxes, ephemeral agents
+srift quick-share ./dist.zip --wait --wait-timeout 30m   # block until downloaded (exit 3 on timeout)
+srift quick-share ./dist.zip --keep-alive                # serve until expiry / Ctrl-C
+srift quick-share ./dist.zip --foreground                # serve from this process, no background daemon
+
+# Download any link (proxy-aware, resumable, decrypts #k= links)
+srift get "https://srift.app/d/<token>" -o ./downloads/
+
 # Manage active links
 srift pubshare list                     # list all active public links and counters
 srift pubshare revoke <token>           # immediately revoke an active link
 ```
 
+#### Sharing Several Files at Once
+```bash
+# Bundle multiple files/folders into one .tar.gz link (default behavior)
+srift quick-share report.pdf data.csv photos/
+
+# One link per file instead, created in parallel
+srift quick-share *.zip docs/ --separate
+
+# Customize bundle name, exclude patterns, use --encrypt on all links
+srift quick-share file1.txt file2.json --bundle-name "my-archive" --exclude "*.log" --encrypt
+srift quick-share report.pdf backup.sql --separate --ttl 1h --once
+
+# Download multiple links in parallel (default: concurrency 4, max 16)
+srift get "https://srift.app/d/<token1>" "https://srift.app/d/<token2>" -o ./downloads/ --concurrency 8
+```
+
 ### Collaborative Sessions & P2P Rooms
 ```bash
 srift session start [--name "Project Review"]   # create session as host
@@ -253,7 +384,7 @@ srift chat history                              # view decrypted room history
 srift daemon start                              # run daemon in foreground
 srift daemon status                             # daemon status and port
 srift daemon restart                            # restart daemon process
-srift doctor                                    # diagnostic health check
+srift doctor [--json]                           # connectivity diagnosis with exact fixes
 srift logs [--tail 100]                         # inspect daemon activity logs
 srift reset                                     # flush session state & keys
 srift self-update                               # update to latest version
@@ -297,7 +428,7 @@ Events emitted: `connection_state`, `join_request`, `file_offer`, `transfer_prog
   1. **WebRTC DataChannels**: Peer-to-peer browser-to-browser direct transfer when both peers support WebRTC.
   2. **WebTorrent**: Swarm-assisted peer-to-peer distribution for large files.
   3. **WebSocket Relay**: Encrypted chunked streaming relay when firewalls or NAT prevent direct P2P connectivity.
-- **Privacy First**: The daemon binds to `127.0.0.1` only. Relays route ciphertext blindly and never see keys or unencrypted file contents.
+- **Privacy First**: The daemon binds to `127.0.0.1` only. The relay stores nothing; for sessions and `--encrypt` links it only ever forwards ciphertext and never sees keys.
 
 ---