gitterm 0.0.2 → 0.0.3

package/dist/index.js

@@ -10034,7 +10034,7 @@ async function runTunnel(args) {
 `);
     }
     if (!args.port) {
-      const portInput = await prompt("Enter the local port to expose (e.g. 4096): ");
+      const portInput = await prompt("Enter the port your Opencode server is running on (e.g. 4096): ");
       const parsedPort = Number.parseInt(portInput, 10);
       if (!Number.isFinite(parsedPort) || parsedPort <= 0) {
         throw new Error("Invalid port number");
@@ -10065,25 +10065,122 @@ async function runTunnel(args) {
     primaryPort = args.port;
   }
   const exposedPorts = parseExposeArgs(args.expose);
-  const pendingRequestBodies = new Map;
-  const pendingRequestMeta = new Map;
+  const pendingRequests = new Map;
   const activeRequests = new Map;
-  function mergeBody(id) {
-    const parts = pendingRequestBodies.get(id) ?? [];
-    pendingRequestBodies.delete(id);
-    if (parts.length === 0)
-      return new Uint8Array;
-    const total = parts.reduce((sum, p) => sum + p.byteLength, 0);
-    const merged = new Uint8Array(total);
-    let off = 0;
-    for (const p of parts) {
-      merged.set(p, off);
-      off += p.byteLength;
-    }
-    return merged;
+  function createBodyStream(pending) {
+    return new ReadableStream({
+      start: (controller) => {
+        pending.bodyController = controller;
+        if (pending.bufferedChunks.length > 0) {
+          for (const chunk of pending.bufferedChunks) {
+            controller.enqueue(chunk);
+          }
+          pending.bufferedChunks = [];
+        }
+        if (pending.bodyClosed)
+          controller.close();
+      },
+      cancel: () => {
+        pending.abortController.abort();
+      }
+    });
   }
   const effectiveWsUrl = args.wsUrl ?? connectCfg?.wsUrl ?? DEFAULT_WS_URL;
   const ws = new WebSocket(effectiveWsUrl);
+  async function startUpstreamRequest(id, pending) {
+    if (pending.started)
+      return;
+    pending.started = true;
+    const meta = pending.meta;
+    const abortController = pending.abortController;
+    activeRequests.set(id, abortController);
+    try {
+      const base = new URL(targetBase.replace(/\/$/, "") + "/");
+      base.hostname = "localhost";
+      base.port = String(meta.port ?? primaryPort);
+      const url = new URL(meta.path.replace(/^\//, ""), base);
+      const headers = new Headers(meta.headers);
+      headers.delete("host");
+      headers.delete("content-length");
+      headers.delete("connection");
+      headers.delete("keep-alive");
+      headers.delete("proxy-authenticate");
+      headers.delete("proxy-authorization");
+      headers.delete("te");
+      headers.delete("trailers");
+      headers.delete("transfer-encoding");
+      headers.delete("upgrade");
+      const upstream = await fetch(url, {
+        method: meta.method,
+        headers,
+        body: pending.ignoreBody ? undefined : pending.bodyStream ?? undefined,
+        redirect: "manual",
+        signal: abortController.signal
+      });
+      ws.send(JSON.stringify({
+        type: "response",
+        id,
+        statusCode: upstream.status,
+        headers: headersToRecord(upstream.headers),
+        timestamp: Date.now()
+      }));
+      if (!upstream.body) {
+        activeRequests.delete(id);
+        ws.send(JSON.stringify({
+          type: "data",
+          id,
+          final: true,
+          timestamp: Date.now()
+        }));
+        return;
+      }
+      const reader = upstream.body.getReader();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          if (!value)
+            continue;
+          ws.send(JSON.stringify({
+            type: "data",
+            id,
+            data: bytesToBase64(value),
+            final: false,
+            timestamp: Date.now()
+          }));
+        }
+      } finally {
+        reader.releaseLock();
+      }
+      activeRequests.delete(id);
+      ws.send(JSON.stringify({
+        type: "data",
+        id,
+        final: true,
+        timestamp: Date.now()
+      }));
+    } catch (error) {
+      activeRequests.delete(id);
+      if (error instanceof Error && error.name === "AbortError") {
+        return;
+      }
+      ws.send(JSON.stringify({
+        type: "response",
+        id,
+        statusCode: 502,
+        headers: { "content-type": "application/json" },
+        timestamp: Date.now()
+      }));
+      ws.send(JSON.stringify({
+        type: "data",
+        id,
+        data: bytesToBase64(new TextEncoder().encode(JSON.stringify({ error: "upstream_error" }))),
+        final: true,
+        timestamp: Date.now()
+      }));
+    }
+  }
   ws.addEventListener("open", () => {
     console.log("Establishing secure tunnel for workspace...");
     ws.send(JSON.stringify({
@@ -10146,123 +10243,63 @@ Press Ctrl+C to disconnect.
         controller.abort();
         activeRequests.delete(frame.id);
       }
-      pendingRequestBodies.delete(frame.id);
-      pendingRequestMeta.delete(frame.id);
+      const pending = pendingRequests.get(frame.id);
+      if (pending?.bodyController) {
+        try {
+          pending.bodyController.close();
+        } catch {}
+      }
+      pendingRequests.delete(frame.id);
       return;
     }
     if (frame.type === "request") {
-      pendingRequestBodies.set(frame.id, []);
-      pendingRequestMeta.set(frame.id, {
+      const meta = {
         method: (frame.method ?? "GET").toUpperCase(),
         path: frame.path ?? "/",
         headers: frame.headers ?? {},
         port: frame.port
-      });
+      };
+      const ignoreBody = meta.method === "GET" || meta.method === "HEAD";
+      const pending = {
+        meta,
+        bodyStream: null,
+        bufferedChunks: [],
+        bodyClosed: false,
+        started: false,
+        abortController: new AbortController,
+        ignoreBody
+      };
+      pending.bodyStream = ignoreBody ? null : createBodyStream(pending);
+      pendingRequests.set(frame.id, pending);
+      startUpstreamRequest(frame.id, pending);
       return;
     }
     if (frame.type === "data") {
-      const chunks = pendingRequestBodies.get(frame.id);
-      if (!chunks) {
+      const pending = pendingRequests.get(frame.id);
+      if (!pending)
+        return;
+      if (pending.ignoreBody) {
+        if (frame.final)
+          pendingRequests.delete(frame.id);
         return;
       }
-      if (frame.data)
-        chunks.push(base64ToBytes(frame.data));
+      if (frame.data) {
+        const chunk = base64ToBytes(frame.data);
+        if (pending.bodyController) {
+          pending.bodyController.enqueue(chunk);
+        } else {
+          pending.bufferedChunks.push(chunk);
+        }
+      }
       if (!frame.final)
         return;
-      const abortController = new AbortController;
-      activeRequests.set(frame.id, abortController);
-      const meta = pendingRequestMeta.get(frame.id);
-      if (!meta)
-        return;
-      pendingRequestMeta.delete(frame.id);
-      try {
-        const reqBody = mergeBody(frame.id);
-        const base = new URL(targetBase.replace(/\/$/, "") + "/");
-        base.hostname = "localhost";
-        base.port = String(meta.port ?? primaryPort);
-        const url = new URL(meta.path.replace(/^\//, ""), base);
-        const headers = new Headers(meta.headers);
-        headers.delete("host");
-        headers.delete("content-length");
-        headers.delete("connection");
-        headers.delete("keep-alive");
-        headers.delete("proxy-authenticate");
-        headers.delete("proxy-authorization");
-        headers.delete("te");
-        headers.delete("trailers");
-        headers.delete("transfer-encoding");
-        headers.delete("upgrade");
-        const upstream = await fetch(url, {
-          method: meta.method,
-          headers,
-          body: reqBody.byteLength > 0 ? reqBody : undefined,
-          redirect: "manual",
-          signal: abortController.signal
-        });
-        ws.send(JSON.stringify({
-          type: "response",
-          id: frame.id,
-          statusCode: upstream.status,
-          headers: headersToRecord(upstream.headers),
-          timestamp: Date.now()
-        }));
-        if (!upstream.body) {
-          activeRequests.delete(frame.id);
-          ws.send(JSON.stringify({
-            type: "data",
-            id: frame.id,
-            final: true,
-            timestamp: Date.now()
-          }));
-          return;
-        }
-        const reader = upstream.body.getReader();
+      pending.bodyClosed = true;
+      if (pending.bodyController) {
         try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-              break;
-            if (!value)
-              continue;
-            ws.send(JSON.stringify({
-              type: "data",
-              id: frame.id,
-              data: bytesToBase64(value),
-              final: false,
-              timestamp: Date.now()
-            }));
-          }
-        } finally {
-          reader.releaseLock();
-        }
-        activeRequests.delete(frame.id);
-        ws.send(JSON.stringify({
-          type: "data",
-          id: frame.id,
-          final: true,
-          timestamp: Date.now()
-        }));
-      } catch (error) {
-        activeRequests.delete(frame.id);
-        pendingRequestBodies.delete(frame.id);
-        if (error instanceof Error && error.name === "AbortError") {
-          return;
-        }
-        ws.send(JSON.stringify({
-          type: "response",
-          id: frame.id,
-          statusCode: 502,
-          headers: { "content-type": "application/json" },
-          timestamp: Date.now()
-        }));
-        ws.send(JSON.stringify({
-          type: "data",
-          id: frame.id,
-          data: bytesToBase64(new TextEncoder().encode(JSON.stringify({ error: "upstream_error" }))),
-          final: true,
-          timestamp: Date.now()
-        }));
+          pending.bodyController.close();
+        } catch {}
       }
+      pendingRequests.delete(frame.id);
     }
   });
   ws.addEventListener("close", () => {
@@ -10282,8 +10319,7 @@ Disconnecting...`);
     controller.abort();
   }
   activeRequests.clear();
-  pendingRequestBodies.clear();
-  pendingRequestMeta.clear();
+  pendingRequests.clear();
   try {
     ws.close();
   } catch {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitterm",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Complete suit of gitterm tools in one CLI",
   "keywords": [
     "gitterm",