peerline 0.1.0-alpha.9 → 0.1.0-beta.0

package/README.md

@@ -4,7 +4,7 @@ Peerline is a terminal-first peer-to-peer file transfer tool.
 
 It is built for the moments when you want to move files, folders, logs, build artifacts, or project snapshots directly between two machines without first uploading them to a cloud drive. One side opens a receive session, shares a human-friendly name and code, and the other side sends one or more paths. Peerline then tries to find the best route between the two peers and transfers the data with application-layer end-to-end encryption.
 
-Peerline is not a sync service and it does not keep a permanent hosted copy of your files. It is closer to a one-shot terminal copy workflow: start a receiver, send the paths, verify the transfer, and exit.
+Peerline is not a sync service and it does not keep a permanent hosted copy of your files. It is closer to a terminal copy workflow: start a receiver, send one or more batches of paths, verify the transfer, and exit when you are done.
 
 ## Why Peerline Exists
 
@@ -18,12 +18,14 @@ Peerline is not a sync service and it does not keep a permanent hosted copy of y
 
 Peerline has two roles:
 
-- Receiver: runs `peerline recv`, listens for one incoming transfer, and prints a `name`, `code`, and direct endpoint.
+- Receiver: runs `peerline recv`, keeps listening for incoming transfers until you quit or the idle timeout expires, and prints a `name`, `code`, and direct endpoint.
 - Sender: runs `peerline send`, points at the receiver by name/code or IP/code, and provides the files or folders to send.
 
 For named transfers, the receiver publishes a short-lived descriptor keyed by the shared name and code. The sender derives the same lookup key, discovers candidate routes, and tries them in order. Peerline prefers direct LAN or public TCP endpoints first, then libp2p routes such as DCUtR and WebRTC TURN. Relay data fallback is available only when explicitly enabled.
 
-For direct transfers, the sender can skip discovery and dial an IP address or `host:port` directly. This is useful on the same network, over VPNs, or whenever the receiver already knows which address the sender should use.
+Peerline also probes HTTP rendezvous first, with a default endpoint at `https://peerline.pwp.sh`, then falls back to DHT and mDNS. Official builds use a private mTLS-protected rendezvous endpoint; set `PEERLINE_RENDEZVOUS_CLIENT_IDENTITY_PATH` or `PEERLINE_RENDEZVOUS_CLIENT_IDENTITY_PEM` to a PEM bundle with the client certificate and private key, or set `PEERLINE_RENDEZVOUS_URLS` / `PEERLINE_RENDEZVOUS_URL` to point at another compatible rendezvous service. Use `PEERLINE_RENDEZVOUS_TOKEN` only when the rendezvous service expects a shared secret.
+
+For direct transfers, the sender can skip discovery and dial an IP address or `host:port` directly. This is useful on the same network, over VPNs, or whenever the receiver already knows which address the sender should use. If you only provide an IP, Peerline probes the default direct window `43117-43121`.
 
 During a transfer, Peerline scans the requested paths into a manifest, preserves directories with safe relative paths, compresses when useful, and streams the archive to the receiver. The receiver verifies file sizes and BLAKE3 hashes before writing files into the current directory. Existing files are kept by default; conflicting names receive a non-overwriting suffix unless `--overwrite` is used.
 
@@ -71,40 +73,41 @@ The receiver prints values like:
 
 ```text
 peerline recv
-name: river-mango-42
-code: rose-lime-iris-jade-1234
+name: frost-827
+code: fig-mint-1234-5678
 direct: 0.0.0.0:43117
-waiting for one transfer over direct TCP or libp2p...
+waiting for transfers over direct TCP or libp2p...
+idle timeout: 10 min (change with --idle-timeout-minutes)
 ```
 
 Send a file, multiple files, or a folder by name and code:
 
 ```sh
-peerline send river-mango-42 rose-lime-iris-jade-1234 ./file.txt
-peerline send river-mango-42 rose-lime-iris-jade-1234 ./file.txt ./notes.md ./photos
+peerline send frost-827 fig-mint-1234-5678 ./file.txt
+peerline send frost-827 fig-mint-1234-5678 ./file.txt ./notes.md ./photos
 ```
 
 Receive with a saved name:
 
 ```sh
-peerline set name river-mango-42
+peerline set name frost-827
 peerline recv
 ```
 
 After a name is saved, you can receive with only a fresh code:
 
 ```sh
-peerline recv rose-lime-iris-jade-1234
+peerline recv fig-mint-1234-5678
 ```
 
 Use a direct IP address when discovery is not needed:
 
 ```sh
-peerline send 192.168.1.23:43117 ./file.txt --code=rose-lime-iris-jade-1234
-peerline send 192.168.1.23 ./folder --code=rose-lime-iris-jade-1234
+peerline send 192.168.1.23:43117 ./file.txt --code=fig-mint-1234-5678
+peerline send 192.168.1.23 ./folder --code=fig-mint-1234-5678
 ```
 
