gowalk-cicd 1.0.111 → 1.0.112

package/CLAUDE.md

@@ -143,6 +143,8 @@ node /path/to/gowalk-cicd/bin/cli.mjs
   Crashlytics Buildtools reads them first and rejects authenticated proxy URLs. HTTPS is tunneled
   without TLS interception; no upstream failure may fall back to the destination.
   The wrapper disables Gradle daemons and closes its relay when the command ends.
+  The relay's idle deadline covers the whole tunnel: traffic in either direction
+  keeps downloads/uploads alive. An idle direction alone must never end a transfer.
 - Flutter bootstrap is part of that boundary: before the Flutter setup action,
   `play_store_proxy.py --bootstrap-env` validates the Google account pin and writes
   both proxy/bypass spellings to the private job environment without console output.

package/action/.daemux-version

@@ -1 +1 @@
-1.0.111
+1.0.112

package/android-action/.daemux-version

@@ -1 +1 @@
-1.0.111
+1.0.112

package/android-action/scripts/jvm_proxy_relay.py

@@ -13,8 +13,8 @@ import threading
 from urllib.parse import unquote, urlsplit
 
 
-# A tunnel carries whole SDK/NDK/CMake downloads and Gradle's keep-alive pools; an
-# idle read is not a failure, so pumps wait long and the tunnel closes cleanly.
+# A tunnel carries whole SDK/NDK/CMake downloads and Gradle's keep-alive pools.
+# Only inactivity in both directions expires it; a download may send no requests.
 IDLE_TIMEOUT = 900.0
 
 
@@ -63,11 +63,16 @@ class Relay:
         await writer.drain()
         return reader, writer
 
-    async def _pump(self, reader, writer):
-        while data := await asyncio.wait_for(reader.read(65536), timeout=IDLE_TIMEOUT):
+    async def _pump(self, reader, writer, activity):
+        while data := await reader.read(65536):
+            activity[0] = self.loop.time()
             writer.write(data)
             await writer.drain()
 
+    async def _idle(self, activity):
+        while remaining := max(0.0, activity[0] + IDLE_TIMEOUT - self.loop.time()):
+            await asyncio.sleep(remaining)
+
     async def _handle(self, reader, writer):
         upstream = None
         pumps = []
@@ -82,8 +87,10 @@ class Relay:
                 writer.write(b"HTTP/1.1 200 Connection established\r\n\r\n")
                 await writer.drain()
             established = True
-            pumps = [asyncio.create_task(self._pump(reader, upstream)),
-                     asyncio.create_task(self._pump(upstream_reader, writer))]
+            activity = [self.loop.time()]
+            pumps = [asyncio.create_task(self._pump(reader, upstream, activity)),
+                     asyncio.create_task(self._pump(upstream_reader, writer, activity)),
+                     asyncio.create_task(self._idle(activity))]
             await asyncio.wait(pumps, return_when=asyncio.FIRST_COMPLETED)
         except (OSError, ValueError, IndexError, asyncio.TimeoutError,
                 asyncio.IncompleteReadError, asyncio.LimitOverrunError):

package/android-action/scripts/test_jvm_proxy_idle.py

@@ -0,0 +1,106 @@
+"""A live tunnel stays open for one-way traffic and closes on total inactivity."""
+from contextlib import contextmanager
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+import socket
+import threading
+import unittest
+from unittest import mock
+
+import jvm_proxy_relay as relay
+
+
+PAYLOAD = bytes(range(24))
+INTERVAL = 0.075
+
+
+@contextmanager
+def tunnel(mode):
+    stop = threading.Event()
+    finished = threading.Event()
+    received = []
+
+    class Proxy(BaseHTTPRequestHandler):
+        def do_CONNECT(self):
+            self.send_response(200)
+            self.end_headers()
+            try:
+                if mode == "download":
+                    for value in PAYLOAD:
+                        self.wfile.write(bytes([value]))
+                        if stop.wait(INTERVAL):
+                            break
+                else:
+                    value = self.rfile.read(len(PAYLOAD))
+                    received.append(value)
+                    if mode == "upload":
+                        self.wfile.write(value)
+            except OSError:
+                pass
+            finally:
+                finished.set()
+
+        def log_message(self, *_):
+            pass
+
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Proxy)
+    server.daemon_threads = True
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield f"http://127.0.0.1:{server.server_port}", finished, received
+    finally:
+        stop.set()
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=5)
+
+
+@contextmanager
+def client(port):
+    with socket.create_connection(("127.0.0.1", port), timeout=5) as connection:
+        with connection.makefile("rb") as stream:
+            connection.sendall(b"CONNECT unresolvable.invalid:443 HTTP/1.1\r\nHost: ignored\r\n\r\n")
+            assert b"200" in stream.readline()
+            while stream.readline() != b"\r\n":
+                pass
+            yield connection, stream
+
+
+class TunnelActivityTests(unittest.TestCase):
+    def test_download_outlives_idle_deadline_without_client_traffic(self):
+        with tunnel("download") as (proxy, finished, _), mock.patch.object(relay, "IDLE_TIMEOUT", 1.0):
+            with relay.running(proxy) as port, client(port) as (_, stream):
+                self.assertEqual(stream.read(len(PAYLOAD)), PAYLOAD)
+            self.assertTrue(finished.wait(5))
+
+    def test_upload_outlives_idle_deadline_without_server_traffic(self):
+        with tunnel("upload") as (proxy, finished, received), mock.patch.object(relay, "IDLE_TIMEOUT", 1.0):
+            with relay.running(proxy) as port, client(port) as (connection, stream):
+                for value in PAYLOAD:
+                    connection.sendall(bytes([value]))
+                    threading.Event().wait(INTERVAL)
+                self.assertEqual(stream.read(len(PAYLOAD)), PAYLOAD)
+            self.assertTrue(finished.wait(5))
+            self.assertEqual(received, [PAYLOAD])
+
+    def test_wholly_idle_tunnel_closes_without_http_bytes(self):
+        with tunnel("idle") as (proxy, finished, received), mock.patch.object(relay, "IDLE_TIMEOUT", 0.2):
+            with relay.running(proxy) as port, client(port) as (_, stream):
+                self.assertEqual(stream.read(), b"")
+            self.assertTrue(finished.wait(5))
+            self.assertEqual(received, [b""])
+
+    def test_owner_exit_closes_active_clients_and_upstream(self):
+        with tunnel("idle") as (proxy, finished, received):
+            with relay.running(proxy) as port:
+                connection = socket.create_connection(("127.0.0.1", port), timeout=5)
+                connection.sendall(b"CONNECT unresolvable.invalid:443 HTTP/1.1\r\n\r\n")
+                self.assertIn(b"200", connection.recv(4096))
+            with connection:
+                self.assertEqual(connection.recv(4096), b"")
+            self.assertTrue(finished.wait(5))
+            self.assertEqual(received, [b""])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/backend-action/.daemux-version

@@ -1 +1 @@
-1.0.111
+1.0.112

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gowalk-cicd",
-  "version": "1.0.111",
+  "version": "1.0.112",
   "description": "Zero-config GitHub Actions delivery for iOS TestFlight and Android Google Play.",
   "type": "module",
   "bin": {