-When the port is omitted, Peerline uses the default direct port `43117`.
+When the port is omitted, Peerline probes the default direct window `43117-43121`.
 
 ## Common Options
 
@@ -115,8 +118,12 @@ peerline recv [NAME_OR_CODE] [CODE] --port 43117
 peerline recv [NAME_OR_CODE] [CODE] --overwrite
 peerline recv [NAME_OR_CODE] [CODE] --no-tui
 peerline recv [NAME_OR_CODE] [CODE] --allow-relay-fallback
+peerline recv [NAME_OR_CODE] [CODE] --idle-timeout-minutes 30
 ```
 
+`--port` starts the 5-port direct window; Peerline will try that port and the next four.
+`--idle-timeout-minutes` defaults to `10`; set it to `0` to wait until you quit manually.
+
 Sender options:
 
 ```sh
@@ -129,15 +136,18 @@ peerline send --name <name> --code <code> <path...>
 ```
 
 Relay fallback must be enabled on both sides when you want Peerline to use relay data paths. Direct and hole-punched routes are attempted before relay fallback.
+In the send TUI, a failed attempt stays on screen and offers `r` to retry the same send or `q`/Esc to quit.
 
 ## Current Status
 
 - Direct IP send and receive works.
-- Named discovery uses saved names, generated codes, OPAQUE PAKE, Kademlia provider records, mDNS, DCUtR, relay fallback, and libp2p-webrtc's built-in ICE servers.
+- Named discovery now uses HTTP rendezvous first, then Kademlia provider records, mDNS, DCUtR, relay fallback, and libp2p-webrtc's built-in ICE servers.
 - Files, multiple files, and folders are archived with safe relative paths, BLAKE3 integrity checks, and streaming zstd/lzma compression support.
+- Receivers stay open across multiple incoming transfers, with a configurable idle auto-exit.
 - Conflicts default to non-overwrite behavior, with TUI-driven handling in the receiver flow.
 - The receive side includes a modern terminal UI for identity, route state, and transfer progress.
 - The workspace test suite and E2E coverage are in place.
+- The repository also includes a private Cloudflare Worker rendezvous service in `services/peerline-rendezvous`.
 
 ## License
 

package/npm/peerline.js

@@ -292,7 +292,20 @@ function executeBinary(binaryPath, argv = process.argv.slice(2), deps = {}) {
 
 async function main(argv = process.argv.slice(2), deps = {}) {
   const result = executeBinary(await resolveBinary(deps), argv, deps);
-  process.exit(result.status ?? 1);
+  process.exit(exitCodeForResult(result));
+}
+
+function exitCodeForResult(result) {
+  if (Number.isInteger(result?.status)) {
+    return result.status;
+  }
+  if (result?.signal === "SIGINT") {
+    return 130;
+  }
+  if (result?.signal === "SIGTERM") {
+    return 143;
+  }
+  return 1;
 }
 
 if (require.main === module) {
@@ -310,6 +323,7 @@ module.exports = {
   downloadReleaseBinary,
   ensureExecutable,
   executeBinary,
+  exitCodeForResult,
   copyBinaryToTemporaryLocation,
   formatExecutionFallbackError,
   isRetryableExecutionError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peerline",
-  "version": "0.1.0-alpha.9",
+  "version": "0.1.0-beta.0",
   "description": "P2P post-quantum encrypted file transfer CLI",
   "repository": {
     "type": "git",